1
00:00:00,000 --> 00:00:08,000
¿Qué relación? Vale, voy a grabar esta clase, por lo tanto, si habláis, me autorizáis a grabar vuestra voz, ¿vale?

2
00:00:08,419 --> 00:00:16,739
Entonces, vamos a ver un poquito, unos cuantos temas, algunos no lo hemos visto antes, algunos sí, ¿vale?

3
00:00:16,760 --> 00:00:24,980
Siempre sobre el concepto de programación orientada a objetos, desarrollo de clases, objetos y clases, estática y no estática y cosas por eso.

4
00:00:24,980 --> 00:00:34,719
¿Vale? Entonces, primer tema que vamos a ver es el método main.

5
00:00:35,460 --> 00:00:40,280
Nosotros estamos utilizando el método main desde el principio,

6
00:00:40,399 --> 00:00:42,979
desde el primer día, digamos, que hemos tocado programación.

7
00:00:44,659 --> 00:00:49,479
Pero hemos ido diciendo, ah, si escriben así, esto es así,

8
00:00:49,979 --> 00:00:53,600
que son estas cosas, no lo sé, lo vamos entendiendo con el tiempo.

9
00:00:53,600 --> 00:01:02,700
Ahora estamos a un nivel en el que más o menos podemos descifrar todo del método main, ¿vale?

10
00:01:03,119 --> 00:01:07,000
El domain es público, es decir, que se puede acceder desde fuera de esta clase.

11
00:01:07,400 --> 00:01:11,719
Alguien accederá a este método para empezar mi programa, ¿vale?

12
00:01:12,099 --> 00:01:18,140
La virtual machine se arrancará, empezará haciendo sus cosas y cuando ya está lista,

13
00:01:18,140 --> 00:01:23,480
ha creado el entorno para funcionar, llamará desde no sé dónde este método.

14
00:01:23,599 --> 00:01:26,980
para que desde aquí empiece mi programa.

15
00:01:29,120 --> 00:01:29,599
Estático.

16
00:01:30,060 --> 00:01:31,920
Eso quiere decir que no depende de un objeto.

17
00:01:32,060 --> 00:01:33,579
No tengo que crear un objeto

18
00:01:33,579 --> 00:01:36,019
y luego llamar el método main sobre este objeto.

19
00:01:36,359 --> 00:01:38,099
Es la clase que tiene el método main.

20
00:01:38,200 --> 00:01:40,379
El punto de acceso no necesita la creación

21
00:01:40,379 --> 00:01:41,819
de una instancia de esa clase

22
00:01:41,819 --> 00:01:43,420
para poder ser ejecutado.

23
00:01:44,519 --> 00:01:46,819
Eso porque cuando empiezo el programa

24
00:01:46,819 --> 00:01:48,000
todavía no tengo objetos.

25
00:01:48,000 --> 00:01:49,480
Si no, la Java Vector Machine

26
00:01:49,480 --> 00:01:52,239
debería haber creado un objeto anterior

27
00:01:52,239 --> 00:01:54,299
para poder luego llamar mi main

28
00:01:54,299 --> 00:01:56,420
sobre ese objeto. Pero, ¿qué objeto es?

29
00:01:56,739 --> 00:01:57,340
Pues no lo sé.

30
00:01:57,879 --> 00:02:00,079
Entonces lo pones estático y ya

31
00:02:00,079 --> 00:02:01,519
no dependes de objetos.

32
00:02:02,280 --> 00:02:04,379
Void. El método main no devuelve nada.

33
00:02:04,739 --> 00:02:06,159
No me espero que el método main

34
00:02:06,159 --> 00:02:07,980
devuelva un entero, un objeto,

35
00:02:08,240 --> 00:02:10,560
un string o lo que sea.

36
00:02:11,180 --> 00:02:12,379
Se llama main

37
00:02:12,379 --> 00:02:14,219
y pilla como parámetro

38
00:02:14,219 --> 00:02:16,780
un array de string

39
00:02:16,780 --> 00:02:18,620
llamado args.

40
00:02:18,960 --> 00:02:20,139
args está por

41
00:02:20,139 --> 00:02:22,979
argumentos.

42
00:02:23,520 --> 00:02:23,639
¿Vale?

43
00:02:24,819 --> 00:02:26,599
Estos son unos parámetros

44
00:02:26,599 --> 00:02:28,819
que yo puedo pasar a mi programa

45
00:02:28,819 --> 00:02:31,139
antes de ejecutar

46
00:02:31,139 --> 00:02:32,759
el programa. Nosotros estamos acostumbrados

47
00:02:32,759 --> 00:02:34,900
a que yo lanzo el programa y me aparece

48
00:02:34,900 --> 00:02:36,599
un... ¿Enserta el número?

49
00:02:36,800 --> 00:02:37,979
Pues sí, inserto el número. ¿Vale?

50
00:02:38,319 --> 00:02:39,800
Pero si habéis usado alguna vez

51
00:02:39,800 --> 00:02:42,479
algún programa de informática,

52
00:02:42,659 --> 00:02:44,699
muchas veces los programas o los comandos

53
00:02:44,699 --> 00:02:47,039
que lanzáis, en el momento en que lanzáis

54
00:02:47,039 --> 00:02:48,979
el mismo comando, le pasáis

55
00:02:48,979 --> 00:02:50,919
unos parámetros, unos argumentos.

56
00:02:51,300 --> 00:02:52,840
Habéis hecho un ping en vuestra vida.

57
00:02:55,340 --> 00:02:56,319
Cuando vosotros hacéis ping,

58
00:02:56,460 --> 00:02:57,520
el comando es ping.

59
00:02:58,159 --> 00:02:59,400
Pero ahora le pasáis un parámetro.

60
00:02:59,780 --> 00:03:01,599
Le pasáis a quién hacéis el ping.

61
00:03:02,659 --> 00:03:04,300
¿Sí? Y así con muchas

62
00:03:04,300 --> 00:03:06,419
otras cosas. Habéis copiado un archivo

63
00:03:06,419 --> 00:03:07,860
desde el Necesto, no sé qué.

64
00:03:07,860 --> 00:03:09,740
Habéis hecho algo en Linux o

65
00:03:09,740 --> 00:03:11,259
en...

66
00:03:11,259 --> 00:03:13,699
en sistemas.

67
00:03:14,219 --> 00:03:16,180
¿Habéis visto algo? Muchos comandos

68
00:03:16,180 --> 00:03:17,960
son el comando y luego tiene una

69
00:03:17,960 --> 00:03:19,900
serie de parámetros que le hacen funcionar

70
00:03:19,900 --> 00:03:21,759
el comando. Pues esos parámetros serían

71
00:03:21,759 --> 00:03:23,360
argumentos. Y lo puedo utilizar

72
00:03:23,360 --> 00:03:24,159
en Java.

73
00:03:26,199 --> 00:03:27,479
Vamos a ver

74
00:03:27,479 --> 00:03:30,699
si lo podemos usar.

75
00:03:31,479 --> 00:03:33,219
Entonces, si aquí me he creado una clase

76
00:03:33,219 --> 00:03:34,560
ejemplo. Hago un main

77
00:03:34,560 --> 00:03:39,879
y esta cosa de aquí,

78
00:03:40,439 --> 00:03:42,560
sustancialmente, puedo pasar una

79
00:03:42,560 --> 00:03:44,340
serie de argumentos.

80
00:03:44,680 --> 00:03:45,139
Ángel,

81
00:03:45,139 --> 00:03:45,699
aquí.

82
00:03:48,039 --> 00:03:48,680
Entonces,

83
00:03:49,460 --> 00:03:51,300
yo puedo

84
00:03:51,300 --> 00:03:52,840
decir, por ejemplo, si eso

85
00:03:52,840 --> 00:03:55,639
args.length

86
00:03:55,639 --> 00:03:59,759
¿Vale? Y podría decir

87
00:03:59,759 --> 00:04:00,680
for

88
00:04:00,680 --> 00:04:03,400
string s

89
00:04:03,400 --> 00:04:07,900
dos puntos args

90
00:04:07,900 --> 00:04:10,939
x o s

91
00:04:10,939 --> 00:04:12,800
Esto

92
00:04:12,800 --> 00:04:14,259
sustancialmente me va a mirar

93
00:04:14,259 --> 00:04:16,459
cuántos argumentos tengo

94
00:04:16,459 --> 00:04:19,180
y me va a mirar cuáles son los argumentos.

95
00:04:20,000 --> 00:04:21,000
¿Sí? Está claro

96
00:04:21,000 --> 00:04:23,000
que normalmente esto me dirá

97
00:04:23,000 --> 00:04:24,879
no hay argumento.

98
00:04:24,879 --> 00:04:26,160
Y por lo tanto no me escribe nada.

99
00:04:28,079 --> 00:04:28,240
¿Sí?

100
00:04:28,379 --> 00:04:36,180
Ahora, si yo me voy, lo hacemos de dos formas. Si yo me voy aquí en el workspace, me voy a,

101
00:04:36,180 --> 00:04:51,060
esto estaba en, estaba en ejemplos, ah, objetos, aquí. En bin y en ejemplos. Y aquí es ejemplo.class,

102
00:04:51,060 --> 00:04:56,519
es la mía. He ido en bin en el otro porque lo quiero ejecutar, ¿vale? Y aquí le doy botón

103
00:04:56,519 --> 00:05:05,220
derecho y abrido en terminal, así estoy aquí. ¿Os acordáis si yo tengo el .class como se ejecuta

104
00:05:05,220 --> 00:05:12,500
un programa? ¿Os acordáis si tenía el java como tenía el .class? Si sois informáticos,

105
00:05:12,500 --> 00:05:20,779
sois programadores, no me podéis obviar estas cosas. Si tengo el .java con javac, javacompiler,

106
00:05:20,779 --> 00:05:28,100
desde allí me crea el .class. Y una vez que tengo el .class hago java y el nombre de la clase,

107
00:05:28,100 --> 00:05:30,199
y me lo ejecuto.

108
00:05:30,199 --> 00:05:30,779
Me lo ejecuto.

109
00:05:32,420 --> 00:05:33,579
Esto es.

110
00:05:34,740 --> 00:05:35,100
A ver.

111
00:05:36,040 --> 00:05:37,800
Ejemplo. Me voy a dar

112
00:05:37,800 --> 00:05:38,959
ejemplos.ejemplo.

113
00:05:49,899 --> 00:05:50,500
Aquí.

114
00:05:51,319 --> 00:05:51,519
¿Vale?

115
00:05:51,879 --> 00:05:54,279
Como este es un package, en vez

116
00:05:54,279 --> 00:05:56,220
de ejecutarlo desde dentro del package,

117
00:05:56,319 --> 00:05:58,399
yo lo estoy ejecutando desde fuera, dándole

