0
00:00:00,000 --> 00:00:10,000
Entonces, vamos a grabar, todo lo que digáis me lo autoriza que esto sea grabado, y vamos

1
00:00:10,000 --> 00:00:16,000
a ver un poquito más sobre los objetos, en particular sobre el desarrollo de clases.

2
00:00:16,000 --> 00:00:26,000
Este es un apartado que incluye varios conceptos sobre los que hablaremos un ratito para entenderlos

3
00:00:26,000 --> 00:00:34,000
y luego después hay una tanda de ejercicios que va más o menos a trabajar sobre estos.

4
00:00:34,000 --> 00:00:42,000
El primer concepto es el metodomain, el metodomain ya lo conocéis, ya lo habéis usado mil veces,

5
00:00:42,000 --> 00:00:50,000
sin embargo vamos a verlo, no lo digo más en profundidad, entenderlo un poquito mejor.

6
00:00:50,000 --> 00:00:57,000
El prototipo, el prototipo es sustancialmente las palabras claves que se han utilizado para crear el metodomain,

7
00:00:57,000 --> 00:01:04,000
es el que siempre utilizamos, public static, void main, string, array, args.

8
00:01:04,000 --> 00:01:13,000
Entonces, main es el nombre, es como se llama este método, es el metodomain, es un método público,

9
00:01:13,000 --> 00:01:22,000
se puede ejecutar públicamente, esto no lo hemos visto todavía, lo veremos al final de estas transparencias que son los varios cambios.

10
00:01:22,000 --> 00:01:30,000
Static es que es un método estático, no se refiere a un objeto concreto, se ejecuta en ámbito estático,

11
00:01:30,000 --> 00:01:36,000
de hecho nosotros no creamos un objeto para luego poder ejecutar el main, se ejecuta directamente.

12
00:01:36,000 --> 00:01:46,000
No devuelve nada, void, no se espera que devuelva nada de esto, y pilla como parámetro un array de strings.

13
00:01:46,000 --> 00:01:52,000
Cosa que siempre hemos escrito aquí, y nunca nos hemos preguntado que es esto.

14
00:01:52,000 --> 00:01:59,000
Y ahora iremos a ver que es esta cosa aquí.

15
00:01:59,000 --> 00:02:08,000
En general, este es el punto de acceso a mi programa, cada sistema, cada conjunto de clases, cada conjunto de objetos,

16
00:02:08,000 --> 00:02:16,000
y tened en cuenta que ahora cuando empezaremos la programación orientada a objetos, tendremos muchas clases,

17
00:02:16,000 --> 00:02:24,000
muchas clases de objetos distintos que trabajarán entre ellos, mandándose mensajes, llamando un método de un a otro,

18
00:02:25,000 --> 00:02:34,000
pero tendrá siempre que haber en todo este conjunto de no se cuantas clases, un punto que es de aquí empieza mi programa.

19
00:02:34,000 --> 00:02:40,000
Este es el punto donde todo empieza, y esto normalmente suele ser el método main.

20
00:02:44,000 --> 00:02:52,000
El string of args es sustancialmente los parámetros con que ejecuto mi programa.

21
00:02:52,000 --> 00:03:04,000
Vosotros os acordáis que cuando hicimos la clase miclase a principio, una de las primeras prácticas que hicimos fue ejecutar una clase desde línea de comando.

22
00:03:04,000 --> 00:03:16,000
Entonces lanzamos dos comandos, por un lado el javac de miclase.java, y esto lo que hacía era crear un miclase.class, os acordáis,

23
00:03:16,000 --> 00:03:23,000
era la primera parte, era como un compilador de java, pero sabemos que java no es compilado, es interpretado,

24
00:03:23,000 --> 00:03:31,000
tenemos un programa que se llama la java virtual machine, que lo que hace es leer el punto class,

25
00:03:31,000 --> 00:03:37,000
que hay un lenguaje especial que se llama el bytecode, que es la mitad entre el java y el lenguaje máquina,

26
00:03:37,000 --> 00:03:46,000
y lo que hace es ejecutar e interpretar cada una de las instrucciones del lenguaje máquina y pasársela al procesador.

27
00:03:46,000 --> 00:03:53,000
Cuando nosotros llamamos java miclase, él ejecuta miclase empezando desde el main.

28
00:03:53,000 --> 00:04:02,000
¿Qué pasa si yo llamo java miclase y luego le pongo detrás algo, tres y otra cosa?

29
00:04:03,000 --> 00:04:07,000
¿Si lanzo esto en vez que solo java miclase?

30
00:04:07,000 --> 00:04:11,000
¿Qué le pasa a estas cosas de aquí, que normalmente son los parámetros?

31
00:04:11,000 --> 00:04:17,000
Si vosotros habéis utilizado en algunas otras asignaturas la línea de comando, el cmd,

32
00:04:17,000 --> 00:04:24,000
y habéis hecho un ping, habéis hecho cualquier comando, muchas veces el comando es el programa que vais a ejecutar,

33
00:04:24,000 --> 00:04:29,000
y luego detrás tiene un conjunto de parámetros que se pueden lanzar.

34
00:04:29,000 --> 00:04:35,000
Imaginémonos que yo hago un programa que necesita parámetros, que cuando se lanza necesita parámetros,

35
00:04:35,000 --> 00:04:39,000
como este de aquí, que necesita esta palabra, este número y otra palabra.

36
00:04:39,000 --> 00:04:44,000
¿Dónde acaban estos parámetros de aquí dentro de mi programa?

37
00:04:44,000 --> 00:04:46,000
Pues acaban en args.

38
00:04:47,000 --> 00:05:00,000
Cuando yo ejecuto java miclase algo, tres, otra cosa, en args de cero, en la posición cero de mi array args,

39
00:05:00,000 --> 00:05:04,000
encontraré esta palabra de aquí, algo, como string.

40
00:05:04,000 --> 00:05:08,000
¿Por qué como string? Porque es un array string.

41
00:05:09,000 --> 00:05:10,000
¿Sí?

42
00:05:11,000 --> 00:05:17,000
Luego está otra palabra que es tres, entonces en args de uno encontraré tres.

43
00:05:17,000 --> 00:05:25,000
Cuidado, como string, porque no es un entero, no es el entero tres, es la cadena de caracteres,

44
00:05:25,000 --> 00:05:28,000
el carácter tres y nada más.

45
00:05:28,000 --> 00:05:35,000
Que luego yo pueda de alguna forma convertir ese carácter de allí en un número, pues eso ya veremos que se puede hacer.

46
00:05:35,000 --> 00:05:40,000
Pero por ahora es el string tres, es esta cosa de aquí.

47
00:05:50,000 --> 00:05:53,000
Y en args de dos, otra cosa.

48
00:05:54,000 --> 00:06:00,000
Imaginémonos que yo esté dentro de un main, estoy en el método main.

49
00:06:00,000 --> 00:06:05,000
La pregunta es, ¿cómo puedo saber cuántos parámetros me han pasado?

50
00:06:16,000 --> 00:06:21,000
Imaginémonos que nosotros estamos en una clase, clase prueba.

51
00:06:25,000 --> 00:06:27,000
Estoy aquí dentro.

52
00:06:31,000 --> 00:06:34,000
Estoy aquí dentro, ¿vale?

53
00:06:34,000 --> 00:06:44,000
Y la pregunta es, quiero saber aquí dentro en tiempo de ejecución, cuando se ejecute esto, cuántos parámetros me han pasado.

54
00:06:46,000 --> 00:06:52,000
¿Cómo sabré cuántos parámetros me han pasado? Pues con args.length.

55
00:06:52,000 --> 00:06:53,000
args.length.

56
00:06:57,000 --> 00:07:03,000
Esta cosa de aquí me define cuántas posiciones tiene args.

57
00:07:05,000 --> 00:07:17,000
Y como por cada parámetro que me dan, yo lo voy a poniendo en una posición distinta, pues al final si me han dado cinco parámetros, pues tendré cinco posiciones.

58
00:07:17,000 --> 00:07:20,000
Entonces args.length será cinco.

59
00:07:22,000 --> 00:07:39,000
Entonces esto, por ejemplo, se puede utilizar para hacer cosas como, imaginaos, si args.length es igual a cero.

60
00:07:40,000 --> 00:07:54,000
Si alguien ha intentado lanzar mi programa sin darme ningún parámetro de ejecución, y yo necesito parámetros de ejecución, pues le puedo poner,

61
00:07:55,000 --> 00:08:02,000
sigo diciendo, este programa se usa así.

62
00:08:06,000 --> 00:08:11,000
Y ponerle las instrucciones para poderla lanzar.

63
00:08:16,000 --> 00:08:21,000
Java, prueba tu nombre.

64
00:08:25,000 --> 00:08:35,000
Entonces, ¿qué pasa? Que si yo lanzo este programa aquí, me dirá, mira, este programa se usa así.

65
00:08:35,000 --> 00:08:37,000
Java, prueba tu nombre.

66
00:08:37,000 --> 00:08:46,000
Entonces ahora ya sé que no puedo lanzar Java prueba solo, sino necesito añadirle otro parámetro aquí que sea tu nombre.

67
00:08:47,000 --> 00:08:49,000
¿Qué hace esto?

68
00:08:49,000 --> 00:09:02,000
Si no, esto quiere decir que args.length no es igual a cero, y por lo tanto hay algo en args.length, hay al menos la posición cero.

69
00:09:02,000 --> 00:09:14,000
Y, por ejemplo, lo que hace mi programa es decirte, hola, más args de cero.

70
00:09:16,000 --> 00:09:21,000
Fijaos que aquí args de cero no está por ningún lado, nadie lo ha rellenado.

71
00:09:21,000 --> 00:09:27,000
Y si yo lo lanzo, pues siempre me dará este de aquí porque no le he puesto ningún nombre.

72
00:09:27,000 --> 00:09:39,000
Si lo lanzara desde línea de comando, desde el cmd, y escribiera Java prueba y mi nombre, Stefano, pues probablemente me escribiría hola Stefano.

73
00:09:39,000 --> 00:09:48,000
¿Cómo hago en Eclipse para que cuando él se ejecute tenga algo en los parámetros?

74
00:09:48,000 --> 00:09:50,000
Como argumento.

75
00:09:50,000 --> 00:10:02,000
En ejecución aquí puedo utilizar Run Configurations.

76
00:10:02,000 --> 00:10:07,000
En Run Configurations hay una opción de argumentos.

77
00:10:07,000 --> 00:10:13,000
Lo que yo escribo aquí es como si lo escribiera después de Java prueba.

78
00:10:13,000 --> 00:10:20,000
Entonces escribo Stefano aquí, es como si estuviera lanzando Java prueba Stefano.

79
00:10:20,000 --> 00:10:34,000
Entonces, ahora cuando lo lanzo, porque ahora ya algo hay, Stefano lo ha puesto dentro de args de cero,

80
00:10:34,000 --> 00:10:42,000
por lo tanto args.length no es cero, sino es uno, por lo tanto me va en la rama else y aquí me puede escribir.

81
00:10:43,000 --> 00:10:46,000
¿Para qué me pueden servir estas cosas?

82
00:10:46,000 --> 00:10:56,000
Porque a veces nosotros podemos hablar con el usuario y decirle, no, yo lanzo un programa y digo, vale, usuario, dame tu nombre y yo escribo su nombre.

83
00:10:56,000 --> 00:11:02,000
Pero otras veces yo no tengo interacción con un usuario, yo tengo que hacer una operación.

84
00:11:02,000 --> 00:11:09,000
Y esta operación tiene que estar hecha sobre un fichero, sobre un objeto, sobre algo.

85
00:11:09,000 --> 00:11:19,000
O un string, o que use algo que al momento de ejecutarlo me digan cuáles son los argumentos, cuáles son los parámetros que voy a utilizar.

86
00:11:19,000 --> 00:11:29,000
Si pensáis en un programa como el copiar ficheros, que no sé si lo habéis visto, xcopy, nombre del fichero, espacio, otro nombre del fichero,

87
00:11:29,000 --> 00:11:33,000
que copia el primer fichero dentro del segundo fichero.

88
00:11:33,000 --> 00:11:36,000
Pues los dos ficheros al fin y al cabo son parámetros.

89
00:11:36,000 --> 00:11:45,000
Si yo quisiera hacer la clase copia fichero, que lo que hace es pillar dos ficheros y copiarlos de uno a otro y usarlo directamente en línea de comando,

90
00:11:45,000 --> 00:11:49,000
pues lo debería hacer con esta cosa aquí.

91
00:11:49,000 --> 00:12:01,000
A lo mejor en un futuro, en algunos ejemplos y en algunas circunstancias, usaremos este fichero, este array.

92
00:12:01,000 --> 00:12:05,000
La cosa fundamental de por qué lo estamos viendo es para saber qué es esto.

93
00:12:05,000 --> 00:12:10,000
Porque desde el día uno lo hemos puesto allí y no sabíamos hasta ahora para qué servía.

94
00:12:10,000 --> 00:12:20,000
A partir de ahora sabemos tanto para qué sirve y cómo lo puedo utilizar dentro del Eclipse.

95
00:12:23,000 --> 00:12:24,000
¿Dudas?

96
00:12:32,000 --> 00:12:34,000
Esto es string.args.

97
00:12:34,000 --> 00:12:38,000
Otros conceptos que nos interesan a nivel de clase.

98
00:12:38,000 --> 00:12:44,000
Como hay un método main, normalmente en un conjunto de clases debería haber una clase main.

99
00:12:44,000 --> 00:12:47,000
La clase main no se tiene que llamar main.

100
00:12:47,000 --> 00:12:51,000
Tiene que existir una clase que se llame main así.

101
00:12:51,000 --> 00:12:54,000
No necesariamente.

102
00:12:54,000 --> 00:12:58,000
Pero cuando yo hago un proyecto, sobre todo si el proyecto es suficientemente grande,

103
00:12:58,000 --> 00:13:03,000
y hemos dicho ahora que tengo varias clases y muchas clases y me las encuentro allí,

104
00:13:03,000 --> 00:13:08,000
debería ser relativamente fácil saber cuál es la clase que yo lanzo.

105
00:13:08,000 --> 00:13:18,000
Pensad al ejemplo que hemos hecho antes del examen, que había la clase alumno, había la clase prueba.

106
00:13:18,000 --> 00:13:27,000
Yo si me encuentro un montón de ficheros.java, no sé dónde está el punto de acceso de mi programa.

107
00:13:27,000 --> 00:13:32,000
Por lo tanto, normalmente cuando yo hago una estructura, un proyecto con muchas clases,

108
00:13:32,000 --> 00:13:35,000
debería elegir una clase y decir esta es la clase que se ejecuta.

109
00:13:35,000 --> 00:13:37,000
Esta es la que tiene el main.

110
00:13:37,000 --> 00:13:43,000
Todos los demás clases no necesariamente no tienen que tener el main.

111
00:13:43,000 --> 00:13:47,000
Pueden tenerlo, pero no es el punto de acceso de mi programa.

112
00:13:47,000 --> 00:13:56,000
Normalmente, las otras clases pueden tener un main para hacer pruebas concretas de esa clase.

113
00:13:56,000 --> 00:14:03,000
Yo podría poner en el ejemplo que hacíamos antes de alumno, un main dentro de alumno,

114
00:14:03,000 --> 00:14:06,000
para probar el objeto alumno.

115
00:14:06,000 --> 00:14:11,000
Creo un objeto alumno, le pruebo los métodos, le pongo unos datos y cosa por el estilo.

116
00:14:11,000 --> 00:14:15,000
Pero luego, mi programa de verdad no es eso.

117
00:14:16,000 --> 00:14:21,000
Esta práctica de poner un método main dentro de una clase para probarla,

118
00:14:21,000 --> 00:14:27,000
prácticamente hoy en día se usa poco porque hay otras utilidades como el JUnit,

119
00:14:27,000 --> 00:14:31,000
que son pruebas unitarias, que lo veremos más adelante,

120
00:14:31,000 --> 00:14:34,000
a lo mejor lo veréis en el entorno de programación, eso ya lo veremos.

121
00:14:34,000 --> 00:14:43,000
Pero son bacterias de pruebas que yo hago para probar extensamente mis clases, mis objetos.

122
00:14:43,000 --> 00:14:46,000
Entonces, en vez de hacerlo con un main allí dentro que hago lo que me da la gana,

123
00:14:46,000 --> 00:14:53,000
pues tengo esta bacteria de pruebas que está hecha para otros equipos desarrolladores,

124
00:14:53,000 --> 00:14:59,000
a lo mejor de mi empresa, para que me digan, si tú haces todas estas pruebas y todas las pruebas te dan ok,

125
00:14:59,000 --> 00:15:06,000
pues probablemente tu objeto hace las funcionalidades por las que está pensado.

126
00:15:06,000 --> 00:15:09,000
Pero lo veremos más adelante.

127
00:15:09,000 --> 00:15:14,000
Por ahora, para nosotros, si vosotros estáis haciendo un examen, un ejercicio que tiene 5 clases,

128
00:15:14,000 --> 00:15:20,000
y habéis creado la clase alumno que tiene su método de calcular media,

129
00:15:20,000 --> 00:15:24,000
y queréis probar ese alumno, pues os hacéis un main dentro de esa clase,

130
00:15:24,000 --> 00:15:30,000
allí dentro creáis un objeto, le rellenáis las notas y probáis la clase media, el método media,

131
00:15:30,000 --> 00:15:32,000
para ver si funciona.

132
00:15:32,000 --> 00:15:37,000
Pero no es el punto de acceso de todo el sistema, es el punto de acceso para probar alumno.

133
00:15:37,000 --> 00:15:39,000
¿Me entendéis?

134
00:15:39,000 --> 00:15:43,000
Por otro lado, deberíais crear una clase que podría llamarse main,

135
00:15:43,000 --> 00:15:48,000
porque es fácil de detectar, o podría llamarse de otra forma,

136
00:15:48,000 --> 00:15:51,000
como el ejemplo de DAIO competición, ¿os acordáis?

137
00:15:51,000 --> 00:15:55,000
Que allí dentro había el main, esa era mi clase main en el examen.

138
00:15:57,000 --> 00:16:02,000
Vale, no tiene por qué llamarse main, pero es la clase detonante,

139
00:16:02,000 --> 00:16:04,000
la clase que hace partir todo mi proyecto.

140
00:16:04,000 --> 00:16:11,000
Concepto de static y no static, que ya hemos repasado hace un momento,

141
00:16:11,000 --> 00:16:14,000
pero vamos a hacerlo un poquito más en detalle.

142
00:16:14,000 --> 00:16:21,000
Un método o una variable puede ser static o no static.

143
00:16:21,000 --> 00:16:27,000
Cuando no es estático, cuando no se considera un método no es estático.

144
00:16:27,000 --> 00:16:33,000
No se usa cuando me estoy refiriendo a algo que depende de un objeto concreto,

145
00:16:34,000 --> 00:16:40,000
o sea, esa variable, ese atributo o ese método,

146
00:16:40,000 --> 00:16:47,000
necesita ser llamado sobre un objeto concreto,

147
00:16:47,000 --> 00:16:53,000
porque utiliza características de ese objeto concreto para funcionar.

148
00:16:53,000 --> 00:16:54,000
¿Vale?

149
00:16:54,000 --> 00:16:58,000
Eso quiere decir que si hago la misma operación, acceder a una variable,

150
00:16:58,000 --> 00:17:02,000
o llamar un método sobre objetos distintos,

151
00:17:02,000 --> 00:17:07,000
el resultado que puedo obtener es distinto,