118
00:05:58,399 --> 00:06:00,079
que es del package

119
00:06:00,079 --> 00:06:02,319
ejemplo y la clase ejemplo.

120
00:06:02,680 --> 00:06:04,259
¿Vale? Entonces veis que

121
00:06:04,259 --> 00:06:05,720
el comando es java

122
00:06:05,720 --> 00:06:20,589
ejemplos punto ejemplo y me devuelve lo mismo de antes ahora si yo lanzo este programa

123
00:06:22,089 --> 00:06:34,089
y le pasó unos parámetros gato cocodrilo veis que ahora tengo dos parámetros en alex el primer

124
00:06:34,089 --> 00:06:40,449
parámetro es gato, el segundo parámetro es cocodrilo. O sea, lo que escribo a continuación

125
00:06:40,449 --> 00:06:50,589
del comando para ejecutar, se pondrá como string uno en cada casilla del array args.

126
00:06:51,790 --> 00:06:59,230
Y estas cosas de aquí, yo las puedo utilizar dentro del programa para que mi programa haga algo.

127
00:06:59,230 --> 00:07:08,550
Por ejemplo, si este programa leyera en un fichero, yo podría pasarle aquí el fichero que tiene que leer.

128
00:07:09,389 --> 00:07:19,449
Si yo, este programa tiene que crear un cierto número de objetos antes de empezar,

129
00:07:19,670 --> 00:07:23,350
y que pueden ser cinco, pueden ser siete, yo le podría pasar aquí un siete,

130
00:07:23,350 --> 00:07:28,290
pasar este string a entero y decir, si es siete, me crea siete objetos.

131
00:07:28,290 --> 00:07:36,490
vamos que sea un programa que dice aquí recibir argumentos que vienen desde fuera vale sin

132
00:07:36,490 --> 00:07:44,310
necesidad de que separe el programa y que requiera si este programa copiará un fichero yo podría

133
00:07:44,310 --> 00:07:54,189
decirle que fichero quiero copiar y donde quiero copiarlo por ejemplo entiende ahora desde línea

134
00:07:54,189 --> 00:08:03,449
comando esto se escribiría aquí. Si yo pongo claramente 3 separado por espacios pues tengo

135
00:08:03,449 --> 00:08:15,329
tres argumentos gato, cocodrilo, etc. Ahora esto sin tener que salir del eclipse lo puedo hacer

136
00:08:15,329 --> 00:08:26,050
también aquí. Cuando ejecuto, ¿vale? Esto se ejecuta con cero. Puedo hacer run configurations, ¿vale? Si me voy a run

137
00:08:26,050 --> 00:08:33,850
configuration, esta es la clase ejemplo, ¿vale? Aquí tengo arguments. Lo que escribo aquí es como si lo

138
00:08:33,850 --> 00:08:45,850
escribiendo después del java ejemplo. Entonces si escribo gato, cocodrilo, pues y lo aplico,

139
00:08:45,850 --> 00:08:54,230
cuando lo ejecuto, veis que ahora son tres y me han leído estas cosas. ¿Sí? ¿Dudas?

140
00:08:56,330 --> 00:09:06,059
Ahora ya sabéis qué es el método main y qué es esta cosa aquí. ¿Sí? Aquí lo dice, vale,

141
00:09:06,059 --> 00:09:15,220
bla bla bla, representa el array de parámetros, los argumentos, javami-clase, si escribo

142
00:09:15,220 --> 00:09:19,940
javami-clase con algo, tres, otra cosa, tendré algo, tres y otra cosa, teniendo en cuenta

143
00:09:19,940 --> 00:09:27,500
que este es un array de strings, vale, por lo tanto, si tengo que transformar estos tres

144
00:09:27,500 --> 00:09:33,559
en un número, tendré que hacer algo como integer punto parche int de este string.

145
00:09:33,559 --> 00:09:44,360
¿Dudas? Vale, clase main, ¿vale? No método main, pues ya lo hemos hecho mil veces, ¿vale?

146
00:09:44,700 --> 00:09:52,159
Normalmente en un sistema, antes nosotros hacíamos ejercicios que eran, este ejercicio hace algo, crea una clase y hace esa cosa, punto.

147
00:09:52,720 --> 00:09:59,820
Ahora no es así. Ahora cuando nosotros hemos introducido los objetos, hay clases que tienen main y clases que no tienen main.

148
00:10:00,159 --> 00:10:06,899
Una persona no tiene main. Una persona representa a una persona, el alumno representa a un alumno, la escuela representa a la escuela,

149
00:10:06,899 --> 00:10:13,080
estos no tienen un main. Tendrán por otro lado una clase main que lo que hace es usar estos.

150
00:10:13,080 --> 00:10:21,899
Ayer hemos hecho el ejemplo de la libreta y de las personas con las direcciones. Las personas

151
00:10:21,899 --> 00:10:30,940
con las direcciones son modelos que representan los objetos que voy a manejar, que voy a manipular,

152
00:10:30,940 --> 00:10:38,980
pero no tienen un main por sí mismo. Lo que tiene el main es la libreta y podría hasta no tenerlo.

153
00:10:38,980 --> 00:10:44,600
La libreta podría ser una libreta y que luego tú tengas otra clase main que lo que hace es crear

154
00:10:44,600 --> 00:10:50,620
varias libretas y añadir personas a las varias libretas, quitarlas, buscar información o cosas

155
00:10:50,620 --> 00:10:58,700
por el estilo. Pero en un proyecto siempre antes o después tendrá que haber mi punto de acceso real,

156
00:10:58,700 --> 00:11:05,480
que es el punto de acción, aquí es donde empieza mi proyecto. Entonces yo puedo tener 5, 6, 8 clases y

157
00:11:05,480 --> 00:11:12,519
tener una clase que será la que se ejecuta. Cuidado, yo podría tener en cada clase, en persona, en objeto,

158
00:11:12,519 --> 00:11:20,659
en coche y en el main, un main, un método main. Pero normalmente los main de los objetos, digamos que

159
00:11:20,659 --> 00:11:27,259
se usan, pues sirven para probar esa clase y que cuando luego ya se ha acabado, pues

160
00:11:27,259 --> 00:11:31,460
probablemente se me o lo comentó lo quito

161
00:11:32,179 --> 00:11:38,120
yo tengo una clase un sistema como hemos hecho directa

162
00:11:38,120 --> 00:11:45,100
libreta yo tenía tres clases vale gestionar rey no tiene un mail es una

163
00:11:45,100 --> 00:11:50,179
clase estática con métodos estáticos para que yo pueda sustancialmente hacer

164
00:11:50,179 --> 00:11:55,200
más fácil determinadas acciones como añadir o quitar algo de una de una red

165
00:11:55,200 --> 00:12:04,679
Luego tengo libreta de direcciones, que en mi caso esta sería la clase main, la clase principal, porque es la que tiene dentro el main que me permite hacer algo.

166
00:12:05,539 --> 00:12:16,120
Pero si lo miráis, la libreta hace cosas como contar las personas que hay, añadir una persona, obtener la información.

167
00:12:16,399 --> 00:12:20,539
O sea que este main yo lo estoy usando para probar la libreta, pero no es el main.

168
00:12:20,539 --> 00:12:23,019
el main real sería otra clase

169
00:12:23,019 --> 00:12:25,080
donde hay un interfaz de usuario

170
00:12:25,080 --> 00:12:27,120
que me dice, mira, ¿qué quieres hacer?

171
00:12:27,399 --> 00:12:28,720
crear una nueva libreta

172
00:12:28,720 --> 00:12:30,480
abrir una libreta existente

173
00:12:30,480 --> 00:12:32,480
tú abres la libreta existente

174
00:12:32,480 --> 00:12:34,320
ahora te dice, vale, estás en la libreta 3

175
00:12:34,320 --> 00:12:35,980
¿qué quieres hacer? añadir una persona

176
00:12:35,980 --> 00:12:37,320
me explicó

177
00:12:37,320 --> 00:12:38,980
eso sería el main

178
00:12:38,980 --> 00:12:45,340
en el caso de

179
00:12:45,340 --> 00:12:46,200
música

180
00:12:46,200 --> 00:12:49,580
aquí yo tenía mi clase main

181
00:12:49,580 --> 00:12:51,220
que era la que permitía

182
00:12:51,220 --> 00:12:53,379
trabajar con mi clase

183
00:12:53,379 --> 00:12:55,460
partitura que era la que

184
00:12:55,460 --> 00:12:57,860
de verdad representaba el ejercicio

185
00:12:57,860 --> 00:12:58,700
el ejercicio son

186
00:12:58,700 --> 00:13:01,639
trabajar sobre partituras, estoy modelizando una partitura

187
00:13:01,639 --> 00:13:03,460
vale, una vez que he modelizado la partitura

188
00:13:03,460 --> 00:13:05,559
no sé si funciona o no, tendré que crear

189
00:13:05,559 --> 00:13:07,120
algo para ver si funciona, vale

190
00:13:07,120 --> 00:13:09,440
me he creado esta clase main para hacer funcionar

191
00:13:09,440 --> 00:13:10,980
esto es un main falso

192
00:13:10,980 --> 00:13:13,240
no lo usaría nadie, porque

193
00:13:13,240 --> 00:13:15,480
para poder utilizar la partitura tengo que saber

194
00:13:15,480 --> 00:13:17,340
escribir código, y la gente

195
00:13:17,340 --> 00:13:19,340
que usa programas no sabe escribir código

196
00:13:19,340 --> 00:13:20,860
no quiere saber escribir código

197
00:13:20,860 --> 00:13:23,299
cuando vosotros usáis el Word, no estáis

198
00:13:23,299 --> 00:13:26,779
cambiando las funcionalidades de Word aplicando código.

199
00:13:26,779 --> 00:13:30,379
Estáis usando esa aplicación, ¿se entiende?

200
00:13:30,960 --> 00:13:37,340
Hay una interfaz gráfica de Word que os permite escribir vuestro texto sin tener que saber nada de código.

201
00:13:38,600 --> 00:13:47,299
Por debajo el Word tendrá un montón de objetos, un montón de cosas que gestionarán el texto que estáis escribiendo, el

202
00:13:47,299 --> 00:13:52,639
formato, la gramática para que os subraye lo que estáis

203
00:13:52,639 --> 00:13:54,679
escribiendo mal, etcétera, etcétera, etcétera.

204
00:14:01,009 --> 00:14:05,210
Muy bien, entonces sabemos el método main y sabemos la clase

205
00:14:05,210 --> 00:14:09,529
main, que es donde estará el método main principal, el que

206
00:14:09,529 --> 00:14:10,909
empieza, digamos, por ahí.

207
00:14:13,919 --> 00:14:17,740
Entonces hablamos ahora de otro concepto que es estático y no

208
00:14:17,740 --> 00:14:21,860
estático. No sé cómo la palabra para indicar que no es