152
00:17:07,000 --> 00:17:16,000
porque usará objetos o usará variables propias del objeto.

153
00:17:18,000 --> 00:17:22,000
Un atributo de una clase aparecerá en todas las instancias de esa clase,

154
00:17:22,000 --> 00:17:25,000
y por cada instancia tiene un valor distinto de ese atributo,

155
00:17:25,000 --> 00:17:30,000
y ese atributo no es estático, porque cada instancia tiene su propio atributo.

156
00:17:30,000 --> 00:17:34,000
Un valor distinto, o sea, el valor puede ser el mismo,

157
00:17:34,000 --> 00:17:39,000
pero son copias distintas del mismo valor.

158
00:17:43,000 --> 00:17:46,000
Cuando yo tengo un atributo que no es estático,

159
00:17:46,000 --> 00:17:49,000
quiere decir que cada objeto tiene su propia copia.

160
00:17:49,000 --> 00:17:56,000
Cada objeto tiene su celda de memoria donde dentro almacenará ese valor.

161
00:17:56,000 --> 00:17:57,000
¿Vale?

162
00:17:57,000 --> 00:18:02,000
Y que dos objetos distintos tienen dos valores distintos,

163
00:18:02,000 --> 00:18:05,000
si yo cambio en uno, no lo estoy cambiando en el otro.

164
00:18:05,000 --> 00:18:06,000
¿Vale?

165
00:18:06,000 --> 00:18:08,000
El valor de esa variable.

166
00:18:08,000 --> 00:18:10,000
Cuidado que si luego esa variable es un objeto,

167
00:18:10,000 --> 00:18:12,000
puede haber cosas un poquito más complejas,

168
00:18:12,000 --> 00:18:14,000
pero lo hablaremos más después.

169
00:18:14,000 --> 00:18:15,000
¿Vale?

170
00:18:15,000 --> 00:18:16,000
Pensadlo como int.

171
00:18:16,000 --> 00:18:19,000
Si yo tengo una persona con int edad.

172
00:18:19,000 --> 00:18:20,000
¿Vale?

173
00:18:20,000 --> 00:18:22,000
Si yo tengo dos personas, dos objetos personas,

174
00:18:22,000 --> 00:18:28,000
la variable int de que estas objetos personas son separadas, son distintas.

175
00:18:28,000 --> 00:18:29,000
¿Vale?

176
00:18:29,000 --> 00:18:32,000
Si yo cambio la edad de un objeto, no la estoy cambiando en otro.

177
00:18:32,000 --> 00:18:33,000
¿Si?

178
00:18:33,000 --> 00:18:35,000
Los dos pueden tener la misma edad,

179
00:18:35,000 --> 00:18:39,000
pero son dos valores separados, son dos trozos de memoria separados.

180
00:18:39,000 --> 00:18:40,000
Digámoslo así.

181
00:18:40,000 --> 00:18:41,000
¿Si?

182
00:18:41,000 --> 00:18:46,000
Y el método no es estático cuando tú lo tienes que llamar sobre un objeto concreto.

183
00:18:46,000 --> 00:18:49,000
Al llamar este método sobre un objeto concreto,

184
00:18:49,000 --> 00:18:54,000
utilizará valores, atributos y hará operaciones sobre ese objeto,

185
00:18:54,000 --> 00:18:57,000
no sobre los otros objetos.

186
00:18:57,000 --> 00:18:58,000
¿Si?

187
00:18:58,000 --> 00:19:00,000
Entonces, en un cierto sentido, si no es estático,

188
00:19:00,000 --> 00:19:04,000
tiene una independencia por cada objeto distinto.

189
00:19:04,000 --> 00:19:08,000
Cada objeto distinto es independiente de lo que hace,

190
00:19:08,000 --> 00:19:12,000
de los valores que tiene con respecto a otros objetos.

191
00:19:12,000 --> 00:19:15,000
Dudas.

192
00:19:15,000 --> 00:19:17,000
Ejemplo.

193
00:19:17,000 --> 00:19:18,000
¿Vale?

194
00:19:18,000 --> 00:19:21,000
Pillamos la clase rectángulo.

195
00:19:21,000 --> 00:19:23,000
Aquí está la clase rectángulo.

196
00:19:23,000 --> 00:19:25,000
¿Qué modeliza?

197
00:19:25,000 --> 00:19:26,000
Modeliza un rectángulo.

198
00:19:26,000 --> 00:19:27,000
¿Vale?

199
00:19:27,000 --> 00:19:29,000
¿Qué necesito poner para un rectángulo?

200
00:19:29,000 --> 00:19:32,000
Pues un entero que es el largo del rectángulo,

201
00:19:32,000 --> 00:19:34,000
y un entero que es el ancho del rectángulo.

202
00:19:34,000 --> 00:19:35,000
¿Vale?

203
00:19:35,000 --> 00:19:37,000
Estos son sus atributos.

204
00:19:37,000 --> 00:19:41,000
¿Qué valores, qué métodos tiene?

205
00:19:41,000 --> 00:19:42,000
¿Vale?

206
00:19:42,000 --> 00:19:44,000
No tiene un constructor, no se lo he puesto,

207
00:19:44,000 --> 00:19:48,000
pero tiene un método que es el método setData.

208
00:19:48,000 --> 00:19:49,000
¿Vale?

209
00:19:49,000 --> 00:19:50,000
Aquí podría poner el public.

210
00:19:50,000 --> 00:19:52,000
No pone public, pero no cambia nada por ahora.

211
00:19:52,000 --> 00:19:55,000
El método setData pilla dos variables,

212
00:19:55,000 --> 00:19:57,000
L y B,

213
00:19:57,000 --> 00:19:59,000
y pone que L es largo,

214
00:19:59,000 --> 00:20:01,000
y B es el ancho.

215
00:20:01,000 --> 00:20:02,000
Ya está.

216
00:20:02,000 --> 00:20:03,000
Esto debería ser A.

217
00:20:03,000 --> 00:20:04,000
Pero bueno.

218
00:20:04,000 --> 00:20:05,000
Se me ha colado la vida.

219
00:20:05,000 --> 00:20:06,000
¿Si?

220
00:20:06,000 --> 00:20:09,000
Tiene otro método que es el método Area.

221
00:20:09,000 --> 00:20:11,000
Fijaos que Area no tiene parámetros.

222
00:20:11,000 --> 00:20:16,000
Y lo que hace es calcular el área de este rectángulo.

223
00:20:16,000 --> 00:20:17,000
¿Vale?

224
00:20:17,000 --> 00:20:19,000
Utilizando estos datos de aquí.

225
00:20:19,000 --> 00:20:23,000
Y después de haber calculado el área, la devuelvo.

226
00:20:23,000 --> 00:20:24,000
¿Si?

227
00:20:24,000 --> 00:20:26,000
Entonces, ¿cómo uso estas cosas?

228
00:20:26,000 --> 00:20:28,000
Por ejemplo, aquí tengo un Main.

229
00:20:28,000 --> 00:20:29,000
¿Vale?

230
00:20:29,000 --> 00:20:30,000
Esta sería la clase Main.

231
00:20:30,000 --> 00:20:31,000
¿Si?

232
00:20:31,000 --> 00:20:34,000
Y lo que hace es crearme dos rectángulos.

233
00:20:34,000 --> 00:20:35,000
¿Si?

234
00:20:35,000 --> 00:20:37,000
Fijaos que los rectángulos no tienen constructor.

235
00:20:37,000 --> 00:20:39,000
Por lo tanto, es un constructor vacío.

236
00:20:39,000 --> 00:20:43,000
En este momento, yo he creado dos objetos rectángulos,

237
00:20:43,000 --> 00:20:47,000
y los dos tendrán 0 y 0 en sus valores.

238
00:20:47,000 --> 00:20:48,000
¿Vale?

239
00:20:48,000 --> 00:20:50,000
Porque 20 por defecto vale 0.

240
00:20:50,000 --> 00:20:54,000
Y luego, sobre el rectángulo 1,

241
00:20:54,000 --> 00:20:56,000
llamo el método setData.

242
00:20:56,000 --> 00:20:58,000
Este setData de aquí.

243
00:20:58,000 --> 00:20:59,000
¿Vale?

244
00:20:59,000 --> 00:21:02,000
Que recibe dos parámetros.

245
00:21:02,000 --> 00:21:05,000
Son 5 y 6, por ejemplo.

246
00:21:05,000 --> 00:21:09,000
Si yo hago esta cosa de setData 5 y 6,

247
00:21:09,000 --> 00:21:11,000
lo que quiere decir es que he cambiado,

248
00:21:11,000 --> 00:21:13,000
he modificado el rectángulo 1.

249
00:21:13,000 --> 00:21:19,000
Que ahora tendrá rectángulo1.largo será 5,

250
00:21:19,000 --> 00:21:24,000
y rectángulo1.ancho será 6.

251
00:21:24,000 --> 00:21:25,000
Justo.

252
00:21:25,000 --> 00:21:28,000
¿He cambiado algo de rectángulo 2?

253
00:21:28,000 --> 00:21:29,000
No.

254
00:21:29,000 --> 00:21:32,000
Son dos instancias completamente separadas.

255
00:21:32,000 --> 00:21:34,000
No dependen una de otra.

256
00:21:34,000 --> 00:21:35,000
¿Si?

257
00:21:35,000 --> 00:21:41,000
Y cuando calculo rectángulo1.área,

258
00:21:41,000 --> 00:21:46,000
lo que me hará es ir a mirar este método

259
00:21:46,000 --> 00:21:48,000
sobre rectángulo 1.

260
00:21:48,000 --> 00:21:50,000
Este método pillará largo y ancho.

261
00:21:50,000 --> 00:21:52,000
Largo ahora vale 5,

262
00:21:52,000 --> 00:21:55,000
y ancho ahora vale 6.

263
00:21:55,000 --> 00:21:58,000
Por lo tanto me hará 6 multiplicado 5,

264
00:21:58,000 --> 00:22:00,000
y aquí el resultado,

265
00:22:00,000 --> 00:22:02,000
cuando escribo área de rectángulo 1,

266
00:22:02,000 --> 00:22:06,000
será el resultado de la operación 5x6.

267
00:22:06,000 --> 00:22:08,000
¿Si?

268
00:22:08,000 --> 00:22:13,000
Ahora voy a llamar setData sobre el otro objeto.

269
00:22:13,000 --> 00:22:17,000
Entonces esto modificará los datos de rectángulo 2,

270
00:22:17,000 --> 00:22:19,000
no de rectángulo 1.

271
00:22:19,000 --> 00:22:21,000
Rectángulo 1 es completamente independiente.

272
00:22:21,000 --> 00:22:23,000
Y cuando llamo el mismo método,

273
00:22:23,000 --> 00:22:25,000
es siempre área, es el mismo código,

274
00:22:25,000 --> 00:22:28,000
pero sobre un objeto distinto,

275
00:22:28,000 --> 00:22:31,000
ahora los datos que estoy utilizando

276
00:22:31,000 --> 00:22:33,000
no son los de rectángulo 1,

277
00:22:33,000 --> 00:22:36,000
sino son los de rectángulo 2.

278
00:22:36,000 --> 00:22:39,000
Entonces serán 1 y 3.

279
00:22:39,000 --> 00:22:44,000
Largo 1, ancho 3, 1x3, 3.

280
00:22:44,000 --> 00:22:46,000
Entonces área valdrá 3.

281
00:22:46,000 --> 00:22:50,000
Entonces el resultado de llamar área

282
00:22:50,000 --> 00:22:52,000
sobre rectángulo 1

283
00:22:52,000 --> 00:22:55,000
dependerá de los valores de rectángulo 1,

284
00:22:55,000 --> 00:22:59,000
y el resultado de llamar área sobre rectángulo 2

285
00:22:59,000 --> 00:23:01,000
dependerá de los valores de rectángulo 2.

286
00:23:01,000 --> 00:23:04,000
Fijaos que estos métodos,

287
00:23:04,000 --> 00:23:05,000
como tanto setData,

288
00:23:05,000 --> 00:23:08,000
se están llamando sobre una instancia.

289
00:23:08,000 --> 00:23:11,000
Esta de aquí, rec1 y rec2,

290
00:23:11,000 --> 00:23:16,000
son instancias de la clase rectángulo.

291
00:23:16,000 --> 00:23:21,000
¿Dudas?

292
00:23:21,000 --> 00:23:24,000
Todo esto estamos en un ejemplo

293
00:23:24,000 --> 00:23:26,000
de métodos no estáticos.

294
00:23:26,000 --> 00:23:28,000
¿Veis que aquí estático no existe?

295
00:23:28,000 --> 00:23:29,000
No lo he puesto.

296
00:23:29,000 --> 00:23:30,000
El único estático que aparece es esto,

297
00:23:30,000 --> 00:23:31,000
porque es el main,

298
00:23:31,000 --> 00:23:33,000
porque tiene que ser así,

299
00:23:33,000 --> 00:23:35,000
es el punto de acceso a mi programa.

300
00:23:35,000 --> 00:23:37,000
Pero luego aquí todo lo que estoy haciendo

301
00:23:37,000 --> 00:23:43,000
son sobre instancias, no sobre clases.

302
00:23:43,000 --> 00:23:45,000
¿Dudas?

303
00:23:46,000 --> 00:23:54,000
¿Cuándo en vez se utiliza el estático?

304
00:23:54,000 --> 00:23:57,000
¿Cuándo tenemos que ver algo con estático?

305
00:23:57,000 --> 00:24:00,000
Un entorno es estático cuando me refiero

306
00:24:00,000 --> 00:24:03,000
a algo que no pertenece a un objeto concreto,

307
00:24:03,000 --> 00:24:05,000
sino a la clase.

308
00:24:05,000 --> 00:24:08,000
Es algo que tiene que ver con la clase,

309
00:24:08,000 --> 00:24:11,000
no con una instancia de esa clase.

310
00:24:11,000 --> 00:24:14,000
Son métodos o son variables

311
00:24:14,000 --> 00:24:17,000
que no tienen nada que ver con un objeto o con otro.

312
00:24:17,000 --> 00:24:21,000
En un objeto o en otro objeto distinto

313
00:24:21,000 --> 00:24:26,000
el método o esa variable es lo mismo.

314
00:24:26,000 --> 00:24:30,000
No dependen de si lo estoy utilizando

315
00:24:30,000 --> 00:24:32,000
sobre una instancia o sobre otra.

316
00:24:32,000 --> 00:24:36,000
Son independientes de la instancia.

317
00:24:36,000 --> 00:24:38,000
Entonces una variable estática tendrá el mismo valor

318
00:24:38,000 --> 00:24:40,000
para cualquier objeto que la use.

319
00:24:40,000 --> 00:24:41,000
Si un objeto usa esa variable

320
00:24:41,000 --> 00:24:43,000
o otro objeto usa esa variable,

321
00:24:43,000 --> 00:24:45,000
no es que dependen de la instancia,

322
00:24:45,000 --> 00:24:47,000
sino que valdrá el mismo valor.

323
00:24:47,000 --> 00:24:51,000
Es como si las varias instancias

324
00:24:51,000 --> 00:24:54,000
compartieran esta variable

325
00:24:54,000 --> 00:24:56,000
y cuando uno modifica esta variable

326
00:24:56,000 --> 00:25:00,000
todos los demás ven esa modificación.

327
00:25:00,000 --> 00:25:04,000
No hay un trozo de memoria por cada instancia

328
00:25:04,000 --> 00:25:06,000
donde dentro se guarda un valor,

329
00:25:06,000 --> 00:25:09,000
sino que hay un trozo de memoria solo

330
00:25:09,000 --> 00:25:11,000
y todos los que la usan

331
00:25:11,000 --> 00:25:12,000
utilizan ese trozo de memoria.

332
00:25:12,000 --> 00:25:14,000
Por lo tanto, si alguien lo modifica

333
00:25:14,000 --> 00:25:18,000
todos verán esa modificación.

334
00:25:18,000 --> 00:25:22,000
Y un método estático no se llama sobre un objeto,

335
00:25:22,000 --> 00:25:24,000
sino que se llama sobre una clase.

336
00:25:24,000 --> 00:25:26,000
Entonces un método estático

337
00:25:26,000 --> 00:25:33,000
no puede tener acceso a las variables no estáticas.

338
00:25:33,000 --> 00:25:38,000
Si yo tengo un objeto,

339
00:25:38,000 --> 00:25:41,000
tengo mi objeto rectángulo 1,

340
00:25:41,000 --> 00:25:44,000
con dentro su largo y su ancho.

341
00:25:44,000 --> 00:25:46,000
Estos son trozos de memoria

342
00:25:46,000 --> 00:25:50,000
donde dentro le pongo que era 5 y 6.

343
00:25:50,000 --> 00:25:51,000
Este es el 1.

344
00:25:51,000 --> 00:25:54,000
Luego tenía otro rectángulo distinto

345
00:25:54,000 --> 00:25:57,000
que era el 2, que tenía lado 1,

346
00:25:57,000 --> 00:26:02,000
largo 1 y ancho era 3.

347
00:26:02,000 --> 00:26:06,000
Cada instancia tiene sus propios valores.

348
00:26:07,000 --> 00:26:11,000
Si ahora yo creo un método, una variable estática,

349
00:26:11,000 --> 00:26:14,000
esta variable está fuera de los objetos.

350
00:26:14,000 --> 00:26:17,000
Y yo pongo aquí un valor.

351
00:26:17,000 --> 00:26:19,000
Si este objeto de aquí,

352
00:26:19,000 --> 00:26:21,000
con un método o de alguna forma,

353
00:26:21,000 --> 00:26:24,000
modifica esto y lo cambia a 5,

354
00:26:24,000 --> 00:26:28,000
también este objeto ve este cambio.

355
00:26:28,000 --> 00:26:30,000
Porque no pertenece al objeto,

356
00:26:30,000 --> 00:26:37,000
pertenece a la clase.

357
00:26:37,000 --> 00:26:40,000
Todo esto son instancias de la misma clase.

358
00:26:40,000 --> 00:26:43,000
Y la clase tiene un trozo de memoria

359
00:26:43,000 --> 00:26:48,000
que es compartido por todas las instancias.

360
00:26:48,000 --> 00:26:52,000
O si es público, hasta por otros objetos.

361
00:26:52,000 --> 00:26:57,000
Pero los objetos que acceden a este espacio de memoria

362
00:26:57,000 --> 00:27:00,000
que no depende de una instancia concreta.

363
00:27:00,000 --> 00:27:05,000
Depende de la clase.

364
00:27:05,000 --> 00:27:08,000
Y si yo tengo un método estático,

365
00:27:08,000 --> 00:27:10,000
lo representaremos.

366
00:27:10,000 --> 00:27:14,000
Este es un método estático que hace algo, no lo sé.

367
00:27:14,000 --> 00:27:18,000
Este método estático, si usa ancho o usa largo,

368
00:27:18,000 --> 00:27:22,000
no sabe si tiene que utilizar esto o este de aquí.

369
00:27:22,000 --> 00:27:25,000
Porque si es estático no hace referencia a un objeto.

370
00:27:25,000 --> 00:27:27,000
Por lo tanto no lo puede utilizar.

371
00:27:27,000 --> 00:27:32,000
Un método estático puede utilizar solo variables estáticas.

372
00:27:32,000 --> 00:27:35,000
Porque si yo uso algo no estático,

373
00:27:35,000 --> 00:27:39,000
debería saber de qué objeto lo estoy utilizando.

374
00:27:39,000 --> 00:27:43,000
Y este método no lo sabe, a menos que no se lo he pasado por parámetro