209
00:14:21,860 --> 00:14:32,100
static, pues no sé si es dinámico, pero lo debería buscar. En Java, cuando no utilizo la palabra

210
00:14:32,100 --> 00:14:37,879
reservada static, me estoy refiriendo a algo que depende de un objeto concreto. O sea, que si un

211
00:14:37,879 --> 00:14:47,039
método o una variable pertenecen a un objeto concreto, a una instancia, entonces ese variable

212
00:14:47,039 --> 00:14:54,539
o ese método, no tendrán la palabra static. Esto quiere decir que dentro, en algún lado de este

213
00:14:54,539 --> 00:15:02,820
método o esta variable, es distinto si lo llamo sobre, si lo uso sobre un objeto o lo uso sobre

214
00:15:02,820 --> 00:15:13,259
un objeto distinto. Si yo hago la clase triángulos equiláteros, que sólo simula y modeliza triángulos

215
00:15:13,259 --> 00:15:21,899
equiláteros, el concepto de lado depende de la instancia del triángulo. No todos los triángulos

216
00:15:21,899 --> 00:15:28,600
tienen el mismo lado. Habrá un triángulo, todos son equiláteros, o sea que los tres lados son

217
00:15:28,600 --> 00:15:34,440
iguales. Pero habrá el triángulo equilátero del lado 3, habrá el triángulo equilátero del lado 5.

218
00:15:34,440 --> 00:15:48,659
¿Vale? Entonces, cada instancia, cada copia de este objeto que yo creo, tendrá dentro una copia de esta variable lado que será instanciada con un valor distinto.

219
00:15:49,639 --> 00:15:58,070
Entonces, yo tengo por un lado algo que me define todos los triángulos equiláteros.

220
00:15:58,070 --> 00:16:08,590
A partir de esto, yo puedo crear triángulos equiláteros, por ejemplo, del lado 3, o triángulos equiláteros del lado 5.

221
00:16:09,649 --> 00:16:18,269
Es más, yo puedo crear un triángulo equilátero del lado 3 que sea distinto de este otro.

222
00:16:18,509 --> 00:16:20,350
Son dos triángulos equiláteros distintos.

223
00:16:22,159 --> 00:16:22,600
¿Entiendes?

224
00:16:23,080 --> 00:16:24,960
Son dos objetos, son dos distancias.

225
00:16:24,960 --> 00:16:40,299
Esta cosa de aquí es un molde genérico que sostancialmente me define qué características tiene y qué puede hacer un triángulo equilátero.

226
00:16:40,299 --> 00:16:47,870
Por ejemplo, tiene que tener un lado y tiene la posibilidad de calcular el perímetro.

227
00:16:47,870 --> 00:16:53,769
Esta es una característica

228
00:16:53,769 --> 00:16:55,309
De los triángulos equiláteros

229
00:16:55,309 --> 00:16:57,590
Este de aquí es un

230
00:16:57,590 --> 00:16:59,269
Un comportamiento

231
00:16:59,269 --> 00:17:00,850
Una funcionalidad

232
00:17:00,850 --> 00:17:02,950
Que pueden tener los triángulos equiláteros

233
00:17:02,950 --> 00:17:05,289
Ahora, todos estos triángulos equiláteros

234
00:17:05,289 --> 00:17:08,009
Tendrán una copia de lado

235
00:17:08,009 --> 00:17:09,609
Setada

236
00:17:09,609 --> 00:17:11,430
O configurada

237
00:17:11,430 --> 00:17:13,049
A su valor concreto

238
00:17:13,049 --> 00:17:14,210
¿Se entiende?

239
00:17:14,210 --> 00:17:25,049
Y si yo llamo esta funcionalidad sobre este triángulo, tendré un resultado distinto con respecto a si lo llamo sobre este triángulo.

240
00:17:25,509 --> 00:17:34,990
Porque el calcular perímetro dependerá de una característica propia de la instancia del objeto en el que estoy trabajando.

241
00:17:36,250 --> 00:17:36,970
¿Están de acuerdo?

242
00:17:37,950 --> 00:17:39,029
¿Dudas hasta aquí?

243
00:17:39,029 --> 00:17:56,740
Entonces, si yo quisiera poner el método cálculo-área, ¿sería estático o no? No estático, ¿vale?

244
00:17:56,740 --> 00:18:04,619
Porque dependerá de este valor de aquí. Ahora, si yo quisiera ponerlo, escribo así, porque así se ve mejor,

245
00:18:04,619 --> 00:18:36,380
el método cálcula, método cálcula, área, cálcula área, triángulo equilátero, lado L. Este señor,

246
00:18:36,380 --> 00:18:48,700
que me calcula el área del triángulo del lado L que le paso por aquí, ¿es estático o no? Sí,

247
00:18:48,700 --> 00:18:55,299
porque que lo llame sobre un triángulo de lado 3 o sobre un triángulo de lado 5,

248
00:18:55,299 --> 00:19:01,299
quien cuenta, quien me calcula el área es esta variable de aquí. Entonces,

249
00:19:01,299 --> 00:19:08,980
si yo llamo sobre este triángulo, calcular el triángulo equilátero 7, y lo llamo aquí,

250
00:19:08,980 --> 00:19:14,920
calcular el triángulo equilátero 7, no depende de nada propio de este objeto,

251
00:19:14,920 --> 00:19:16,660
que el triángulo

252
00:19:16,660 --> 00:19:19,240
del lado 7

253
00:19:19,240 --> 00:19:20,220
es, no lo sé.

254
00:19:22,910 --> 00:19:25,130
Oiga chicos, ¿qué pasa? ¿Estáis hablando mucho?

255
00:19:28,480 --> 00:19:29,059
¿Se entiende?

256
00:19:30,079 --> 00:19:31,720
Entonces, si es

257
00:19:31,720 --> 00:19:33,859
dependiente el método

258
00:19:33,859 --> 00:19:36,200
o la variable

259
00:19:36,200 --> 00:19:38,019
es dependiente del objeto

260
00:19:38,019 --> 00:19:39,799
o sea, instancias distintas

261
00:19:39,799 --> 00:19:41,299
trabajan con

262
00:19:41,299 --> 00:19:44,039
valores y copias y funciones

263
00:19:44,039 --> 00:19:45,799
distintas, pues entonces

264
00:19:45,799 --> 00:19:47,980
eso es no estático. Si en vez

265
00:19:47,980 --> 00:19:50,200
es una función que me vale

266
00:19:50,200 --> 00:19:52,140
para todos los objetos porque hace lo mismo

267
00:19:52,140 --> 00:19:53,720
sea el objeto que sea, por ejemplo

268
00:19:53,720 --> 00:19:54,559
la función random

269
00:19:54,559 --> 00:19:57,380
la función random me da

270
00:19:57,380 --> 00:20:00,160
un valor entre 0 y 9

271
00:20:00,160 --> 00:20:02,200
y 10, o y 1

272
00:20:02,200 --> 00:20:03,299
¿vale?

273
00:20:03,779 --> 00:20:07,710
entonces, ¿tiene sentido

274
00:20:07,710 --> 00:20:09,750
llamarla sobre el triángulo de lado 3

275
00:20:09,750 --> 00:20:12,269
o lado 5? o sea, ¿tiene diferencia?

276
00:20:12,990 --> 00:20:13,789
esto me diría

277
00:20:13,789 --> 00:20:15,769
un número entre 1 y 10, y este me diría

278
00:20:15,769 --> 00:20:16,930
un número entre 1 y 10

279
00:20:16,930 --> 00:20:19,509
ahora, si yo te dijera, no

280
00:20:19,509 --> 00:20:22,049
me da un número aleatorio

281
00:20:22,049 --> 00:20:24,269
entre 0 y el valor

282
00:20:24,269 --> 00:20:28,430
de su lado, entonces ya sería

283
00:20:28,430 --> 00:20:29,390
no estático

284
00:20:29,390 --> 00:20:31,829
porque depende de algo

285
00:20:31,829 --> 00:20:33,990
propio del triángulo

286
00:20:33,990 --> 00:20:35,930
o sea, que esto me dará

287
00:20:35,930 --> 00:20:37,430
un número entre 0 y 3

288
00:20:37,430 --> 00:20:39,609
y esto me dará un número entre 0 y 5

289
00:20:39,609 --> 00:20:41,829
entonces cambia si lo llamo

290
00:20:41,829 --> 00:20:43,049
sobre un triángulo o sobre otro

291
00:20:43,049 --> 00:20:51,759
a ver que se mueve

292
00:20:51,759 --> 00:20:54,119
entonces un atributo de una clase

293
00:20:54,119 --> 00:20:56,319
aparecerá en todas las instancias de esa clase

294
00:20:56,319 --> 00:21:00,400
los objetos. ¿Vale? Pero cada instancia podrá tener

295
00:21:00,400 --> 00:21:04,319
un valor distinto de ese atributo. Todos los

296
00:21:04,319 --> 00:21:08,359
triángulos tienen lado. Yo estoy seguro que un triángulo tendrá lado. ¿Vale?

297
00:21:08,660 --> 00:21:12,220
Pero el valor de lado depende de la instancia. Habrá un lado 5,

298
00:21:12,319 --> 00:21:16,240
un lado 7, un lado 9. ¿Ok? Un método que no es

299
00:21:16,240 --> 00:21:19,680
estático, quiere decir que hay que llamarlo sobre un objeto concreto.

300
00:21:20,579 --> 00:21:24,180
Ah, vale. Un método que no es estático, quiere decir que hay

301
00:21:24,180 --> 00:21:30,720
quise llamarlo sobre un objeto concreto y usará datos de este objeto concreto en su introducción.

302
00:21:30,720 --> 00:21:36,779
Si un método, vosotros escribís un método y allí no se usa nada propio de ese objeto,

303
00:21:36,779 --> 00:21:41,940
ningún atributo del objeto, lo más probable que sea un método estático.

304
00:21:41,940 --> 00:21:53,630
¿Sí? Ejemplo no estático, ¿vale? Tenemos la clase Rectángulo, ¿sí? Que define un

305
00:21:53,630 --> 00:22:01,630
Un rectángulo con su largo y su ancho tiene la posibilidad de aceptar sus datos que le paso a L y B y lo guarda en sus atributos.

306
00:22:02,069 --> 00:22:05,349
Y tiene área que me calcula el área del rectángulo.

307
00:22:05,670 --> 00:22:11,549
Ten en cuenta que tanto aquí como aquí yo estoy utilizando estos valores de aquí.

308
00:22:12,190 --> 00:22:19,569
Por lo tanto, si lo llamo sobre un objeto o lo llamo sobre un objeto distinto, pues lo que pasa es distinto.

309
00:22:20,109 --> 00:22:21,750
Depende del objeto sobre el que lía.

310
00:22:23,630 --> 00:22:23,950
¿Sí o no?

311
00:22:25,450 --> 00:22:26,009
¿Dudas?

312
00:22:29,210 --> 00:22:30,069
Rectangularia, ¿vale?

313
00:22:30,089 --> 00:22:30,789
Que es un main.

314
00:22:30,950 --> 00:22:33,349
Veis que tiene que crear rectángulos

315
00:22:33,349 --> 00:22:35,430
y luego llamar los métodos

316
00:22:35,430 --> 00:22:37,930
sobre los objetos.

317
00:22:38,410 --> 00:22:39,750
Los métodos no estáticos

318
00:22:39,750 --> 00:22:41,430
se tienen que llamar sobre instancias.

319
00:22:41,809 --> 00:22:43,609
¿Cuándo creo instancias con el new?

320
00:22:44,210 --> 00:22:44,450
¿Vale?

321
00:22:44,849 --> 00:22:47,250
La operación new lo que hace es pillarme

322
00:22:47,250 --> 00:22:48,609
las reglas,

323
00:22:48,609 --> 00:22:50,609
la molde,

324
00:22:50,609 --> 00:22:56,109
el molde, la información general de esa clase,

325
00:22:56,509 --> 00:22:59,549
y a partir de eso, a partir de la estructura general de esa clase,

326
00:22:59,650 --> 00:23:02,950
me va a crear un objeto concreto de esa clase, ¿vale?

327
00:23:03,650 --> 00:23:06,910
Rectángulo es una definición de todos los posibles rectángulos.

328
00:23:07,109 --> 00:23:09,930
Si yo os digo, os doy solo este fichero aquí de la izquierda,

329
00:23:09,930 --> 00:23:12,670
y os digo, ¿cuánto vale el rectángulo?

330
00:23:13,470 --> 00:23:14,309
¿Cuánto vale el área?

331
00:23:16,789 --> 00:23:17,289
¿Lo sabéis?

332
00:23:17,910 --> 00:23:21,430
Aquí, si os fijáis, son todas cosas parametrizadas.

333
00:23:21,430 --> 00:23:23,710
Todo depende de largo y ancho

334
00:23:23,710 --> 00:23:26,089
Pero no se ha definido cuánto es largo y ancho

335
00:23:26,089 --> 00:23:28,170
Se definirá

336
00:23:28,170 --> 00:23:29,829
¿Se definirá cuándo?

337
00:23:29,970 --> 00:23:32,130
En el momento en que creo el objeto

338
00:23:32,130 --> 00:23:33,730
Cuando yo he creado

339
00:23:33,730 --> 00:23:35,329
Después de esta línea

340
00:23:35,329 --> 00:23:36,470
Después de la línea 1

341
00:23:36,470 --> 00:23:40,769
¿Cuánto vale recto 1 punto largo?

342
00:23:42,809 --> 00:23:43,450
Pero

343
00:23:43,450 --> 00:23:47,250
No se ha definido ningún constructor

344
00:23:47,250 --> 00:23:49,890
Por lo tanto usará el constructor por defecto

345
00:23:49,890 --> 00:23:51,930
el constructor por defecto pondrá 0 en largo

346
00:23:51,930 --> 00:23:52,630
y 0 en ancho

347
00:23:52,630 --> 00:23:56,089
luego cuando yo lanzo setData

348
00:23:56,089 --> 00:23:58,349
pues sustituiré los valores

349
00:23:58,349 --> 00:24:00,630
a lo que tienen que ser

350
00:24:00,630 --> 00:24:01,609
¿vale?

351
00:24:01,950 --> 00:24:04,069
pero en el momento que yo creo

352
00:24:04,069 --> 00:24:06,329
un rectángulo he creado un objeto

353
00:24:06,329 --> 00:24:07,529
que tiene dentro de sí

354
00:24:07,529 --> 00:24:10,170
un espacio para largo y un espacio para ancho

355
00:24:10,170 --> 00:24:12,529
y que puede hacer estos dos trabajos

356
00:24:12,529 --> 00:24:13,710
puede calcular

357
00:24:13,710 --> 00:24:16,769
puede ser setData o puede calcular su área

358
00:24:16,769 --> 00:24:18,170
¿se entiende?

359
00:24:22,460 --> 00:24:23,059
estático

360
00:24:23,059 --> 00:24:25,259
cuando estamos en un entorno estático

361
00:24:25,259 --> 00:24:28,380
me refiero a algo que no pertenece a un objeto concreto

362
00:24:28,380 --> 00:24:29,859
sino a la clase en general

363
00:24:29,859 --> 00:24:31,579
es algo más genérico

364
00:24:31,579 --> 00:24:34,640
es algo que me sirve para todos los objetos

365
00:24:34,640 --> 00:24:36,640
para todos los objetos de esta clase

366
00:24:36,640 --> 00:24:37,619
o sea, dos opciones

367
00:24:37,619 --> 00:24:40,299
o que todos los objetos de esta clase

368
00:24:40,299 --> 00:24:42,359
harían lo mismo

369
00:24:42,359 --> 00:24:45,440
y por lo tanto este método es independiente

370
00:24:45,440 --> 00:24:48,220
de si lo llamo sobre un objeto o sobre otro

371
00:24:48,220 --> 00:24:50,319
o la segunda opción

372
00:24:50,319 --> 00:24:52,259
es que estoy modelizando una clase

373
00:24:52,259 --> 00:24:54,119
que no tiene instancias.

374
00:24:54,720 --> 00:24:56,059
Que no tiene sentido

375
00:24:56,059 --> 00:24:57,700
crear distancias distintas.

376
00:24:58,079 --> 00:25:00,259
La clase math, que representa

377
00:25:00,259 --> 00:25:01,599
operaciones matemáticas,

378
00:25:02,200 --> 00:25:04,279
tiene sentido crear objetos math.

379
00:25:05,259 --> 00:25:06,240
Tú puedes decir math

380
00:25:06,240 --> 00:25:07,880
math1 es igual a new math

381
00:25:07,880 --> 00:25:09,880
math2 es igual a new math.

382
00:25:10,500 --> 00:25:11,420
¿Qué diferencia hay?

383
00:25:11,980 --> 00:25:14,339
La matemática es diferente si lo usas

384
00:25:14,339 --> 00:25:15,880
un objeto o otro. No, es siempre lo mismo.

385
00:25:15,980 --> 00:25:17,640
La elevación a potencia cambia

386
00:25:17,640 --> 00:25:19,460
si tú pillas un objeto u otro.

387
00:25:19,920 --> 00:25:21,660
Ese peso no se le va a dar a 3

388
00:25:21,660 --> 00:25:22,380
eso no cambia.

389
00:25:24,539 --> 00:25:25,400
De hecho, la clase

390
00:25:25,400 --> 00:25:27,200
math no se instante. Lo puedes hacer así,

391
00:25:27,700 --> 00:25:29,480
pero no me sirve de nada, porque todos sus métodos

392
00:25:29,480 --> 00:25:30,200
son estáticos.

393
00:25:31,819 --> 00:25:33,779
Cuando un método es independiente

394
00:25:33,779 --> 00:25:35,900
de los atributos o la clase

395
00:25:35,900 --> 00:25:37,779
no tiene atributos, pues probablemente

396
00:25:38,480 --> 00:25:39,859
la clase tiene que ser

397
00:25:39,859 --> 00:25:40,819
estática.

398
00:25:42,819 --> 00:25:42,920
¿Sí?

399
00:25:43,940 --> 00:25:45,960
Una clase estática tendrá el mismo

400
00:25:45,960 --> 00:25:47,980
valor para cualquier objeto que la use.

401
00:25:48,599 --> 00:25:49,680
No depende del objeto,

402
00:25:49,680 --> 00:25:54,160
sino de la clase. Cuidado, yo puedo poner parámetros en una clase estática que son

403
00:25:54,160 --> 00:26:02,240
estáticos. Si hago una clase estática y le pongo un valor estático vale para toda la clase. No es

404
00:26:02,240 --> 00:26:14,759
una variable, pero es una constante. Math.py vale 3,14 y es una variable estática, es una constante

405
00:26:14,759 --> 00:26:25,680
estática estática final y entiendo porque no depende y no cambia de si lo

406
00:26:25,680 --> 00:26:30,980
llamamos sobre una matemática sobre otra y es siempre 3,14

407
00:26:31,259 --> 00:26:38,299
sí vale un método estático no se llama sobre

408
00:26:38,299 --> 00:26:42,700
un objeto si no se llama sobre la clase vale no usa los datos de un objeto

409
00:26:42,700 --> 00:26:49,519
concreto para ejecutarse. Puede usar los datos estáticos de esa clase. Cuando vosotros desde un

410
00:26:49,519 --> 00:26:55,119
método estático intentáis acceder a algo que es propio de un objeto, os dará un error diciendo

411
00:26:55,119 --> 00:27:00,880
no puedo desde un entorno, un contexto estático acceder a un contexto no estático. Lo hemos visto

412
00:27:00,880 --> 00:27:10,660
alguna vez. Ejemplo, tenemos una clase estática que me dice staticInt operacionesHechas. Cada vez

413
00:27:10,660 --> 00:27:12,740
que yo hago una operación, pues

414
00:27:12,740 --> 00:27:14,799
esto le sumo uno. ¿Lo veis?

415
00:27:15,920 --> 00:27:16,740
Entonces, en cada

416
00:27:16,740 --> 00:27:18,519
momento yo puedo preguntar a esta clase

417
00:27:18,519 --> 00:27:20,119
estática, ¿cuántas operaciones has hecho?

418
00:27:21,160 --> 00:27:22,559
Independientemente de quién la haya hecho

419
00:27:22,559 --> 00:27:23,400
y cuándo la haya hecho.

420
00:27:24,599 --> 00:27:25,920
Realmente, cada vez que apago

421
00:27:25,920 --> 00:27:28,500
el programa y lo reinicio, pues eso se

422
00:27:28,500 --> 00:27:30,480
reiniciará a cero. Si quisiera

423
00:27:30,480 --> 00:27:32,440
mantener esto, necesitaría

424
00:27:32,440 --> 00:27:34,039
ficheros. Lo vemos más adelante.

425
00:27:35,380 --> 00:27:36,339
Entonces, esto tiene un

426
00:27:36,339 --> 00:27:38,680
calcular a rectángulo. Oye, lo mismo que antes.

427
00:27:38,680 --> 00:27:46,400
Solo que como ahora aquí no hay objetos y no hay los atributos de largo y ancho, me los tienes que pasar por parámetros.

428
00:27:47,559 --> 00:27:55,480
Pero ahora, como me los estás pasando por parámetros y yo aquí dentro uso ellos, pues no hace falta, no dependo de un objeto.

429
00:27:56,779 --> 00:27:58,619
Este método es independiente del objeto.