375
00:27:43,000 --> 00:27:46,000
o he hecho algo especial.

376
00:27:46,000 --> 00:27:49,000
Entonces, lo que me interesa es que quede claro

377
00:27:49,000 --> 00:27:51,000
que hay dos mundos.

378
00:27:51,000 --> 00:27:54,000
El mundo estático, que es todo lo que se refiere a la clase,

379
00:27:54,000 --> 00:27:57,000
pero que es, en un cierto sentido, independiente

380
00:27:57,000 --> 00:28:01,000
de cuántas instancias hay o de qué instancias haya.

381
00:28:01,000 --> 00:28:05,000
Mientras el mundo no estático,

382
00:28:05,000 --> 00:28:10,000
que es profundamente dependiente

383
00:28:10,000 --> 00:28:15,000
de la instancia sobre la que trabaja.

384
00:28:15,000 --> 00:28:18,000
Entonces, por un lado, por ejemplo,

385
00:28:18,000 --> 00:28:21,000
hay los métodos estáticos que se llaman sobre la clase

386
00:28:21,000 --> 00:28:25,000
y los métodos no estáticos que se llaman sobre una instancia,

387
00:28:25,000 --> 00:28:29,000
sobre un objeto.

388
00:28:29,000 --> 00:28:35,000
Vamos a ver un ejemplo de método estático.

389
00:28:35,000 --> 00:28:40,000
Imaginámonos esta clase estática de aquí.

390
00:28:40,000 --> 00:28:44,000
Esta clase estática tiene un intero estático

391
00:28:44,000 --> 00:28:47,000
que se llama operaciones hechas.

392
00:28:47,000 --> 00:28:51,000
Esto es que quiero saber cuántas operaciones se han hecho.

393
00:28:51,000 --> 00:28:55,000
Cada vez que haré una de las operaciones que tengo aquí

394
00:28:55,000 --> 00:28:59,000
en mi clase, quiero sumar uno a esto.

395
00:28:59,000 --> 00:29:03,000
No me importa si lo está haciendo uno u otro.

396
00:29:03,000 --> 00:29:06,000
Lo que quiero hacer es que si se hace una operación,

397
00:29:06,000 --> 00:29:08,000
se suma una aquí.

398
00:29:08,000 --> 00:29:12,000
Al final, en clase estática, en esta variable de aquí,

399
00:29:12,000 --> 00:29:15,000
tendré el número de operaciones hechas.

400
00:29:15,000 --> 00:29:17,000
¿Cuántas operaciones se pueden hacer?

401
00:29:17,000 --> 00:29:19,000
Pues tengo dos métodos estáticos,

402
00:29:19,000 --> 00:29:21,000
que son cálculo área de rectángulo.

403
00:29:21,000 --> 00:29:24,000
Oye, es lo mismo que antes.

404
00:29:24,000 --> 00:29:27,000
Pero fijaos que ahora tiene dos parámetros.

405
00:29:27,000 --> 00:29:30,000
Porque ahora no puede hacer cálculo área de rectángulo

406
00:29:30,000 --> 00:29:32,000
sin parámetros.

407
00:29:32,000 --> 00:29:35,000
Porque me diría, ¿y cuál es el largo y el ancho?

408
00:29:35,000 --> 00:29:38,000
No tengo un objeto al que referirme

409
00:29:38,000 --> 00:29:40,000
y este objeto tiene un ancho y un largo

410
00:29:40,000 --> 00:29:43,000
y entonces hago la multiplicación entre este ancho y el largo.

411
00:29:43,000 --> 00:29:46,000
En un entorno estático no tengo instancias.

412
00:29:46,000 --> 00:29:49,000
Por lo tanto, no tengo objetos, no tengo...

413
00:29:49,000 --> 00:29:52,000
¿Qué hago? Pues se lo paso por parámetro.

414
00:29:52,000 --> 00:29:54,000
Lo puede hacer, sí.

415
00:29:54,000 --> 00:29:57,000
Calcular un área de rectángulo si me dan el largo y el ancho

416
00:29:57,000 --> 00:30:01,000
lo puede hacer hasta sin saber de qué objeto estoy hablando.

417
00:30:01,000 --> 00:30:03,000
¿Sí o no?

418
00:30:03,000 --> 00:30:06,000
Entonces en este caso haría largo por ancho,

419
00:30:06,000 --> 00:30:10,000
fijaos, sumo uno a esta variable de aquí

420
00:30:10,000 --> 00:30:12,000
para decir que he hecho una operación,

421
00:30:12,000 --> 00:30:14,000
he hecho calcular área de rectángulo

422
00:30:14,000 --> 00:30:17,000
y luego devuelvo la área de rectángulo.

423
00:30:17,000 --> 00:30:20,000
Y luego está, calcula perímetro de rectángulo

424
00:30:20,000 --> 00:30:22,000
que es otra operación que necesita,

425
00:30:22,000 --> 00:30:25,000
también necesita los dos lados.

426
00:30:25,000 --> 00:30:28,000
Lo calculará de forma distinta, suma uno

427
00:30:28,000 --> 00:30:31,000
a las operaciones hechas.

428
00:30:31,000 --> 00:30:34,000
Entonces tanto que calcule el área como calcule el perímetro

429
00:30:34,000 --> 00:30:37,000
sumo uno a cuantas operaciones he hecho

430
00:30:37,000 --> 00:30:39,000
y luego devuelvo.

431
00:30:39,000 --> 00:30:41,000
Esta es una clase estática.

432
00:30:41,000 --> 00:30:46,000
¿Por qué? Porque no tiene nada aquí que no sea estático.

433
00:30:46,000 --> 00:30:47,000
Justo.

434
00:30:47,000 --> 00:30:49,000
¿Tiene sentido hacer objetos de esta clase?

435
00:30:49,000 --> 00:30:55,000
¿Hacer clase estática x es igual a new clase estática?

436
00:30:55,000 --> 00:30:57,000
La pregunta es entonces,

437
00:30:57,000 --> 00:31:00,000
¿la variable estática y operación hechas

438
00:31:00,000 --> 00:31:02,000
opera en toda la clase?

439
00:31:02,000 --> 00:31:03,000
Pertenece a la clase.

440
00:31:03,000 --> 00:31:04,000
¿Y si haces una variable que sea una clase

441
00:31:04,000 --> 00:31:06,000
¿opera en todo el paquete?

442
00:31:06,000 --> 00:31:07,000
¿Cómo?

443
00:31:07,000 --> 00:31:09,000
¿Si haces una variable que sea una clase

444
00:31:09,000 --> 00:31:12,000
¿opera en todo el paquete?

445
00:31:12,000 --> 00:31:18,000
Si haces una variable, por ejemplo, static string

446
00:31:18,000 --> 00:31:22,000
En vez de public clase estática, no puedes poner

447
00:31:22,000 --> 00:31:24,000
Public static class

448
00:31:25,000 --> 00:31:28,000
No, no puede, por ahora.

449
00:31:32,000 --> 00:31:34,000
No, en principio no.

450
00:31:34,000 --> 00:31:36,000
Public static class me pillas

451
00:31:36,000 --> 00:31:38,000
porque no lo he visto en vida mía

452
00:31:38,000 --> 00:31:41,000
pero no me atrevo a decir que no se puede.

453
00:31:41,000 --> 00:31:43,000
Entonces se lo debería mirar.

454
00:31:43,000 --> 00:31:44,000
Oye, esto se ha grabado.

455
00:31:44,000 --> 00:31:46,000
No, lo sé, pero no os lo digo.

456
00:31:46,000 --> 00:31:49,000
Miradlo vosotros en Google.

457
00:31:49,000 --> 00:31:51,000
Para casa.

458
00:31:52,000 --> 00:31:55,000
Esta es la clase estática.

459
00:31:55,000 --> 00:31:58,000
Os pongo otra vez esta de aquí para fijaros.

460
00:31:58,000 --> 00:32:02,000
La clase no estática tenía sus atributos

461
00:32:02,000 --> 00:32:08,000
y programitas, métodos que utilizan estos.

462
00:32:08,000 --> 00:32:10,000
¿Podría un método no utilizar estos?

463
00:32:10,000 --> 00:32:11,000
Sí.

464
00:32:11,000 --> 00:32:14,000
Podría tener un método de rectángulo

465
00:32:14,000 --> 00:32:16,000
que no va a utilizar estos.

466
00:32:16,000 --> 00:32:18,000
Sería un poco raro, pero podría

467
00:32:18,000 --> 00:32:21,000
en algunos casos tener sentido.

468
00:32:23,000 --> 00:32:26,000
Mientras que la clase estática, si os fijáis,

469
00:32:26,000 --> 00:32:28,000
tiene sus variables estáticas,

470
00:32:28,000 --> 00:32:30,000
pero lo que está haciendo es

471
00:32:30,000 --> 00:32:32,000
no es dependiente de un objeto.

472
00:32:32,000 --> 00:32:33,000
Esta es la cosa importante.

473
00:32:33,000 --> 00:32:35,000
No tiene instancias aquí.

474
00:32:35,000 --> 00:32:38,000
No tiene sentido crear una clase estática,

475
00:32:38,000 --> 00:32:39,000
un objeto de la clase estática,

476
00:32:39,000 --> 00:32:42,000
porque no tiene algo que dependa

477
00:32:42,000 --> 00:32:44,000
de la clase estática.

478
00:32:44,000 --> 00:32:47,000
No es un valor que dependa

479
00:32:47,000 --> 00:32:48,000
de una instancia en concreta.

480
00:32:48,000 --> 00:32:50,000
No tiene nada que no sea estático.

481
00:32:50,000 --> 00:32:52,000
¿Cómo uso esta?

482
00:32:52,000 --> 00:32:55,000
Me hago mi clase estática main,

483
00:32:55,000 --> 00:32:57,000
donde tengo el main.