430
00:27:58,619 --> 00:28:09,460
Si el rectángulo A llama a este método poniendo 3 y 7, no tiene que ver con los datos del mismo rectángulo.

431
00:28:09,559 --> 00:28:14,599
El rectángulo podría ser 3 por 5 y calcular el área de rectángulo de 10 y 20.

432
00:28:16,200 --> 00:28:18,579
Entonces es independiente, no depende del objeto.

433
00:28:19,079 --> 00:28:20,700
Por lo tanto, hablamos sobre la clase.

434
00:28:21,380 --> 00:28:24,960
Y aquí tengo un calculaferímetro que me pilla al lado de ancho y calcula los suyos.

435
00:28:24,960 --> 00:28:32,660
Fijaos que hay un dato estático que sustancialmente se usa desde un contexto estático, entonces se puede usar.

436
00:28:32,660 --> 00:28:42,099
Si yo le quito ese estático y me daría un error, me diría no puedes usar un dato que está duplicado en todas las instancias.

437
00:28:42,279 --> 00:28:48,079
En este caso sería de clase estática, o sea, cuando hago un núcleo de clase estática creo una copia y ahora me dices, súmbala.

438
00:28:48,220 --> 00:28:49,900
¿A qué objeto la tengo que sumar?

439
00:28:49,900 --> 00:28:54,140
si estoy en un contexto estático

440
00:28:54,140 --> 00:28:55,500
no tengo un objeto

441
00:28:55,500 --> 00:28:57,940
aquí dentro, ¿puedo usar this?

442
00:29:04,640 --> 00:29:06,299
no, porque no tengo

443
00:29:06,299 --> 00:29:07,940
un contexto, no tengo

444
00:29:07,940 --> 00:29:09,119
un objeto

445
00:29:09,119 --> 00:29:12,220
estoy estático, no estoy hablando de un objeto

446
00:29:12,220 --> 00:29:13,839
y a este objeto pilla

447
00:29:13,839 --> 00:29:16,079
su valor, no estoy hablando

448
00:29:16,079 --> 00:29:17,680
de objetos, no tengo una instancia

449
00:29:17,680 --> 00:29:20,099
ni siquiera la instancia de este objeto

450
00:29:20,099 --> 00:29:22,140
porque estoy en un contexto estático

451
00:29:22,140 --> 00:29:23,720
¿entienden?

452
00:29:24,200 --> 00:29:25,079
¿cómo se usa?

453
00:29:25,819 --> 00:29:32,380
Por ejemplo, el rectángulo 1 tiene área y clase estática, punto, calcular el rectángulo, 3, 6.

454
00:29:33,319 --> 00:29:38,480
Fijaos que estoy llamando sobre la clase, como hemos hecho con gestión array.

455
00:29:39,700 --> 00:29:41,779
Como habéis hecho con arrays.

456
00:29:42,359 --> 00:29:44,539
Habéis usado arrays.toString.

457
00:29:44,960 --> 00:29:45,740
¿Qué es arrays?

458
00:29:48,490 --> 00:29:52,490
Clase con un método estático toString.

459
00:29:52,490 --> 00:29:54,430
al que le pasas un string

460
00:29:54,430 --> 00:29:55,250
un array

461
00:29:55,250 --> 00:29:58,630
y el método de lo que hace es recorrer

462
00:29:58,630 --> 00:30:00,170
el array en primer lugar

463
00:30:00,170 --> 00:30:02,430
recorrer el array y llamar un

464
00:30:02,430 --> 00:30:03,829
toString por cada elemento

465
00:30:03,829 --> 00:30:08,069
fijaos que al final yo puedo decir

466
00:30:08,069 --> 00:30:10,730
he hecho clase estática punto

467
00:30:10,730 --> 00:30:12,890
operaciones estáticas operaciones

468
00:30:12,890 --> 00:30:14,390
y lo puedo hacer porque estoy en un

469
00:30:14,390 --> 00:30:16,490
contexto estático y estoy llamando

470
00:30:16,490 --> 00:30:17,690
un objeto estático

471
00:30:17,690 --> 00:30:20,829
un atributo estático

472
00:30:20,829 --> 00:30:22,109
una variable estática

473
00:30:22,109 --> 00:30:24,329
que, fijaos, la llamo sobre la clase.

474
00:30:24,890 --> 00:30:26,069
No la llamo sobre un objeto.

475
00:30:28,029 --> 00:30:28,369
¿Dudas?

476
00:30:31,779 --> 00:30:31,980
Bueno.

477
00:30:33,119 --> 00:30:35,180
Estáticos y no estáticos pueden coexistir.

478
00:30:36,319 --> 00:30:37,579
Yo puedo tener una misma clase

479
00:30:37,579 --> 00:30:40,759
que tenga cosas estáticas y cosas no estáticas.

480
00:30:40,900 --> 00:30:43,220
Por ejemplo, yo tengo un rectángulo

481
00:30:43,220 --> 00:30:45,140
que tiene una estática inter,

482
00:30:45,180 --> 00:30:47,099
rectángulos creados, que es igual a cero.

483
00:30:47,480 --> 00:30:49,660
Cada vez que en el constructor

484
00:30:49,660 --> 00:30:52,259
creo un nuevo rectángulo,

485
00:30:52,700 --> 00:30:53,819
le sumo uno a esto.

486
00:30:54,759 --> 00:31:00,059
Entonces, al final, yo puedo preguntar al rectángulo cuántos rectángulos se han creado en general.

487
00:31:00,559 --> 00:31:04,799
Cada rectángulo, si accede a rectángulos creados, tendrá el mismo número.

488
00:31:05,819 --> 00:31:12,279
Si yo creo tres rectángulos, cuando rectángulo 1 accede a rectángulos creados, encontrará tres.

489
00:31:13,160 --> 00:31:15,160
Y el 2, 3, y el 3, 3.

490
00:31:16,220 --> 00:31:19,980
Porque no es una cosa que depende de la estancia, depende de la clase.

491
00:31:19,980 --> 00:31:23,000
entonces cada vez que yo

492
00:31:23,000 --> 00:31:24,920
creo un nuevo rectángulo

493
00:31:24,920 --> 00:31:26,000
o un objeto rectángulo

494
00:31:26,000 --> 00:31:27,700
estoy sumando uno

495
00:31:27,700 --> 00:31:30,640
no a la copia de la variable

496
00:31:30,640 --> 00:31:31,720
de este objeto

497
00:31:31,720 --> 00:31:33,359
más a la clase

498
00:31:33,359 --> 00:31:35,859
entonces todos los que acceden a esa clase

499
00:31:35,859 --> 00:31:37,079
verán esta modificación

500
00:31:37,079 --> 00:31:40,440
es una variable compartida

501
00:31:40,440 --> 00:31:42,799
entre todos los rectángulos

502
00:31:42,799 --> 00:31:44,140
en un cierto sentido

503
00:31:44,140 --> 00:31:47,440
mientras que ancho y largo

504
00:31:47,440 --> 00:31:48,759
cada rectángulo

505
00:31:48,759 --> 00:31:51,339
tiene su copia de ancho y su copia de largo

506
00:31:51,339 --> 00:31:54,420
los rectángulos creados

507
00:31:54,420 --> 00:31:56,839
es una variable que no está dentro del objeto

508
00:31:56,839 --> 00:31:57,960
más está dentro de la clase

509
00:31:57,960 --> 00:32:00,559
y todos cuando acceden es compartir entre ellos

510
00:32:00,559 --> 00:32:01,779
y si uno la modifica

511
00:32:01,779 --> 00:32:03,819
los otros verán la modificación

512
00:32:03,819 --> 00:32:09,920
al crear el nuevo objeto

513
00:32:09,920 --> 00:32:11,539
se modificará

514
00:32:11,539 --> 00:32:15,960
y lo verán también los objetos que habían sido creados antes

515
00:32:15,960 --> 00:32:18,279
public int area

516
00:32:18,279 --> 00:32:20,240
veis que no es estática

517
00:32:20,240 --> 00:32:22,039
y entonces usará

518
00:32:22,039 --> 00:32:24,059
ancho y largo del propio objeto

519
00:32:24,059 --> 00:32:25,960
esto aquí depende del objeto

520
00:32:25,960 --> 00:32:27,700
si lo llevamos sobre un objeto tendremos

521
00:32:27,700 --> 00:32:29,680
un resultado, si lo llevamos sobre otro objeto

522
00:32:29,680 --> 00:32:30,980
tendremos un resultado distinto

523
00:32:30,980 --> 00:32:33,759
y public static int total

524
00:32:33,759 --> 00:32:36,380
rectángulo creados, pues que devuelve

525
00:32:36,380 --> 00:32:37,740
esta variable estática

526
00:32:37,740 --> 00:32:39,880
es estático porque no depende

527
00:32:39,880 --> 00:32:43,789
del objeto, esto lo llamaría

528
00:32:43,789 --> 00:32:45,809
sobre la clase rectángulo

529
00:32:45,809 --> 00:32:47,670
mientras esto de aquí

530
00:32:47,670 --> 00:32:49,049
lo llamaría sobre un objeto

531
00:32:49,049 --> 00:32:52,390
rectángulo, dudas?

532
00:32:52,390 --> 00:32:57,289
Preguntas

533
00:32:57,289 --> 00:33:00,660
¿Lo habéis entendido?

534
00:33:01,839 --> 00:33:03,900
Si lo habéis entendido, ¿por qué luego lo falláis?

535
00:33:09,039 --> 00:33:09,339
Vale

536
00:33:09,339 --> 00:33:11,920
En la segunda hora

537
00:33:11,920 --> 00:33:14,019
Hacemos algún ejemplo de estas cosas

538
00:33:14,019 --> 00:33:14,559
¿Vale? Pero

539
00:33:14,559 --> 00:33:16,599
Acabo con la teoría

540
00:33:16,599 --> 00:33:19,700
Organización del código, esto me interesa relativamente

541
00:33:19,700 --> 00:33:21,480
¿Vale? La idea es que

542
00:33:21,480 --> 00:33:24,059
Los códigos en Java se pueden organizar

543
00:33:24,059 --> 00:33:24,960
En proyectos

544
00:33:24,960 --> 00:33:27,160
Dentro de los proyectos en la parte sur

545
00:33:27,160 --> 00:33:28,680
Se pueden crear paquetes

546
00:33:28,680 --> 00:33:31,599
Y dentro de los paquetes las clases

547
00:33:31,599 --> 00:33:35,339
la idea es que cuando vosotros montáis un programa

548
00:33:35,339 --> 00:33:37,140
un sistema un poquito más complejo

549
00:33:37,140 --> 00:33:41,079
organizéis esta estructura

550
00:33:41,079 --> 00:33:43,420
de una forma coherente a lo que vais a hacer

551
00:33:43,420 --> 00:33:46,339
no me mezcléis todos dentro del mismo package

552
00:33:46,339 --> 00:33:48,819
pero si hay un package que gestiona los alumnos

553
00:33:48,819 --> 00:33:52,019
un package que gestiona la parte financiera de una escuela

554
00:33:52,019 --> 00:33:54,759
un package que gestiona las materias

555
00:33:54,759 --> 00:33:57,359
pues pueden ir en packages distintos

556
00:33:57,359 --> 00:34:00,420
para que luego yo sepa si tengo que tocar algo

557
00:34:00,420 --> 00:34:07,500
en qué package voy a tocar. O si tengo que importar uno de estos packages en un main o

558
00:34:07,500 --> 00:34:12,719
cosa por el estilo porque, por ejemplo, es inútil para los profesores importar el package, para el

559
00:34:12,719 --> 00:34:19,559
gestional de los profesores, el programa que usarán los profesores, importar el package de

560
00:34:19,559 --> 00:34:26,659
la gestión financiera porque los profesores no manejan el dinero. Eso lo usará el aplicativo

561
00:34:26,659 --> 00:34:40,820
que usará la secretaria para poder hacer. Overloading o sobrecarga de un método es cuando

562
00:34:40,820 --> 00:34:53,400
yo tengo un método que se llama igual pero tiene distintos parámetros. El número de parámetros de

563
00:34:53,400 --> 00:34:57,579
entradas distintos, el tipo de algunos de los parámetros son distintos o una combinación de

564
00:34:57,579 --> 00:35:04,840
los dos anteriores. Yo puedo hacer mi método de int y mi método de double. Y el programa,

565
00:35:04,840 --> 00:35:10,780
la llave de Thomasin sabrá si utilizar uno o utilizar el otro en base al parámetro que tú

566
00:35:10,780 --> 00:35:19,539
me pasas. Si tú me pasas mi método de 3, pues lo usaré con int. Si me pasas mi método de 3.0,

567
00:35:19,539 --> 00:35:26,559
3.0 es un double, pues entonces utilizaré la opción con double. Lo que no puede hacer es dos

568
00:35:26,559 --> 00:35:32,440
que tenga la misma firma. La firma es el nombre y la lista de tipos de parámetros.

569
00:35:32,440 --> 00:35:47,960
¿Sí? Tened en cuenta, lo que devuelve un método no entra en la firma. Si yo tengo, por algún lado,

570
00:35:47,960 --> 00:36:06,019
Por ejemplo, si yo tengo por algún lado el método public void mi método de int x que

571
00:36:06,019 --> 00:36:18,599
hace algo, no puedo hacer public void mi método de int x y decir, mira, no, porque es lo mismo,

572
00:36:18,599 --> 00:36:27,340
pues entonces le pongo aquí int. Y esto es algo que devuelve return a 3. O sea, no me lo acepta,

573
00:36:27,340 --> 00:36:36,760
porque la firma de este método es mi método int. Y esto tiene la misma firma, mi método int. Si yo

574
00:36:36,760 --> 00:36:46,639
te paso, si yo llamo en algún lado, no lo sé, sobre un objeto obj punto mi método 3, es 43,

575
00:36:46,639 --> 00:36:50,360
Java no sabe

576
00:36:50,360 --> 00:36:51,880
si tiene que usar esto

577
00:36:51,880 --> 00:36:53,519
o si tiene que usar esto.

578
00:36:54,300 --> 00:36:55,039
No lo puede saber.

579
00:36:56,300 --> 00:36:58,079
Y entonces es ambiguo, entonces se inflaba.

580
00:36:59,579 --> 00:37:00,340
Ahora, si esto

581
00:37:00,340 --> 00:37:02,119
yo le digo, tú eres doble,

582
00:37:06,869 --> 00:37:08,309
pues ahora si yo lo llamo así,

583
00:37:09,570 --> 00:37:10,090
llamará este

584
00:37:10,090 --> 00:37:12,150
método aquí y hará esto.

585
00:37:12,949 --> 00:37:13,989
Si yo lo llamo así,

586
00:37:15,050 --> 00:37:15,650
llamará esto.

587
00:37:18,579 --> 00:37:22,079
¿Entiendes? También

588
00:37:22,079 --> 00:37:25,980
podría hacer un public

589
00:37:25,980 --> 00:37:39,079
voy int, int, pero ponerle otra cosa, boolean. Entonces ahora este método de aquí es, la firma

590
00:37:39,079 --> 00:37:45,500
es mi método de int, esta firma aquí es mi método de int boolean. Entonces este de aquí se llamará,

591
00:37:45,500 --> 00:37:52,199
cuando llamo esto, estoy llamando este método de aquí, cuando llamo esta cosa aquí, estoy llamando

592
00:37:52,199 --> 00:37:59,400
este método. Importante que sea único, que no sea ambiguo qué método voy a llamar.

593
00:37:59,400 --> 00:38:07,079
Ahora, crear un método que se llama igual, pero tiene distintos parámetros, se llama

594
00:38:07,079 --> 00:38:22,639
sobrecargar este método. Overload. ¿Dónde hemos usado nosotros el overload? En print,

595
00:38:22,639 --> 00:38:29,360
por ejemplo. Print es un método que está sobrecargado porque puedo hacer print de un int,

596
00:38:29,659 --> 00:38:33,619
puedo hacer print de un double, puedo hacer un print de un string, puedo hacer un print de un object.

597
00:38:35,079 --> 00:38:41,340
Pero lo hemos usado pero no lo sabíamos y no lo hemos creado nosotros. ¿Dónde nosotros hemos creado

598
00:38:41,340 --> 00:38:52,150
cosas sobrecargadas? En los constructores. Cuando tú haces un constructor que pilla un solo parámetro,

599
00:38:52,150 --> 00:38:54,730
un constructor que pilla tres parámetros, está sobrecargando

600
00:38:54,730 --> 00:38:56,570
el constructor. Acordaos que el constructor

601
00:38:56,570 --> 00:38:58,570
es un método. Un método especial

602
00:38:58,570 --> 00:39:00,429
porque devuelve un

603
00:39:00,429 --> 00:39:02,389
objeto de esta clase, pero

604
00:39:02,389 --> 00:39:03,230
eso es otro método.

605
00:39:04,570 --> 00:39:05,090
¿Dudas?

606
00:39:06,710 --> 00:39:08,369
Si entiendes el concepto de

607
00:39:08,369 --> 00:39:11,800
sobrecargar, vale.

608
00:39:13,219 --> 00:39:14,059
En inglés, overload.

609
00:39:14,340 --> 00:39:16,079
¿Vale? No confundir con

610
00:39:16,079 --> 00:39:18,119
overwrite.

611
00:39:19,119 --> 00:39:19,940
¿Vale? Que lo veremos

612
00:39:19,940 --> 00:39:22,039
sobreescribir. Lo veremos más

613
00:39:22,039 --> 00:39:26,659
adelante. Por ahora lo hemos hecho, cuando hemos hecho el toString, cuando hemos

614
00:39:26,659 --> 00:39:30,280
hecho el equals, hemos hecho la sobrescriptura, pero todavía no lo

615
00:39:30,280 --> 00:39:34,280
entendemos bien, porque todavía no sabemos el concepto de herencia.

616
00:39:34,280 --> 00:39:43,420
Conectación del código otra vez, vale, aquí os dice cómo navegar, qué sé yo,

617
00:39:43,420 --> 00:39:48,300
lo leéis. Encapsulación y visibilidad son las

618
00:39:48,300 --> 00:39:52,619
últimas dos cosas que me quedan, que sustancialmente es cuando creo un método

619
00:39:52,619 --> 00:39:55,420
o cuando creo un atributo, ¿vale?

620
00:39:55,440 --> 00:39:59,199
Le puedo decir dónde se puede ver este atributo,

621
00:39:59,320 --> 00:40:01,699
dónde se puede ver este objeto, ¿vale?

622
00:40:02,380 --> 00:40:05,719
Normalmente nosotros hemos usado public y private, ¿vale?

623
00:40:06,239 --> 00:40:09,719
Public quiere decir que tú puedes acceder allí

624
00:40:09,719 --> 00:40:11,119
desde donde quieras.

625
00:40:11,659 --> 00:40:13,360
Si tú tienes acceso a esta clase,

626
00:40:13,940 --> 00:40:17,659
puedes acceder a ese variable, a ese atributo, ¿vale?

627
00:40:17,980 --> 00:40:20,579
Nosotros lo hemos hecho que desde otra clase accedo allí,

628
00:40:20,579 --> 00:40:21,440
¿vale? Fenomenal.

629
00:40:21,440 --> 00:40:23,420
Pero las dos clases estaban en el mismo package.

630
00:40:23,579 --> 00:40:25,659
Hasta si estuvieras en packages distintos,

631
00:40:26,119 --> 00:40:27,980
pues podrías acceder a esas variables.

632
00:40:28,139 --> 00:40:30,119
En una variable pública, todos pueden acceder.

633
00:40:31,719 --> 00:40:33,539
Private es el opuesto.

634
00:40:34,019 --> 00:40:37,579
Solo se puede acceder a esa variable dentro de esa clase.

635
00:40:37,900 --> 00:40:40,880
Como salgas de esa clase, no es accesible esa variable.

636
00:40:41,719 --> 00:40:44,159
Si quieres que alguien pueda modificarla o leerla,

637
00:40:44,340 --> 00:40:47,219
tendrás que crear métodos públicos, por ejemplo,

638
00:40:47,639 --> 00:40:49,480
que permitan acceder a esa variable.

639
00:40:49,480 --> 00:40:51,179
Y que hagan algún control.

640
00:40:51,179 --> 00:40:52,139
y que me pidan

641
00:40:52,139 --> 00:40:55,239
que verifiquen que yo pueda acceder

642
00:40:55,239 --> 00:40:56,500
o que lo pueda modificar

643
00:40:56,500 --> 00:40:59,039
como es un método

644
00:40:59,039 --> 00:41:01,159
no es necesariamente que te lo devuelvo

645
00:41:01,159 --> 00:41:03,320
directamente, de hecho, un get o un set

646
00:41:03,320 --> 00:41:05,340
un método que te devuelve directamente

647
00:41:05,340 --> 00:41:07,360
y que si tú implementas

648
00:41:07,360 --> 00:41:08,840
tanto leer como escribir

649
00:41:08,840 --> 00:41:10,940
sin hacer nada, pues entonces

650
00:41:10,940 --> 00:41:13,239
podrías dejarlo public, no pasa nada

651
00:41:13,239 --> 00:41:15,599
sin embargo

652
00:41:15,599 --> 00:41:17,199
como hemos hecho alguna vez, si tú haces

653
00:41:17,199 --> 00:41:19,059
un set de edad

654
00:41:19,059 --> 00:41:20,960
pero dices que, oye, mira, yo voy a