484
00:32:57,000 --> 00:33:00,000
Y, por ejemplo, tengo dos rectángulos.

485
00:33:00,000 --> 00:33:01,000
Este es el rectángulo 2.

486
00:33:01,000 --> 00:33:03,000
Uno de largo 3 es ancho 6.

487
00:33:03,000 --> 00:33:06,000
El otro de largo 1 es ancho 3.

488
00:33:06,000 --> 00:33:08,000
Y puedo hacer algo parecido con el otro.

489
00:33:08,000 --> 00:33:10,000
El rectángulo 1 tiene área.

490
00:33:10,000 --> 00:33:12,000
Y ahora me llamo el método

491
00:33:12,000 --> 00:33:16,000
calcular el rectángulo 3,6.

492
00:33:16,000 --> 00:33:18,000
¿Dónde llamo este método?

493
00:33:18,000 --> 00:33:19,000
¿Sobre un objeto?

494
00:33:19,000 --> 00:33:21,000
No, lo llamo sobre la clase.

495
00:33:21,000 --> 00:33:24,000
¿Por qué? Porque es estático.

496
00:33:24,000 --> 00:33:26,000
¿Podría quitar esta parte de aquí

497
00:33:26,000 --> 00:33:28,000
y dejar sólo calcular el rectángulo?

498
00:33:28,000 --> 00:33:31,000
No, porque en esta clase de aquí

499
00:33:31,000 --> 00:33:34,000
no está definido calcular el rectángulo.

500
00:33:34,000 --> 00:33:37,000
El método está definido en esta clase de aquí.

501
00:33:37,000 --> 00:33:39,000
Entonces, si yo le estoy diciendo

502
00:33:39,000 --> 00:33:43,000
utilizar este método de esta clase.

503
00:33:43,000 --> 00:33:46,000
Como cuando hacemos math.random.

504
00:33:46,000 --> 00:33:48,000
Quiero utilizar el método random

505
00:33:48,000 --> 00:33:50,000
definido en la clase math.

506
00:33:50,000 --> 00:33:51,000
¿En una instancia de la clase math?

507
00:33:51,000 --> 00:33:53,000
No, en la clase math.

508
00:33:53,000 --> 00:33:56,000
Es estático.

509
00:33:56,000 --> 00:34:00,000
Y esto me da 3x6.

510
00:34:00,000 --> 00:34:02,000
Y lo escribe.

511
00:34:02,000 --> 00:34:04,000
Y luego lo que voy a hacer del otro rectángulo.

512
00:34:04,000 --> 00:34:06,000
Cuidado que aquí no estoy creando

513
00:34:06,000 --> 00:34:07,000
rectángulos nuevos.

514
00:34:08,000 --> 00:34:10,000
No estoy creando objetos.

515
00:34:10,000 --> 00:34:12,000
No hay instancias.

516
00:34:12,000 --> 00:34:14,000
Pero utilizo el calcular al rectángulo

517
00:34:14,000 --> 00:34:16,000
y ya está.

518
00:34:16,000 --> 00:34:18,000
Esto podría ser una suite

519
00:34:18,000 --> 00:34:23,000
de métodos de geometría

520
00:34:23,000 --> 00:34:26,000
para calcular el área del cuadrado,

521
00:34:26,000 --> 00:34:27,000
el área del rectángulo,

522
00:34:27,000 --> 00:34:28,000
el área del círculo,

523
00:34:28,000 --> 00:34:29,000
el área de no sé qué.

524
00:34:29,000 --> 00:34:31,000
Y que luego yo utilizo esta suite

525
00:34:31,000 --> 00:34:33,000
cuando quiero utilizar

526
00:34:33,000 --> 00:34:34,000
alguna de estas formas

527
00:34:34,000 --> 00:34:36,000
y calcular el área de alguna de estas formas.

528
00:34:37,000 --> 00:34:39,000
Sin necesidad de crearme un objeto

529
00:34:39,000 --> 00:34:41,000
para poder calcular esa cosa.

530
00:34:41,000 --> 00:34:43,000
¿Sí?

531
00:34:43,000 --> 00:34:45,000
Como es la clase math.

532
00:34:45,000 --> 00:34:47,000
La clase math es un conjunto

533
00:34:47,000 --> 00:34:51,000
de métodos relacionados con la matemática

534
00:34:51,000 --> 00:34:53,000
como hacer un número aleatorio, por ejemplo,

535
00:34:53,000 --> 00:34:55,000
que están allí

536
00:34:55,000 --> 00:34:57,000
y yo puedo utilizarlas.

537
00:34:57,000 --> 00:34:59,000
La clase math tiene otros métodos

538
00:34:59,000 --> 00:35:01,000
como calcular la raíz cuadrada.

539
00:35:01,000 --> 00:35:03,000
Calcular la raíz cuadrada

540
00:35:03,000 --> 00:35:05,000
y hacer un objeto 9

541
00:35:05,000 --> 00:35:07,000
para luego poder llamar

542
00:35:07,000 --> 00:35:09,000
9.raíz cuadrada

543
00:35:09,000 --> 00:35:11,000
y sacarme 3.

544
00:35:11,000 --> 00:35:13,000
Yo llamo math.sqrt

545
00:35:13,000 --> 00:35:15,000
square root

546
00:35:15,000 --> 00:35:17,000
raíz cuadrada

547
00:35:17,000 --> 00:35:19,000
y le pongo el número que quiero hacer

548
00:35:19,000 --> 00:35:21,000
la raíz cuadrada, 9.

549
00:35:21,000 --> 00:35:23,000
Y el resultado es 3.

550
00:35:23,000 --> 00:35:25,000
Y eso no depende de un objeto.

551
00:35:25,000 --> 00:35:27,000
Se entiende la diferencia.

552
00:35:27,000 --> 00:35:29,000
¿Y qué pasará al final?

553
00:35:29,000 --> 00:35:31,000
Bueno, aquí calcula un perímetro.

554
00:35:31,000 --> 00:35:33,000
Fijaos que yo no tengo un objeto.

555
00:35:33,000 --> 00:35:35,000
Si quiero calcular ahora

556
00:35:35,000 --> 00:35:37,000
el perímetro del primer rectángulo

557
00:35:37,000 --> 00:35:39,000
tengo que volver a ponerle 3.6.

558
00:35:39,000 --> 00:35:43,000
¿Se entiende esto?

559
00:35:43,000 --> 00:35:45,000
Y la pregunta es

560
00:35:45,000 --> 00:35:47,000
si ahora después de estas 3

561
00:35:47,000 --> 00:35:49,000
1, 2 y 3

562
00:35:49,000 --> 00:35:51,000
hago

563
00:35:51,000 --> 00:35:53,000
he hecho clase estática punto operaciones

564
00:35:53,000 --> 00:35:55,000
hecha operaciones

565
00:35:55,000 --> 00:35:57,000
¿Cuánto me escribe aquí?

566
00:35:57,000 --> 00:35:59,000
3.

567
00:35:59,000 --> 00:36:01,000
¿Vale?

568
00:36:01,000 --> 00:36:03,000
Porque cada uno de estos métodos

569
00:36:03,000 --> 00:36:05,000
ha sumado 1

570
00:36:05,000 --> 00:36:07,000
a operaciones hechas.

571
00:36:07,000 --> 00:36:09,000
Entonces operaciones hechas

572
00:36:09,000 --> 00:36:11,000
al principio cuando he arrancado todo

573
00:36:11,000 --> 00:36:13,000
era 0.

574
00:36:13,000 --> 00:36:15,000
La primera vez que he ejecutado esto ha sumado 1.

575
00:36:15,000 --> 00:36:17,000
La segunda vez ha sumado 2.

576
00:36:17,000 --> 00:36:19,000
Y la tercera ha sumado 3.

577
00:36:19,000 --> 00:36:21,000
Por lo tanto ahora vale 3.

578
00:36:21,000 --> 00:36:23,000
¿Esto pertenece a un objeto?

579
00:36:23,000 --> 00:36:25,000
No.

580
00:36:25,000 --> 00:36:27,000
¿Dudas?

581
00:36:27,000 --> 00:36:29,000
¿Puedes mezclar dentro de lo que sería

582
00:36:29,000 --> 00:36:31,000
la clase estática?

583
00:36:35,000 --> 00:36:37,000
¿Dices esto?

584
00:36:37,000 --> 00:36:39,000
No, no.

585
00:36:39,000 --> 00:36:41,000
¿Dices esto?

586
00:36:41,000 --> 00:36:43,000
Sí, puedes.

587
00:36:43,000 --> 00:36:45,000
¿Estática y no estática pueden coexistir?

588
00:36:45,000 --> 00:36:47,000
Muy buena pregunta.

589
00:36:47,000 --> 00:36:49,000
¿Vale?

590
00:36:49,000 --> 00:36:51,000
Habría hecho la misma pregunta.

591
00:36:51,000 --> 00:36:53,000
Entonces yo puedo hacer

592
00:36:53,000 --> 00:36:55,000
una clase que tenga

593
00:36:55,000 --> 00:36:57,000
algunas componentes

594
00:36:57,000 --> 00:36:59,000
que sean propias

595
00:36:59,000 --> 00:37:01,000
de la clase

596
00:37:01,000 --> 00:37:03,000
y entonces sean estáticas

597
00:37:03,000 --> 00:37:05,000
y algunas componentes

598
00:37:05,000 --> 00:37:07,000
que sean propias de un objeto concreto

599
00:37:07,000 --> 00:37:09,000
y que entonces sean no estáticas.

600
00:37:09,000 --> 00:37:11,000
¿Cómo es esta clase aquí, por ejemplo?

601
00:37:11,000 --> 00:37:13,000
Yo me he creado

602
00:37:13,000 --> 00:37:15,000
una clase rectángulo.

603
00:37:15,000 --> 00:37:17,000
¿Vale?

604
00:37:17,000 --> 00:37:19,000
Cada rectángulo puede tener instancias