655
00:41:20,960 --> 00:41:22,940
aceptar la edad que me pasas tú, siempre

656
00:41:22,940 --> 00:41:24,139
cuando sea positiva

657
00:41:24,139 --> 00:41:26,579
ya estás haciendo una cosa distinta

658
00:41:26,579 --> 00:41:28,539
porque si yo tenía acceso público

659
00:41:28,539 --> 00:41:31,039
a la variable, habría podido ponerle que tu edad

660
00:41:31,039 --> 00:41:33,159
es menos 7, como yo le he quitado

661
00:41:33,159 --> 00:41:34,420
el acceso público a la variable

662
00:41:34,420 --> 00:41:37,000
y ahora le he puesto un método que me

663
00:41:37,000 --> 00:41:39,039
verifica que el número que me estás dando tú

664
00:41:39,039 --> 00:41:41,179
sea positivo, ya estoy haciendo un control

665
00:41:41,179 --> 00:41:43,099
adicional, esta es una cosa

666
00:41:43,099 --> 00:41:43,840
que hemos hecho

667
00:41:43,840 --> 00:41:45,260
¿os dais?

668
00:41:47,119 --> 00:41:47,340
¿sí?

669
00:41:49,159 --> 00:41:50,239
ahora, hay

670
00:41:50,239 --> 00:41:52,880
modificadores entre medias.

671
00:41:53,619 --> 00:41:54,699
¿Vale? Público accede

672
00:41:54,699 --> 00:41:56,900
en todos, privado no accede en nadie.

673
00:41:57,219 --> 00:41:58,460
Fuera de la clase. ¿Vale?

674
00:41:58,780 --> 00:42:00,019
Luego está el package.

675
00:42:01,260 --> 00:42:02,880
A esta variable se puede acceder

676
00:42:02,880 --> 00:42:04,719
solo, o sea, se pueden acceder todas

677
00:42:04,719 --> 00:42:06,699
las clases, o sea, código

678
00:42:06,699 --> 00:42:08,739
de clases que pertenezcan al

679
00:42:08,739 --> 00:42:09,440
mismo package.

680
00:42:12,099 --> 00:42:14,280
Entonces, si yo tengo dos

681
00:42:14,280 --> 00:42:16,079
clases que están

682
00:42:16,079 --> 00:42:18,539
definidas en el mismo package,

683
00:42:18,679 --> 00:42:19,780
por ejemplo, tengo

684
00:42:19,780 --> 00:42:25,539
este main esta partitura si esta partitura en vez de privar os acordáis que desde el main no podía

685
00:42:25,539 --> 00:42:38,929
acceder a autor yo aquí hago part2.autor es igual a algo se enfada ah porque es partitura

686
00:42:41,409 --> 00:42:47,989
se enfada me dice hoy es privado no puedo vale pero esto en el mismo package entonces si yo me

687
00:42:47,989 --> 00:42:57,789
voy aquí a donde está en partitura y le digo oye partitura autor en realidad es

688
00:42:57,789 --> 00:43:06,489
dentro del package

689
00:43:06,489 --> 00:43:14,489
es posible que si lo pongo así sea package ahora en teoría si puedo vale

690
00:43:14,489 --> 00:43:19,889
claro que no le he puesto public le he puesto nada cuando es no es protective

691
00:43:19,889 --> 00:43:27,449
ahora lo miro y luego os lo digo vale entonces tenemos para variables y

692
00:43:27,449 --> 00:43:34,949
métodos estos cuatro niveles vale si no pongo nada es para que vale entonces para que no es

693
00:43:34,949 --> 00:43:41,090
una palabra reservada como tal pero sino que si no pongo nada la visibilidad del del package

694
00:43:41,090 --> 00:43:53,690
private es sólo de la clase public es de donde sea protected es no lo entendemos vale es si la

695
00:43:53,690 --> 00:44:01,489
clase es descendente en términos de herencia de ésta o del mismo país. No lo entendemos porque

696
00:44:01,489 --> 00:44:08,690
todavía no sabemos qué es la herencia. Simplemente esto lo recuperaremos en un futuro. Van en orden,

697
00:44:08,690 --> 00:44:19,929
¿vale? Desde la más pública, la más permisiva, a la más estricta. Ahora, vamos a ver cómo funciona

698
00:44:19,929 --> 00:44:29,670
Hemos visto que si yo pongo este autor, tengo partitura y tengo el main, que están en el mismo package.

699
00:44:29,670 --> 00:44:38,949
Si yo pongo autor como package, pues lo puedo usar tranquilamente desde fuera, desde el mismo package.

700
00:44:39,070 --> 00:44:46,449
Pero si yo me pillo en ejemplos, mi ejemplo, y intento usar aquí una partitura.

701
00:44:46,449 --> 00:45:03,829
partitura p es igual a new a partitura que pillaba que autor la cosa los y el

702
00:45:03,829 --> 00:45:10,849
tiempo no esto no me la ve no me la ve porque está en otro package él busca aquí dentro del

703
00:45:10,849 --> 00:45:17,269
package la partitura y no la encuentra entonces no está la clase partitura vale muy bien la

704
00:45:17,269 --> 00:45:39,539
la importo, esto creo que con música, como la importo, import partitura de música, ahí,

705
00:45:39,539 --> 00:45:46,800
musica.partitura, va, text o musica.asterisco para importar todas las clases que están

706
00:45:46,800 --> 00:45:52,880
dentro de esto, vale, entonces como ahora he importado este package y puedo utilizar

707
00:45:52,880 --> 00:45:58,519
partitura pues perfecto vale pero ahora estoy en packages distintos es decir que si yo aquí

708
00:45:58,519 --> 00:46:12,989
intento acceder en p.autor se enfada porque me dice no mira autor no es visible desde fuera

709
00:46:12,989 --> 00:46:21,369
del package vale porque como yo lo he definido partitura como si nada es package entonces se ve

710
00:46:21,369 --> 00:46:25,969
sólo en las clases que pertenecen a este Package. Si yo estoy aquí y lo pongo como public,

711
00:46:25,969 --> 00:46:36,050
pues entonces también desde ejemplo ahora lo puedo acceder. Desde cualquier clase hasta que

712
00:46:36,050 --> 00:46:46,849
no sea dentro del mismo Package sí puedo acceder. ¿Entiende? Entonces, privada sólo desde dentro de

713
00:46:46,849 --> 00:46:54,769
esta clase. Sin nada, desde esta clase y desde todas las clases de su package puedo manipular

714
00:46:54,769 --> 00:47:08,409
esta cosa directamente. Public, desde cualquier sitio. ¿Dudas? Entonces, ¿cómo podría hacer,

715
00:47:10,269 --> 00:47:18,820
mantener esta privada y hacerla accesible desde ejemplo y desde main? Por ejemplo,

716
00:47:18,820 --> 00:47:32,949
en sola lectura. Me debería crear aquí un método public string getAutor, que lo que hace es

717
00:47:32,949 --> 00:47:41,840
returna autor. Aquí lo puedo usar porque estoy en la misma clase, lo puedo usar en private. Pero

718
00:47:41,840 --> 00:47:48,340
cuando la llamo desde fuera, no estoy accediendo directamente a autor, estoy llamando este método

719
00:47:48,340 --> 00:48:00,730
que es público. Entonces se podrá pillar tanto de aquí, bueno para escribir parte.getAutor,

720
00:48:00,730 --> 00:48:11,489
podrá ceder porque el método es público, y también aquí. Lo mismo que he escrito aquí lo

721
00:48:11,489 --> 00:48:22,159
puedo hacer afuera porque el método es público, lo puedo llamar también aquí. Ahora, si el método

722
00:48:22,159 --> 00:48:25,099
y este autor fuera

723
00:48:25,099 --> 00:48:26,539
sin nada,

724
00:48:28,400 --> 00:48:29,079
desde main

725
00:48:29,079 --> 00:48:31,260
lo puedo llamar, desde aquí no.

726
00:48:31,980 --> 00:48:33,179
Porque sería solo interno

727
00:48:33,179 --> 00:48:33,539
al packet.

728
00:48:34,920 --> 00:48:38,760
¿Entiendes? Y fijaos que

729
00:48:38,760 --> 00:48:41,000
¿qué ha cambiado? Pues ha cambiado

730
00:48:41,000 --> 00:48:42,559
que ahora esta variable aquí

731
00:48:42,559 --> 00:48:44,960
es de sola lectura, fuera

732
00:48:44,960 --> 00:48:46,340
de esta clase.

733
00:48:46,940 --> 00:48:48,500
Pero esta clase no se puede sobreescribir,

734
00:48:48,659 --> 00:48:50,539
no se puede cambiar, pero sí se puede leer.

735
00:48:53,090 --> 00:48:57,599
¿Entiendes? Y ahora

736
00:48:57,599 --> 00:49:08,110
digo no pero quiero que se pueda también escribir entonces pongo void set autor que pilla un autor

737
00:49:08,110 --> 00:49:19,460
y lo que hago es que autor es igual a out esto quiere decir que ahora lo puedo modificar donde

738
00:49:19,460 --> 00:49:24,500
me da la gana lo puedo modificar desde el main que es el mismo package y lo puedo modificar

739
00:49:24,500 --> 00:49:29,460
también desde aquí yo puedo hacer ahora tranquilamente antes de escribir el autor

740
00:49:29,460 --> 00:49:32,159
p.setAutor

741
00:49:32,159 --> 00:49:33,619
de gato.

742
00:49:35,280 --> 00:49:35,960
Y me funciona.

743
00:49:36,119 --> 00:49:37,400
Lo puedo hacer. Ahora,

744
00:49:37,900 --> 00:49:40,219
si yo he hecho en partitura

745
00:49:40,219 --> 00:49:41,719
un getAutor

746
00:49:41,719 --> 00:49:43,159
y un setAutor

747
00:49:43,159 --> 00:49:45,179
públicos

748
00:49:45,179 --> 00:49:47,300
que hacen sólo esto,

749
00:49:48,300 --> 00:49:49,900
es equivalente a no haber hecho nada

750
00:49:49,900 --> 00:49:51,199
y haber dejado esto público.

751
00:49:53,719 --> 00:49:56,039
Porque puedo leerla, puedo escribirla

752
00:49:56,039 --> 00:49:57,679
y no hay ninguna

753
00:49:57,679 --> 00:49:59,559
cosa extra. Entonces,

754
00:49:59,559 --> 00:50:04,739
Entonces, para eso, quito el getter set y lo que hago es accesible directamente públicamente

755
00:50:04,739 --> 00:50:05,739
este autor.

756
00:50:05,739 --> 00:50:10,340
Ahora, si yo te digo, mira, leerla lo puedes leer por todos lados, no me interesa.