605
00:37:19,000 --> 00:37:21,000
que tendrán ancho y largo.

606
00:37:21,000 --> 00:37:23,000
Ancho y largo depende del objeto.

607
00:37:23,000 --> 00:37:25,000
Quiero contar cuántos rectángulos

608
00:37:25,000 --> 00:37:27,000
se han creado.

609
00:37:29,000 --> 00:37:31,000
Para crear cuántos rectángulos se han creado

610
00:37:31,000 --> 00:37:33,000
si este rectángulo creado

611
00:37:33,000 --> 00:37:35,000
fuera

612
00:37:35,000 --> 00:37:37,000
no estático, o sea, si borras

613
00:37:37,000 --> 00:37:39,000
estático, cada rectángulo

614
00:37:39,000 --> 00:37:41,000
tendría una copia

615
00:37:41,000 --> 00:37:43,000
de esta variable

616
00:37:43,000 --> 00:37:45,000
y todos valdrían cero.

617
00:37:45,000 --> 00:37:47,000
Entonces cuando creo un rectángulo

618
00:37:47,000 --> 00:37:49,000
y le sumo uno

619
00:37:49,000 --> 00:37:51,000
todos valdrían uno y todos

620
00:37:51,000 --> 00:37:53,000
crearían que solo hay un rectángulo.

621
00:37:53,000 --> 00:37:55,000
El mismo.

622
00:37:55,000 --> 00:37:57,000
Sin embargo, si lo pongo como

623
00:37:57,000 --> 00:37:59,000
rectángulo estático, o sea,

624
00:37:59,000 --> 00:38:01,000
el rectángulo creado es estático, ya esto

625
00:38:01,000 --> 00:38:03,000
no pertenece a la instancia.

626
00:38:03,000 --> 00:38:05,000
¿Vale? No está

627
00:38:07,000 --> 00:38:09,000
aquí dentro esta información.

628
00:38:09,000 --> 00:38:11,000
Sino está aquí fuera.

629
00:38:11,000 --> 00:38:13,000
Y cuando este

630
00:38:13,000 --> 00:38:15,000
suma uno porque ha sido creado

631
00:38:15,000 --> 00:38:17,000
se suma aquí.

632
00:38:17,000 --> 00:38:19,000
Y cuando creo uno nuevo

633
00:38:19,000 --> 00:38:21,000
se suma siempre aquí.

634
00:38:21,000 --> 00:38:23,000
Y por lo tanto ahora hay dos

635
00:38:23,000 --> 00:38:25,000
rectángulos creados.

636
00:38:27,000 --> 00:38:29,000
Veamos el código.

637
00:38:31,000 --> 00:38:33,000
Aquí lo que estoy creando es

638
00:38:35,000 --> 00:38:37,000
un constructor que recibe

639
00:38:37,000 --> 00:38:39,000
un ancho y un largo

640
00:38:39,000 --> 00:38:41,000
asigna el ancho y el largo

641
00:38:41,000 --> 00:38:43,000
como tiene que asignarlo

642
00:38:43,000 --> 00:38:45,000
pero cada vez que se ejecute

643
00:38:45,000 --> 00:38:47,000
este

644
00:38:47,000 --> 00:38:49,000
constructor

645
00:38:49,000 --> 00:38:51,000
lo que se está haciendo es sumar

646
00:38:51,000 --> 00:38:53,000
uno a esta variable

647
00:38:53,000 --> 00:38:55,000
que es una variable de clase.

648
00:38:55,000 --> 00:38:57,000
Fijaos también que

649
00:38:57,000 --> 00:38:59,000
las variables

650
00:38:59,000 --> 00:39:01,000
estáticas están en cursiva.

651
00:39:01,000 --> 00:39:03,000
¿Vale? Entonces lo podéis

652
00:39:03,000 --> 00:39:05,000
saber más fácilmente.

653
00:39:05,000 --> 00:39:07,000
Entonces el primer rectángulo

654
00:39:07,000 --> 00:39:09,000
se creará su propio ancho y largo

655
00:39:09,000 --> 00:39:11,000
suyos de ese objeto

656
00:39:11,000 --> 00:39:13,000
pero sumará uno a una variable compartida

657
00:39:13,000 --> 00:39:15,000
digamos así, una variable global

658
00:39:15,000 --> 00:39:17,000
se puede decir.

659
00:39:17,000 --> 00:39:19,000
Cuando el segundo rectángulo

660
00:39:19,000 --> 00:39:21,000
hace esta cosa otra vez

661
00:39:21,000 --> 00:39:23,000
se creará su propio ancho y largo

662
00:39:23,000 --> 00:39:25,000
suyos que no tienen nada que ver con la otra

663
00:39:25,000 --> 00:39:27,000
instancia

664
00:39:27,000 --> 00:39:29,000
pero sumará uno a la misma

665
00:39:31,000 --> 00:39:33,000
variable estática.

666
00:39:33,000 --> 00:39:35,000
Entonces ahora vale dos.

667
00:39:39,000 --> 00:39:41,000
Luego tengo mi método no estático

668
00:39:41,000 --> 00:39:43,000
que usa

669
00:39:43,000 --> 00:39:45,000
variables no estáticas

670
00:39:45,000 --> 00:39:47,000
entonces si lo llamo

671
00:39:47,000 --> 00:39:49,000
su rectángulo uno

672
00:39:49,000 --> 00:39:51,000
me hará su ancho por su largo

673
00:39:51,000 --> 00:39:53,000
y si lo llamo su rectángulo dos

674
00:39:53,000 --> 00:39:55,000
me hará el ancho del rectángulo dos

675
00:39:55,000 --> 00:39:57,000
por el largo del rectángulo dos

676
00:39:57,000 --> 00:39:59,000
es decir que este método depende

677
00:39:59,000 --> 00:40:01,000
del objeto sobre el que lo llamo

678
00:40:01,000 --> 00:40:03,000
por lo tanto este método

679
00:40:03,000 --> 00:40:05,000
se tendrá que llamar sobre un objeto

680
00:40:05,000 --> 00:40:07,000
rectángulo uno punto área

681
00:40:07,000 --> 00:40:09,000
o rectángulo dos punto área

682
00:40:09,000 --> 00:40:11,000
y fijaos que no recibe

683
00:40:11,000 --> 00:40:13,000
ningún parámetro

684
00:40:13,000 --> 00:40:15,000
¿Por qué no recibe parámetros?

685
00:40:17,000 --> 00:40:19,000
Porque los tiene

686
00:40:19,000 --> 00:40:21,000
¿Si?

687
00:40:21,000 --> 00:40:23,000
Ese objeto ya tendrá esos dos parámetros

688
00:40:23,000 --> 00:40:25,000
entonces usa esos

689
00:40:27,000 --> 00:40:29,000
¿Se entiende?

690
00:40:29,000 --> 00:40:31,000
Y luego está

691
00:40:31,000 --> 00:40:33,000
un método estático por ejemplo

692
00:40:33,000 --> 00:40:35,000
que es total de rectángulos

693
00:40:35,000 --> 00:40:37,000
creados. Cuando yo lanzo este método

694
00:40:37,000 --> 00:40:39,000
total de rectángulos creados

695
00:40:39,000 --> 00:40:41,000
me devuelve rectángulos creados

696
00:40:41,000 --> 00:40:43,000
me devuelve este valor de aquí

697
00:40:47,000 --> 00:40:49,000
¿Habría podido acceder a este valor

698
00:40:49,000 --> 00:40:51,000
de otra forma?

699
00:40:51,000 --> 00:40:53,000
Si yo escribo rectángulo

700
00:40:53,000 --> 00:40:55,000
punto

701
00:40:55,000 --> 00:40:57,000
rectángulos creados

702
00:40:57,000 --> 00:40:59,000
accedería al mismo valor

703
00:41:01,000 --> 00:41:03,000
Y aquí en el futuro

704
00:41:03,000 --> 00:41:05,000
luego lo veremos más en detalle

705
00:41:05,000 --> 00:41:07,000
Si yo quisiera que la gente pudiera tocar

706
00:41:07,000 --> 00:41:09,000
esta cosa desde fuera

707
00:41:09,000 --> 00:41:11,000
pues entonces aquí le pondría un private

708
00:41:13,000 --> 00:41:15,000
Si pongo private

709
00:41:15,000 --> 00:41:17,000
pues esta cosa de aquí

710
00:41:17,000 --> 00:41:19,000
ya no se puede hacer rectángulo

711
00:41:19,000 --> 00:41:21,000
punto rectángulos creados

712
00:41:21,000 --> 00:41:23,000
no se puede acceder a esta variable

713
00:41:23,000 --> 00:41:25,000
desde fuera

714
00:41:25,000 --> 00:41:27,000
entonces la única forma

715
00:41:27,000 --> 00:41:29,000
para poder leer esta variable

716
00:41:29,000 --> 00:41:31,000
sería con este método

717
00:41:31,000 --> 00:41:33,000
que es público

718
00:41:35,000 --> 00:41:37,000
porque nadie podría cambiarlo

719
00:41:37,000 --> 00:41:39,000
nadie podría entrar en rectángulo

720
00:41:39,000 --> 00:41:41,000
hacer rectángulo punto rectángulos creados

721
00:41:41,000 --> 00:41:43,000
igual 7

722
00:41:43,000 --> 00:41:45,000
porque no se puede acceder desde fuera

723
00:41:45,000 --> 00:41:47,000
la única forma para cambiarlo

724
00:41:47,000 --> 00:41:49,000
es esta línea de aquí

725
00:41:49,000 --> 00:41:51,000
que se ejecuta cuando creo un rectángulo

726
00:41:51,000 --> 00:41:53,000
entonces me estoy

727
00:41:53,000 --> 00:41:55,000
garantizando que

728
00:41:55,000 --> 00:41:57,000
los rectángulos creados son efectivamente

729
00:41:57,000 --> 00:41:59,000
los que se han hecho con un constructor

730
00:41:59,000 --> 00:42:01,000
volveremos sobre este concepto

731
00:42:01,000 --> 00:42:03,000
¿Dudas?

732
00:42:05,000 --> 00:42:07,000
Por ahora me interesa la diferencia

733
00:42:07,000 --> 00:42:09,000
entre estático y no estático

734
00:42:09,000 --> 00:42:11,000
estático

735
00:42:11,000 --> 00:42:13,000
todo lo que se refiere a la clase

736
00:42:13,000 --> 00:42:15,000
no a una instancia de la clase

737
00:42:15,000 --> 00:42:17,000
instancias distintas de las clases

738
00:42:17,000 --> 00:42:19,000
ven el mismo comportamiento

739
00:42:21,000 --> 00:42:23,000
no estático

740
00:42:23,000 --> 00:42:25,000
depende de la instancia sobre la que lo llamo

741
00:42:27,000 --> 00:42:29,000
sobre qué funciona

742
00:42:29,000 --> 00:42:31,000
un método estático

743
00:42:31,000 --> 00:42:33,000
pero pueden ser también variables estáticas

744
00:42:33,000 --> 00:42:35,000
o no estáticas

745
00:42:35,000 --> 00:42:37,000
¿Dudas?

746
00:42:43,000 --> 00:42:45,000
Este es fácil

747
00:42:45,000 --> 00:42:47,000
¿Cómo se organiza el código?

748
00:42:47,000 --> 00:42:49,000
Nosotros organizamos códigos en clases

749
00:42:49,000 --> 00:42:51,000
ya lo hemos visto

750
00:42:51,000 --> 00:42:53,000
hay una clase principal y luego otras clases que usaré

751
00:42:53,000 --> 00:42:55,000
desde la clase principal

752
00:42:55,000 --> 00:42:57,000
ya veremos si hacemos ejemplos

753
00:42:57,000 --> 00:42:59,000
existe también una forma

754
00:42:59,000 --> 00:43:01,000
de organizar un poco mejor

755
00:43:01,000 --> 00:43:03,000
las clases que son los paquetes

756
00:43:05,000 --> 00:43:07,000
yo puedo crear un paquete

757
00:43:07,000 --> 00:43:09,000
que contiene dentro varias clases

758
00:43:09,000 --> 00:43:11,000
si yo tengo normalmente

759
00:43:11,000 --> 00:43:13,000
un sistema muy complejo

760
00:43:13,000 --> 00:43:15,000
que tiene muchas

761
00:43:15,000 --> 00:43:17,000
clases

762
00:43:17,000 --> 00:43:19,000
sería complejo

763
00:43:19,000 --> 00:43:21,000
y sobre todo

764
00:43:21,000 --> 00:43:23,000
que yo pueda organizar de alguna forma

765
00:43:23,000 --> 00:43:25,000
porque hay un cierto

766
00:43:25,000 --> 00:43:27,000
número de clases que se ocupan

767
00:43:27,000 --> 00:43:29,000
de un cierto tema y otras clases de un tema

768
00:43:29,000 --> 00:43:31,000
distintos y que tiene sentido

769
00:43:31,000 --> 00:43:33,000
organizar estas dos

770
00:43:33,000 --> 00:43:35,000
de alguna forma pues puedo crear paquetes

771
00:43:37,000 --> 00:43:39,000
un paquete pues lo creo

772
00:43:39,000 --> 00:43:41,000
fácilmente

773
00:43:41,000 --> 00:43:43,000
desde aquí

774
00:43:45,000 --> 00:43:47,000
normalmente nosotros todo lo que hemos hecho ahora

775
00:43:47,000 --> 00:43:49,000
lo hemos puesto en un default package

776
00:43:49,000 --> 00:43:51,000
el package sería el paquete

777
00:43:51,000 --> 00:43:53,000
si yo creo un nuevo puedo crear

778
00:43:53,000 --> 00:43:55,000
un nuevo paquete

779
00:43:55,000 --> 00:43:57,000
crear un nuevo paquete le doy un nombre

780
00:43:57,000 --> 00:43:59,000
por ejemplo

781
00:43:59,000 --> 00:44:01,000
geometría

782
00:44:01,000 --> 00:44:03,000
entonces ahora he creado

783
00:44:03,000 --> 00:44:05,000
un paquete geometría

784
00:44:05,000 --> 00:44:07,000
y las clases

785
00:44:07,000 --> 00:44:09,000
que creo aquí dentro

786
00:44:17,000 --> 00:44:19,000
si os fijáis

787
00:44:19,000 --> 00:44:21,000
pertenecen al

788
00:44:21,000 --> 00:44:23,000
paquete geometría

789
00:44:25,000 --> 00:44:27,000
esto es el comando

790
00:44:27,000 --> 00:44:29,000
que se da al principio para decirle

791
00:44:29,000 --> 00:44:31,000
a que paquete pertenece

792
00:44:31,000 --> 00:44:33,000
me espero

793
00:44:33,000 --> 00:44:35,000
que el paquete geometría este en el

794
00:44:35,000 --> 00:44:37,000
paquete geometría, si lo muevo a otro

795
00:44:37,000 --> 00:44:39,000
paquete que no sea el paquete geometría y le dejo esto

796
00:44:39,000 --> 00:44:41,000
pues posiblemente se enfade

797
00:44:43,000 --> 00:44:45,000
y esto me permite

798
00:44:45,000 --> 00:44:47,000
organizar mejor mi

799
00:44:47,000 --> 00:44:49,000
programa, podría hacer todo sin paquetes

800
00:44:49,000 --> 00:44:51,000
la ventaja es que

801
00:44:51,000 --> 00:44:53,000
luego si yo hago un paquete geometría muy interesante

802
00:44:53,000 --> 00:44:55,000
y lo quiero reutilizar

803
00:44:55,000 --> 00:44:57,000
puedo importar

804
00:44:57,000 --> 00:44:59,000
este paquete por otro lado

805
00:44:59,000 --> 00:45:01,000
¿os suena algo importar un paquete?

806
00:45:05,000 --> 00:45:07,000
¿os acordáis

807
00:45:07,000 --> 00:45:09,000
cuando

808
00:45:09,000 --> 00:45:11,000
hacía scanner

809
00:45:11,000 --> 00:45:13,000
es igual a new scanner

810
00:45:15,000 --> 00:45:17,000
de algo ¿vale?

811
00:45:17,000 --> 00:45:19,000
y le decía

812
00:45:19,000 --> 00:45:21,000
importa

813
00:45:21,000 --> 00:45:23,000
¿qué estoy haciendo aquí?

814
00:45:25,000 --> 00:45:27,000
estoy yendo a un paquete que se llama

815
00:45:27,000 --> 00:45:29,000
java, que dentro tiene

816
00:45:29,000 --> 00:45:31,000
un paquete que se llama util

817
00:45:31,000 --> 00:45:33,000
que son utility de java

818
00:45:33,000 --> 00:45:35,000
y me pillo

819
00:45:35,000 --> 00:45:37,000
la clase scanner

820
00:45:37,000 --> 00:45:39,000
y la importo en mi programa

821
00:45:39,000 --> 00:45:41,000
es como si hubiese copiado

822
00:45:41,000 --> 00:45:43,000
esa clase en mi proyecto

823
00:45:43,000 --> 00:45:45,000
y ahora la puedo utilizar

824
00:45:45,000 --> 00:45:47,000
pues si yo hago el paquete

825
00:45:47,000 --> 00:45:49,000
geometría, pues en un lado

826
00:45:49,000 --> 00:45:51,000
podría importar

827
00:45:51,000 --> 00:45:53,000
aquí import

828
00:45:53,000 --> 00:45:55,000
geometría o importo lo que sea

829
00:45:55,000 --> 00:45:57,000
punto lo que sea geometría

830
00:45:57,000 --> 00:45:59,000
y tendría todo lo que

831
00:45:59,000 --> 00:46:01,000
lo que tengo todo desarrollado

832
00:46:01,000 --> 00:46:03,000
aquí pues ahora lo tengo en el otro programa

833
00:46:05,000 --> 00:46:07,000
estas son cosas un poco más avanzadas

834
00:46:07,000 --> 00:46:09,000
a lo mejor luego lo utilizaremos más adelante

835
00:46:09,000 --> 00:46:11,000
pero por ahora simplemente que sepáis que

836
00:46:11,000 --> 00:46:13,000
existen y que podéis utilizar los paquetes

837
00:46:13,000 --> 00:46:15,000
para organizar mejor

838
00:46:15,000 --> 00:46:17,000
estos ejercicios

839
00:46:17,000 --> 00:46:19,000
por ejemplo hasta ahora

840
00:46:19,000 --> 00:46:21,000
hemos hecho un proyecto nuevo

841
00:46:21,000 --> 00:46:23,000
por cada bloque

842
00:46:23,000 --> 00:46:25,000
de ejercicios

843
00:46:25,000 --> 00:46:27,000
pues ahora podríais hacer un único proyecto

844
00:46:27,000 --> 00:46:29,000
que sea en ejercicio de java

845
00:46:29,000 --> 00:46:31,000
y poner un paquete por cada uno

846
00:46:31,000 --> 00:46:33,000
de los bloques de ejercicio

847
00:46:33,000 --> 00:46:35,000
por ejemplo

848
00:46:39,000 --> 00:46:41,000
y que más

849
00:46:43,000 --> 00:46:45,000
entonces esto es para organización

850
00:46:45,000 --> 00:46:47,000
de código

851
00:46:47,000 --> 00:46:49,000
yo diría que

852
00:46:49,000 --> 00:46:51,000
nos paramos por ahora aquí

853
00:46:51,000 --> 00:46:53,000
y esto lo vemos el viernes

854
00:46:53,000 --> 00:46:55,000
no es mucho

855
00:46:55,000 --> 00:46:57,000
pero