757
00:50:10,340 --> 00:50:19,059
Pero cuando la vas a aceptar, yo quiero que out… fijaos, perdón, vuelvo atrás, aquí

758
00:50:19,059 --> 00:50:29,250
nadie me prohibiría de hacer esto, ¿entiendes?

759
00:50:29,250 --> 00:50:32,389
Estoy haciendo una partitura sin autor, con autor null.

760
00:50:32,389 --> 00:50:34,889
Imaginamos que yo digo, no, el autor tiene que existir.

761
00:50:41,619 --> 00:50:48,380
Entonces yo puedo decir, vale, la escritura, no hago que sea, puedes hacer lo que te da la gana.

762
00:50:48,579 --> 00:50:49,820
Más pongo unos controles.

763
00:50:49,920 --> 00:51:02,300
Por ejemplo, tú me has dado un algo, pero yo quiero que si esto es not null, entonces sí cámbienlo.

764
00:51:02,860 --> 00:51:03,260
Si no, no.

765
00:51:04,000 --> 00:51:07,460
Entonces ya aquí es distinto de haber dejado esto como public.

766
00:51:07,719 --> 00:51:11,219
Porque esto como public yo puedo hacer lo que me da la gana con el autor hasta ponerle null.

767
00:51:11,280 --> 00:51:17,460
Aquí yo estoy forzando que cada vez que yo intente cambiar el autor, me comprueba si es nulo o no.

768
00:51:17,780 --> 00:51:18,920
Entonces, nunca será nulo.

769
00:51:20,480 --> 00:51:20,920
¿Me entiendes?

770
00:51:22,400 --> 00:51:29,039
Y yo podría decir también, i, out.length, mayor que 1.

771
00:51:30,960 --> 00:51:31,199
¿Me entiendes?

772
00:51:32,059 --> 00:51:39,639
Te estoy diciendo, oye, si lo que me has dado es nulo, no es nulo, y además tiene una longitud, no es una cadena vacía,

773
00:51:39,639 --> 00:51:44,380
pues entonces sí te lo acepto como autor, si no, no. Entonces quiere decir que ahora yo estoy haciendo

774
00:51:44,380 --> 00:51:50,139
partituras que una vez creadas no se puede modificar su autor como null, no se puede modificar su

775
00:51:50,139 --> 00:51:58,179
autor como cadena vacía. Es distinto con respecto a haberle puesto aquí public. Ya no es la misma cosa.

776
00:51:58,179 --> 00:52:11,989
¿Se entiende? Vale. Y poco más. Esto por ahora public, private o nada, dependiendo

777
00:52:11,989 --> 00:52:17,210
de cómo quieras hacerlo. ¿Para qué sirve esto al fin y al cabo? Porque cuando yo creo

778
00:52:17,210 --> 00:52:21,510
un package, yo creo un package sobre música que gestiona toda la cosa de música, yo creo

779
00:52:21,510 --> 00:52:25,730
un package sobre la libreta y cosas por el estilo. Todas las clases que estoy haciendo

780
00:52:25,730 --> 00:52:30,329
en este package probablemente las creo yo. Entonces dentro de este package yo tengo un

781
00:52:30,329 --> 00:52:32,170
cierto control, que pueda acceder

782
00:52:32,170 --> 00:52:34,190
a variables de otras clases, porque

783
00:52:34,190 --> 00:52:36,030
como las produzco yo, como las estoy

784
00:52:36,030 --> 00:52:38,389
codificando yo, pues son como

785
00:52:38,389 --> 00:52:39,909
del mismo autor

786
00:52:39,909 --> 00:52:41,929
y tú sabes cómo manejarlas bien.

787
00:52:42,250 --> 00:52:44,309
Pero no te fías de cómo la van

788
00:52:44,309 --> 00:52:46,230
a usar personas fuera que

789
00:52:46,230 --> 00:52:48,349
usan tu package, que importan tu package

790
00:52:48,349 --> 00:52:50,170
y lo quieren utilizar, pero

791
00:52:50,170 --> 00:52:52,510
no saben bien los mecanismos internos

792
00:52:52,510 --> 00:52:54,050
y a lo mejor cuando me van a escribir

793
00:52:54,050 --> 00:52:56,329
los instrumentos,

794
00:52:57,150 --> 00:52:58,409
en vez de separarlo por coma,

795
00:52:58,409 --> 00:53:00,389
me lo separa por punto y coma y explota

796
00:53:00,389 --> 00:53:02,489
entonces yo lo que hago es

797
00:53:02,489 --> 00:53:04,590
la pongo privada o la pongo

798
00:53:04,590 --> 00:53:06,750
sin nada

799
00:53:06,750 --> 00:53:08,789
para que la proteja dentro de mi

800
00:53:08,789 --> 00:53:10,750
de mi

801
00:53:10,750 --> 00:53:12,349
package que yo sé usarla

802
00:53:12,349 --> 00:53:14,650
y luego a ti te doy la posibilidad de

803
00:53:14,650 --> 00:53:16,510
oye mira, tú puedes añadir

804
00:53:16,510 --> 00:53:17,909
un instrumento

805
00:53:17,909 --> 00:53:20,650
pero dime que instrumento quieres

806
00:53:20,650 --> 00:53:22,630
añadir y yo te lo añado bien

807
00:53:22,630 --> 00:53:24,570
te lo añado con las reglas

808
00:53:24,570 --> 00:53:26,969
mías, no te permitas de añadir

809
00:53:26,969 --> 00:53:33,969
comas como te da la gana, o punto y coma, o cosa por el estilo, ¿entiendes? Aún así, esto tiene sus

810
00:53:35,969 --> 00:53:41,969
posibilidades de agregarlo, ¿vale? ¿Os acordáis cómo funcionaba? Si aquí yo como instrumento le doy viola, coma,

811
00:53:41,969 --> 00:53:52,599
flauta, pues me estoy añadiendo dos a la vez. Si le doy no sé qué, coma, coma, no sé cuánto, pues estoy

812
00:53:52,599 --> 00:53:54,699
pues estoy añadiendo un instrumento que no existe.

813
00:54:00,190 --> 00:54:05,389
Vale, de la misma forma nosotros public lo hemos utilizado también en otro lado.

814
00:54:10,380 --> 00:54:17,280
O sea que como hay niveles de visibilidad de encapsulación para

815
00:54:19,280 --> 00:54:25,280
métodos y variables, que son estos, existen también métodos de visibilidad,

816
00:54:25,280 --> 00:54:35,039
modificadores de visibilidad para las clases enteras. Hay public, sin nada, protected,

817
00:54:35,039 --> 00:54:46,219
y private. Pero esto afecta la clase, o sea, donde yo puedo hacer new. Si yo tengo una clase privada,

818
00:54:46,219 --> 00:54:54,800
solo puedo hacer new desde dentro de esa clase. Si no, no puedo. Si la tengo package, pues desde

819
00:54:54,800 --> 00:55:00,320
todo el package, si ya tengo public lo puedo hacer donde me dé la gana. Si os acordáis nosotros también

820
00:55:00,320 --> 00:55:08,659
decíamos que en una clase, por ejemplo la clase ejemplo, yo puedo tener una sola clase que se

821
00:55:08,659 --> 00:55:16,679
llama ejemplo dentro del fichero ejemplo, solo una clase pública, pero nadie me prohíbe aquí poner

822
00:55:16,679 --> 00:55:29,250
una clase, otra clase, y creando una clase completamente con sus atributos, por ejemplo,

823
00:55:29,250 --> 00:55:44,739
int un atributo, string otro atrib, y un método, por ejemplo, public void string,

824
00:55:44,739 --> 00:56:08,889
sí, so, un attribute, más espacio, más otro attribute, ¿vale? Entonces yo lo hago desde esta clase, por ejemplo,

825
00:56:09,429 --> 00:56:19,929
desde dentro del main, puedo crear un objeto de otra clase, otra clase, object, es igual a new, otra clase,

826
00:56:19,929 --> 00:56:25,440
y acceder a sus valores

827
00:56:25,440 --> 00:56:28,320
obj.unatrib

828
00:56:28,320 --> 00:56:29,440
y darle

829
00:56:29,440 --> 00:56:30,639
igual a 0 a 4

830
00:56:30,639 --> 00:56:34,980
obj.otroatrib

831
00:56:34,980 --> 00:56:37,840
es igual a

832
00:56:37,840 --> 00:56:38,219
1

833
00:56:38,219 --> 00:56:41,900
y luego poner

834
00:56:41,900 --> 00:56:44,219
obj.describe

835
00:56:44,219 --> 00:56:47,920
estoy usando

836
00:56:47,920 --> 00:56:50,599
esto, como si fuera una clase

837
00:56:50,599 --> 00:56:52,059
normal, pero no está

838
00:56:52,059 --> 00:56:54,099
dentro de otro

839
00:56:54,099 --> 00:57:01,000
fichero va a estar dentro del mismo fichero. Si ahora lo lanzo, pues me hace lo que me dice.

840
00:57:01,000 --> 00:57:05,659
Al principio me ha escrito esto que es la descripción de otra clase.

841
00:57:09,500 --> 00:57:31,429
¿Dudas? Ahora, si yo esta clase aquí la hago privada, se enfadará. No sé por qué.

842
00:57:33,429 --> 00:57:41,820
Debería poder funcionar. Se enfadará aquí porque está intentando hacer un new otra clase,

843
00:57:41,820 --> 00:57:51,699
entonces me dice no lo puedes hacer así si yo intentara crear otra clase desde otro sitio

844
00:57:51,699 --> 00:57:58,420
importando ejemplo no me lo permitiría porque sólo se puede hacer desde dentro cuando se usan estas

845
00:57:58,420 --> 00:58:06,199
cosas se usan cuando yo tengo un sistema quiero hacer una clase esta clase es que se yo alumno

846
00:58:06,199 --> 00:58:13,019
vale y la clase alumno tiene dentro un array de materias y yo quiero esta materia es crearla aquí

847
00:58:13,019 --> 00:58:19,019
porque me sirven solo para para esta clase o sea la materia la uso solo en los alumnos entonces la

848
00:58:19,019 --> 00:58:24,400
clase me la creo el mismo fichero que van como más empaquetadas van juntos cuando me importa

849
00:58:24,400 --> 00:58:29,639
el fichero alumno me importa también esta clase materia que es la que me sirve para que el alumno

850
00:58:29,639 --> 00:58:42,730
funcione aún así nosotros principalmente usaremos public class y usaremos métodos públicos y privados

851
00:58:42,730 --> 00:58:51,710
¿Vale? Y el resto, lo tienen que saber que existe, pero lo usamos relativamente menos. ¿Vale? Y ya está.

852
00:58:55,760 --> 00:59:00,599
Perdona, Estefano, ¿las clases privadas entonces las llegaremos a usar en algún momento?

853
00:59:00,980 --> 00:59:01,519
No, no.