1
00:00:00,620 --> 00:00:09,759
Vale, vamos grabando, por lo tanto si habláis me estáis dando la autorización a que se os grabe, ¿vale?

2
00:00:09,800 --> 00:00:14,000
Entonces, la última vez estuvimos hablando un poco de herencia, ¿vale?

3
00:00:14,120 --> 00:00:24,480
La herencia es un mecanismo que es propio de la programación orientada a objetos, o sea que cuando hay programación orientada a objetos hay herencia.

4
00:00:24,480 --> 00:00:38,840
Todos los lenguajes que trabajan con esto pues incluyen la herencia, que sirve sustancialmente para organizar mejor el código y para reutilizar código en distintos proyectos o en el mismo proyecto, ¿vale?

5
00:00:39,579 --> 00:00:52,260
Sale de dos ideas que son la misma pero vistas desde dos perspectivas distintas, que son una es tengo una clase ya hecha y la quiero especializar,

6
00:00:52,260 --> 00:00:54,460
o sea quiero añadir algo más a esta cosa.

7
00:00:54,480 --> 00:01:03,720
Pero digamos que el esquema principal de esta clase me vale, que por lo tanto la quiero reutilizar, entonces estaremos en un nivel de espacialización.

8
00:01:04,060 --> 00:01:09,400
Tengo la clase vehículo, que me modeliza un cualquier vehículo y ahora necesito trabajar con coches.

9
00:01:09,840 --> 00:01:15,740
Entonces especializo la clase vehículo con algo más que solo los coches tienen.

10
00:01:16,140 --> 00:01:21,620
Todos los vehículos tendrán lo que está en vehículo, pero coche tiene algo más que tienen solo los coches.

11
00:01:21,620 --> 00:01:24,300
Y bicicleta otra cosa distinta de coche.

12
00:01:24,480 --> 00:01:31,260
Tiene solo la bicicleta y avión tiene algo, etcétera, etcétera, ¿sí?

13
00:01:31,620 --> 00:01:39,939
La otra opción es a nivel de generalización, o sea si tengo muchas clases en mi proyecto que veo que tienen una parte compartida,

14
00:01:40,079 --> 00:01:45,780
tienen métodos que son la misma implementación y que se repiten en varias clases, a un cierto momento puedo decir,

15
00:01:45,780 --> 00:01:53,859
oye mira, toda esta parte común la saco de las clases pequeñas y la pongo en una clase,

16
00:01:53,859 --> 00:01:54,100
la saco de las clases pequeñas y la pongo en una clase, la saco de las clases pequeñas y la pongo en una clase,

17
00:01:54,100 --> 00:01:54,860
la saco de las clases pequeñas y la pongo en una clase,

18
00:01:54,860 --> 00:02:00,100
que será una superclase, y esta superclase luego se heredará en todas las clases anteriores.

19
00:02:00,100 --> 00:02:08,900
De esta forma centralizo en una única clase todos estos métodos que antes, o variables que antes se repetían en muchos sitios.

20
00:02:08,900 --> 00:02:14,439
De esta forma si lo hago mañana, tengo que mejorarlo, tengo que cambiar, tengo que modificar, encuentro un error,

21
00:02:14,439 --> 00:02:21,240
pues tengo una sola clase que modificar y no copiar esta modifica en 37 clases distintas, ¿vale?

22
00:02:21,240 --> 00:02:24,040
Son muy parecidas las dos cosas.

23
00:02:24,099 --> 00:02:27,099
Pero vistas desde dos perspectivas distintas, ¿sí?

24
00:02:27,099 --> 00:02:36,900
Entonces este era un ejemplo en el que aquí había tres clases donde la parte en azul se repetía en las tres clases,

25
00:02:36,900 --> 00:02:43,599
pues entonces la idea es utilizar la clase recursos como superclase, heredarla en aula y ordenador,

26
00:02:43,599 --> 00:02:49,599
y aula y ordenador solo especifican lo que es propio de aula y de ordenador, ¿vale?

27
00:02:49,599 --> 00:02:52,599
Para hacer esto está la palabra extends, ¿vale?

28
00:02:52,599 --> 00:02:53,459
Una palabra reservada.

29
00:02:53,459 --> 00:02:54,099
Una palabra reservada.

30
00:02:54,099 --> 00:02:58,099
Que permite extender recurso con una nueva clase.

31
00:02:58,099 --> 00:03:04,099
Bla, bla, bla, modificadores, ¿vale?

32
00:03:04,099 --> 00:03:14,099
Entonces esto por ejemplo para declarar una estructura como esta, donde está persona, empleado, alumno y profesor,

33
00:03:14,099 --> 00:03:23,099
pues la clase persona es esta de aquí, no tiene nada, la clase alumno extende persona, la clase empleado extende persona,

34
00:03:24,099 --> 00:03:28,099
la clase profesor extende empleado, ¿vale?

35
00:03:28,099 --> 00:03:38,099
Entonces, acordaos que esta relación, esta relación de herencia es una relación de es, ¿vale?

36
00:03:38,099 --> 00:03:48,099
Es decir que un alumno es una persona, un profesor es un empleado, un empleado es una persona, un profesor es una persona.

37
00:03:48,099 --> 00:03:53,099
Es decir que donde yo necesite un objeto superclase,

38
00:03:54,099 --> 00:04:00,099
puedo poner un objeto subclase, ¿si?

39
00:04:00,099 --> 00:04:07,099
Si yo tengo un método que pilla un empleado, puedo utilizar un objeto empleado o puedo utilizar un objeto profesor,

40
00:04:07,099 --> 00:04:11,099
porque profesor es un empleado, tiene todo lo que necesita un empleado.

41
00:04:11,099 --> 00:04:18,100
Este método dentro utilizará variables y cosas propias de empleado, que seguramente profesor tiene,

42
00:04:18,100 --> 00:04:22,100
que muy probablemente profesor tiene, ¿si?

43
00:04:22,100 --> 00:04:23,100
¿Dudas?

44
00:04:24,100 --> 00:04:25,100
Sigo, ¿vale?

45
00:04:25,100 --> 00:04:34,100
Esta es un poquito la idea interna del, de la subclase donde está la parte que hereda y la parte nueva, ¿vale?

46
00:04:34,100 --> 00:04:38,100
Tened en cuenta que no son dos objetos, es siempre un solo objeto, ¿vale?

47
00:04:38,100 --> 00:04:44,100
Este objeto está con una parte anterior que representa prácticamente un objeto de tipo persona,

48
00:04:44,100 --> 00:04:49,100
exteso con la parte que es propia de alumno, ¿si?

49
00:04:49,100 --> 00:04:53,100
La idea es que si yo ahora uso un método que en vez de pedir un objeto alumno,

50
00:04:53,100 --> 00:05:00,100
pide un objeto persona, yo aquí de todas formas tengo toda la información de una persona,

51
00:05:00,100 --> 00:05:03,100
entonces lo puedo usar tranquilamente, no tengo problemas.

52
00:05:03,100 --> 00:05:07,100
Al revés, no, allá donde va una persona no puedo utilizar un alumno,

53
00:05:07,100 --> 00:05:12,100
porque un alumno, perdón, allá donde va un alumno no puedo utilizar una persona.

54
00:05:12,100 --> 00:05:18,100
Si yo tengo un método que quiere un alumno y que entonces puede utilizar estos parámetros aquí abajo,

55
00:05:18,100 --> 00:05:21,100
y tú me pasas una persona, o sea, solo esto,

56
00:05:21,100 --> 00:05:26,100
pues solo esto no tiene estos parámetros, entonces no se puede usar.

57
00:05:26,100 --> 00:05:28,100
Bla, bla, bla.

58
00:05:28,100 --> 00:05:32,100
Hemos visto el constructor super, ¿vale?

59
00:05:32,100 --> 00:05:35,100
Constructor super hace referencia al constructor de la superclase,

60
00:05:35,100 --> 00:05:39,100
y es que cuando, ahora, hoy lo veremos con más detalle,

61
00:05:39,100 --> 00:05:42,100
pero cuando yo creo un objeto de una subclase,

62
00:05:42,100 --> 00:05:46,100
la primera línea del constructor de la subclase tiene que ser una llamada super.

63
00:05:46,100 --> 00:05:50,100
O sea, construye un objeto de la clase super,

64
00:05:50,100 --> 00:05:55,100
y a partir de allí lo extendes con las cosas nuevas.

65
00:05:55,100 --> 00:05:59,100
Si no lo pongo, si no pongo ninguna llamada super,

66
00:05:59,100 --> 00:06:03,100
se asume que por defecto se llame un super así, sin parámetros.

67
00:06:03,100 --> 00:06:10,100
Y eso implica que si el padre, si la superclase no tiene el constructor sin parámetros,

68
00:06:10,100 --> 00:06:13,100
esto me dará error.

69
00:06:13,100 --> 00:06:17,100
Entonces el super es el paso para que entiende el ordenador de coger,

70
00:06:17,100 --> 00:06:19,100
si tengo una superclase y una subclase,

71
00:06:19,100 --> 00:06:24,100
cuando yo ponga el super, le estoy dando a entender al ordenador

72
00:06:24,100 --> 00:06:28,100
que coja lo de la superclase y lo ponga en la subclase.

73
00:06:28,100 --> 00:06:31,100
Eso se lo estás diciendo aquí.

74
00:06:31,100 --> 00:06:36,100
O sea, la relación entre alumno y persona se lo estás diciendo

75
00:06:36,100 --> 00:06:39,100
cuando dices que alumno extende persona, ¿vale?

76
00:06:39,100 --> 00:06:44,100
El super es la llamada al constructor de arriba.

77
00:06:44,100 --> 00:06:48,100
Si tú tienes alumno y persona, para crear un alumno,

78
00:06:48,100 --> 00:06:51,100
tendrás antes que crear una persona.

79
00:06:51,100 --> 00:06:54,100
Y sobre esta persona extender, ¿vale?

80
00:06:54,100 --> 00:06:57,100
Esta llamada a decir, oye, mira, antes de crear un alumno,

81
00:06:57,100 --> 00:06:59,100
crea una persona, es este super.

82
00:06:59,100 --> 00:07:01,100
¿Sí?

83
00:07:01,100 --> 00:07:03,100
Entonces, tú puedes no usarlo.

84
00:07:03,100 --> 00:07:08,100
Yo puedo quitar todos los constructores aquí

85
00:07:08,100 --> 00:07:10,100
y se me quedaría solo el constructor por defecto.

86
00:07:10,100 --> 00:07:12,100
No he usado super por ningún lado.

87
00:07:12,100 --> 00:07:16,100
Por defecto él sabe que como esto extende persona,

88
00:07:16,100 --> 00:07:19,100
cuando tú me crearás un alumno sin parámetros,

89
00:07:19,100 --> 00:07:23,100
voy a llamar super sin parámetros, crearé una persona sin parámetros

90
00:07:23,100 --> 00:07:27,100
y una vez que tengo esta persona, pues la extenderé con alumno.

91
00:07:27,100 --> 00:07:28,100
¿Sí?

92
00:07:28,100 --> 00:07:30,100
Si en vez lo quieres usar explícitamente,

93
00:07:30,100 --> 00:07:34,100
tiene que ser la primera línea de un constructor

94
00:07:34,100 --> 00:07:38,100
y puedes llamar super sin parámetros o super con parámetros.

95
00:07:38,100 --> 00:07:43,100
Esto llamará el constructor de la superclase que corresponde a esos parámetros.

96
00:07:43,100 --> 00:07:44,100
¿Sí?

97
00:07:44,100 --> 00:07:45,100
Vale.

98
00:07:45,100 --> 00:07:47,100
Vale.

99
00:07:47,100 --> 00:07:49,100
Esto es todo el repaso, ¿eh?

100
00:07:49,100 --> 00:07:56,100
Prueba, vimos esta cosa aquí que es reciente interesante

101
00:07:56,100 --> 00:08:02,100
sobre los conceptos de los modificadores.

102
00:08:02,100 --> 00:08:03,100
¿Vale?

103
00:08:03,100 --> 00:08:07,100
Si no, nosotros antes persona era protete, protete, protete,

104
00:08:07,100 --> 00:08:09,100
o public, me da igual.

105
00:08:09,100 --> 00:08:13,100
En el momento en que pongo privado nombre, ¿vale?

106
00:08:13,100 --> 00:08:17,100
Este nombre solo es accesible desde dentro persona.

107
00:08:17,100 --> 00:08:23,100
Tampoco, hasta si al alumno extende persona,

108
00:08:23,100 --> 00:08:26,100
alumno no puede acceder a esta variable.

109
00:08:26,100 --> 00:08:28,100
¿Sí?

110
00:08:28,100 --> 00:08:32,100
Porque cuando es privado es solo de la clase,

111
00:08:32,100 --> 00:08:34,100
solo interna esta clase.

112
00:08:34,100 --> 00:08:36,100
Para poderlo acceder desde una clase que hereda,

113
00:08:36,100 --> 00:08:38,100
lo debería poner protete.

114
00:08:38,100 --> 00:08:39,100
¿Vale?

115
00:08:39,100 --> 00:08:41,100
Os recuerdo que hay cuatro niveles de visibilidad,

116
00:08:41,100 --> 00:08:44,100
de accesibilidad, que son public,

117
00:08:44,100 --> 00:08:47,100
que pueden acceder quien quiera.

118
00:08:47,100 --> 00:08:52,100
Package, que pueden acceder todas las clases

119
00:08:52,100 --> 00:08:55,100
que pertenecen al mismo package, al mismo paquete.

120
00:08:55,100 --> 00:09:01,100
Protected, que pueden acceder todas las del mismo paquete

121
00:09:01,100 --> 00:09:05,100
y todas las clases que hereden de esta clase,

122
00:09:05,100 --> 00:09:08,100
aún si no están en el paquete.

123
00:09:08,100 --> 00:09:09,100
¿Vale?

124
00:09:09,100 --> 00:09:10,100
Y finalmente private.

125
00:09:10,100 --> 00:09:13,100
Que es solo esta clase puede hacer.

126
00:09:13,100 --> 00:09:15,100
Entonces, si pongo private aquí,

127
00:09:15,100 --> 00:09:18,100
no puedo hacer una cosa así.

128
00:09:18,100 --> 00:09:22,100
Esto no funcionaría.

129
00:09:22,100 --> 00:09:24,100
Este es un constructor de alumno,

130
00:09:24,100 --> 00:09:27,100
que pilla nombre, apellido, nacimiento.

131
00:09:27,100 --> 00:09:31,100
Apellido y nacimiento que no están declarados en alumno,

132
00:09:31,100 --> 00:09:33,100
están declarados en persona.

133
00:09:33,100 --> 00:09:35,100
Pero son accesibles sin problemas.

134
00:09:35,100 --> 00:09:38,100
Pero esto dis.nombre no podría hacerlo.

135
00:09:38,100 --> 00:09:39,100
Porque dis.nombre no es accesible.

136
00:09:39,100 --> 00:09:44,100
Porque dis.nombre es accesible solo desde dentro de persona.

137
00:09:44,100 --> 00:09:47,100
Y aquí no estoy en persona, estoy en alumno.

138
00:09:47,100 --> 00:09:49,100
¿Sí?

139
00:09:49,100 --> 00:09:54,100
Esto no quita que pueda hacer esta cosa de aquí.

140
00:09:56,100 --> 00:10:02,100
Llamar el constructor de persona que yo extendo

141
00:10:02,100 --> 00:10:05,100
con nombre, apellido y nacimiento funcionaría

142
00:10:05,100 --> 00:10:08,100
porque en este caso no soy yo que modifico el dis.nombre.

143
00:10:09,100 --> 00:10:13,100
Es un método que pertenece a persona.

144
00:10:13,100 --> 00:10:17,100
El que está tocando, está cambiando el nombre.

145
00:10:17,100 --> 00:10:24,100
Entonces esto funcionaría.

146
00:10:24,100 --> 00:10:26,100
Esto se entiende porque no funciona.

147
00:10:26,100 --> 00:10:28,100
No puedo acceder al nombre.

148
00:10:28,100 --> 00:10:30,100
Dis.nombre es privado.

149
00:10:30,100 --> 00:10:32,100
Es propio de persona.

150
00:10:32,100 --> 00:10:34,100
Si persona puede hacer lo que le da la gana,

151
00:10:34,100 --> 00:10:37,100
todos los métodos de persona pueden toquetear esto,

152
00:10:37,100 --> 00:10:38,100
fuera de la clase persona,

153
00:10:38,100 --> 00:10:40,100
como estoy aquí porque estoy en la clase alumno,

154
00:10:40,100 --> 00:10:42,100
pues no puedo tocar esto.

155
00:10:42,100 --> 00:10:45,100
Por lo tanto esto, al haber puesto nombre privado,

156
00:10:45,100 --> 00:10:46,100
se me bloquea.

157
00:10:46,100 --> 00:10:49,100
O cuidado que si pongo nombre protected ya lo puedo hacer.

158
00:10:49,100 --> 00:10:50,100
Sin ningún problema.

159
00:10:50,100 --> 00:10:51,100
Pero ahora es privado.

160
00:10:51,100 --> 00:10:52,100
No puedo.

161
00:10:52,100 --> 00:10:56,100
Entonces, ¿cómo podría crear un objeto persona entre comillas

162
00:10:56,100 --> 00:10:58,100
para luego crear el objeto alumno?

163
00:10:58,100 --> 00:11:00,100
O una cosa de ese estilo.

164
00:11:00,100 --> 00:11:03,100
Creo un alumno que tiene nombre, apellido y nacimiento.

165
00:11:03,100 --> 00:11:06,100
¿Cómo sé que mi nombre es ese de allí?

166
00:11:06,100 --> 00:11:09,100
Desde alumno no lo puedo modificar.

167
00:11:09,100 --> 00:11:13,100
Pues entonces, llamo el constructor de la superclase.

168
00:11:13,100 --> 00:11:16,100
Llamar al constructor de la superclase está diciendo

169
00:11:16,100 --> 00:11:19,100
que voy a utilizar para modificar este nombre,

170
00:11:19,100 --> 00:11:24,100
no la clase alumno, sino algo propio de la clase persona.

171
00:11:24,100 --> 00:11:29,100
Yo entro en la clase persona, en el constructor de la clase persona,

172
00:11:29,100 --> 00:11:31,100
y le paso estos tres parámetros,

173
00:11:31,100 --> 00:11:33,100
y será el constructor de la clase persona,

174
00:11:33,100 --> 00:11:35,100
si os acordáis que era así.

175
00:11:36,100 --> 00:11:43,100
Este constructor de aquí,

176
00:11:43,100 --> 00:11:47,100
aquí dentro yo estoy usando este constructor pasándole nombre,

177
00:11:47,100 --> 00:11:50,100
y él hace dis.nombres igual a nombre.

178
00:11:50,100 --> 00:11:52,100
Está haciendo lo mismo que hemos visto al otro lado,

179
00:11:52,100 --> 00:11:55,100
pero al otro lado lo estaba haciendo desde alumno.

180
00:11:55,100 --> 00:11:57,100
Y aquí lo estoy haciendo desde dentro persona.

181
00:11:57,100 --> 00:12:01,100
Y por lo tanto sí tiene acceso a este de aquí,

182
00:12:01,100 --> 00:12:03,100
hasta si esto fuera privado.

183
00:12:03,100 --> 00:12:05,100
¿Sí?

184
00:12:06,100 --> 00:12:08,100
Vale.

185
00:12:08,100 --> 00:12:11,100
Este es el ejercicio que hicimos la última vez.

186
00:12:11,100 --> 00:12:12,100
¿Vale?

187
00:12:12,100 --> 00:12:14,100
Te creamos un dispositivo, luego un móvil, un ordenador,

188
00:12:14,100 --> 00:12:18,100
y lo extendimos y hicimos alguna prueba con ellas.

189
00:12:18,100 --> 00:12:19,100
¿Vale?

190
00:12:19,100 --> 00:12:21,100
Y desde aquí es cosa nueva.

191
00:12:24,100 --> 00:12:28,100
Entonces, la idea de la herencia,

192
00:12:28,100 --> 00:12:31,100
este mecanismo que estamos viendo ahora,

193
00:12:31,100 --> 00:12:34,100
crea una jerarquía.

194
00:12:34,100 --> 00:12:35,100
¿Vale?

195
00:12:35,100 --> 00:12:38,100
Es decir, que persona,

196
00:12:38,100 --> 00:12:41,100
o persona tiene dentro empleado alumno,

197
00:12:41,100 --> 00:12:43,100
empleado tiene dentro profesor,

198
00:12:43,100 --> 00:12:46,100
alumno tiene dentro qué sé yo, otra cosa,

199
00:12:46,100 --> 00:12:49,100
pues se va creando una jerarquía

200
00:12:49,100 --> 00:12:53,100
en el que como nodo principal, como nodo inicial,

201
00:12:53,100 --> 00:12:55,100
está el que está más arriba,

202
00:12:55,100 --> 00:12:59,100
y desde allí cuelgan los hijos creando un árbol.

203
00:12:59,100 --> 00:13:00,100
¿Vale?

204
00:13:00,100 --> 00:13:03,100
Y una jerarquía que va especificando cuanto más abajo,

205
00:13:03,100 --> 00:13:05,100
más eso hay específico,

206
00:13:05,100 --> 00:13:08,100
más estoy extendiendo lo que está arriba.

207
00:13:08,100 --> 00:13:10,100
Antes tengo un concepto más general,

208
00:13:10,100 --> 00:13:12,100
lo extiendo con cosas más particulares,

209
00:13:12,100 --> 00:13:14,100
lo extiendo con cosas más particulares, etc.

210
00:13:14,100 --> 00:13:16,100
¿Vale?

211
00:13:18,100 --> 00:13:21,100
Teniendo en cuenta que una clase en Java puede

212
00:13:21,100 --> 00:13:23,100
o heredar específicamente de otra clase,

213
00:13:23,100 --> 00:13:25,100
que es lo que estamos viendo ahora,

214
00:13:25,100 --> 00:13:27,100
extends persona, ¿vale?

215
00:13:27,100 --> 00:13:29,100
Si no le digo nada,

216
00:13:29,100 --> 00:13:32,100
todas las clases que habéis hecho vosotros desde el día uno,

217
00:13:32,100 --> 00:13:33,100
¿vale?

218
00:13:33,100 --> 00:13:35,100
Esto es un public class algo,

219
00:13:35,100 --> 00:13:37,100
en automático, por defecto,

220
00:13:37,100 --> 00:13:41,100
hereda desde la clase object.

221
00:13:41,100 --> 00:13:42,100
¿Vale?

222
00:13:42,100 --> 00:13:46,100
Existe una clase especial object,

223
00:13:46,100 --> 00:13:48,100
definida en el núcleo de Java,

224
00:13:48,100 --> 00:13:51,100
o sea que existe allí y que define un objeto en general,

225
00:13:51,100 --> 00:13:54,100
y todas las clases que vosotros creáis,

226
00:13:54,100 --> 00:13:56,100
por defecto, heredan de object.

227
00:13:56,100 --> 00:14:01,100
O sea que object es la raíz de este árbol de herencia.

228
00:14:01,100 --> 00:14:02,100
Siempre.

229
00:14:02,100 --> 00:14:05,100
Todos los objetos, todas las clases que haréis en Java.

230
00:14:05,100 --> 00:14:08,100
Lo que puedo hacer es que yo puedo crear,

231
00:14:08,100 --> 00:14:10,100
qué sé yo, alumno, ¿vale?

232
00:14:10,100 --> 00:14:12,100
Y alumno hereda de persona,

233
00:14:12,100 --> 00:14:14,100
pero persona, como no le he dicho que extiende nada,

234
00:14:14,100 --> 00:14:16,100
por defecto extiende object.

235
00:14:18,100 --> 00:14:20,100
¿Habéis usado alguna vez

236
00:14:20,100 --> 00:14:23,100
system.out.println

237
00:14:23,100 --> 00:14:26,100
y habéis puesto un objeto allí?

238
00:14:26,100 --> 00:14:28,100
¿Qué os sale?

239
00:14:30,100 --> 00:14:32,100
Os sale el tipo,

240
00:14:32,100 --> 00:14:34,100
arroba, dirección de memoria.

241
00:14:34,100 --> 00:14:36,100
¿Y por qué?

242
00:14:39,100 --> 00:14:43,100
System.out.println que pilla como parámetro.

243
00:14:46,100 --> 00:14:49,100
¿Qué es system.out?

244
00:14:51,100 --> 00:14:54,100
Es un print stream.

245
00:14:54,100 --> 00:14:57,100
Vamos a ver en la API

246
00:14:57,100 --> 00:15:00,100
qué es un print stream.

247
00:15:00,100 --> 00:15:06,100
Print stream, bla bla bla, cosas guay, tiene un metodito.

248
00:15:06,100 --> 00:15:09,100
Que es println.

249
00:15:09,100 --> 00:15:10,100
¿Sí?

250
00:15:10,100 --> 00:15:12,100
Es el que usáis vosotros.

251
00:15:12,100 --> 00:15:14,100
¿Sí?

252
00:15:14,100 --> 00:15:18,100
¿Qué pilla como parámetro el println?

253
00:15:18,100 --> 00:15:23,100
Puede pillar nada, un booleano, un char, un array de char,

254
00:15:23,100 --> 00:15:26,100
puede pillar un float, puede pillar un int, puede pillar un long,

255
00:15:26,100 --> 00:15:28,100
puede pillar un object.

256
00:15:28,100 --> 00:15:31,100
Puede pillar un string.

257
00:15:31,100 --> 00:15:34,100
Vosotros normalmente usáis esto.

258
00:15:34,100 --> 00:15:37,100
Ahora, ¿cuándo se pilla un object?

259
00:15:37,100 --> 00:15:40,100
¿Vosotros habéis pasado nunca un object?

260
00:15:40,100 --> 00:15:42,100
No.

261
00:15:42,100 --> 00:15:44,100
¿Vosotros habéis pasado lo que vosotros habéis creado?

262
00:15:44,100 --> 00:15:46,100
¿Habéis creado coche?

263
00:15:46,100 --> 00:15:48,100
¿Habéis pasado coche?

264
00:15:48,100 --> 00:15:50,100
¿Cómo se me explica?

265
00:15:50,100 --> 00:15:52,100
Nunca habéis hecho vosotros un cast explicit object.

266
00:15:52,100 --> 00:15:55,100
Hasta hoy vosotros ni siquiera sabíais que existía un object.

267
00:15:55,100 --> 00:15:57,100
¿Y por qué entonces esto funciona?

268
00:15:57,100 --> 00:15:59,100
Porque hereda.

269
00:15:59,100 --> 00:16:00,100
Porque hereda.

270
00:16:00,100 --> 00:16:03,100
Y cualquier cosa que hayáis creado vosotros,

271
00:16:03,100 --> 00:16:07,100
vuestra clase, vuestro coche, vuestro animal,

272
00:16:07,100 --> 00:16:09,100
heredaba de object.

273
00:16:09,100 --> 00:16:11,100
Es un object.

274
00:16:11,100 --> 00:16:12,100
¿Sí?

275
00:16:12,100 --> 00:16:14,100
Y por lo tanto se puede poner aquí.

276
00:16:14,100 --> 00:16:16,100
¿Y qué hará este señor de aquí?

277
00:16:16,100 --> 00:16:20,100
Pues este señor de aquí transforma,

278
00:16:20,100 --> 00:16:25,100
como lo que quiere hacer es imprimir en pantalla algo textual,

279
00:16:25,100 --> 00:16:26,100
y tú me estás dando un objeto.

280
00:16:26,100 --> 00:16:28,100
Un objeto no se puede imprimir,

281
00:16:28,100 --> 00:16:30,100
porque un objeto es una serie de unos y ceros.

282
00:16:30,100 --> 00:16:33,100
Pues en la clase object,

283
00:16:33,100 --> 00:16:35,100
está un señor,

284
00:16:35,100 --> 00:16:37,100
que es...

285
00:16:37,100 --> 00:16:39,100
¿Dónde está?

286
00:16:39,100 --> 00:16:41,100
El toString.

287
00:16:41,100 --> 00:16:43,100
Este metodito de aquí,

288
00:16:43,100 --> 00:16:47,100
lo que hace es traducir el objeto

289
00:16:47,100 --> 00:16:52,100
en una representación string del objeto mismo.

290
00:16:52,100 --> 00:16:54,100
¿Vale?

291
00:16:54,100 --> 00:16:57,100
El defecto es mi tipo arroba la posición de memoria,

292
00:16:57,100 --> 00:16:58,100
más o menos no es la posición de memoria,

293
00:16:58,100 --> 00:17:00,100
pero algo parecido.

294
00:17:00,100 --> 00:17:01,100
¿Sí?

295
00:17:01,100 --> 00:17:02,100
Lo que quiero decir con esto,

296
00:17:02,100 --> 00:17:07,099
es que si vosotros no implementáis nada,

297
00:17:07,099 --> 00:17:10,099
y creáis la clase gato,

298
00:17:10,099 --> 00:17:13,099
la clase gato hereda de object,

299
00:17:13,099 --> 00:17:17,099
y entonces importa este método de aquí.

300
00:17:17,099 --> 00:17:19,099
Tiene este método de aquí.

301
00:17:19,099 --> 00:17:21,099
Y cuando vosotros hacéis .

302
00:17:21,099 --> 00:17:23,099
System.out.println,

303
00:17:23,099 --> 00:17:25,099
de un objeto de tipo gato,

304
00:17:25,099 --> 00:17:27,099
como el objeto de tipo gato,

305
00:17:27,099 --> 00:17:29,099
no tiene un toString propio,

306
00:17:29,099 --> 00:17:32,099
sino usa el toString de object,

307
00:17:32,099 --> 00:17:36,099
o sale gato arroba numerito.

308
00:17:36,099 --> 00:17:38,099
¿Se entiende?

309
00:17:38,099 --> 00:17:40,099
Ahora, ¿qué pasa cuando yo,

310
00:17:40,099 --> 00:17:42,099
dentro de gato,

311
00:17:42,099 --> 00:17:44,099
sobreescribo este método?

312
00:17:44,099 --> 00:17:48,099
Y me creo un toString dentro de la clase gato.

313
00:17:48,099 --> 00:17:52,099
Que cuando uso el .println,

314
00:17:52,099 --> 00:17:55,099
el me va a intentar usar esto,

315
00:17:55,099 --> 00:17:58,099
pero se da cuenta que mi objeto

316
00:17:58,099 --> 00:18:00,099
es un objecto y tiene esto.

317
00:18:00,099 --> 00:18:03,099
Pero más específicamente es un gato,

318
00:18:03,099 --> 00:18:05,099
y tiene el toString de gato.

319
00:18:05,099 --> 00:18:09,099
Entonces me usa el toString más específico.

320
00:18:09,099 --> 00:18:12,099
Y entonces me sale lo que yo le he dicho.

321
00:18:12,099 --> 00:18:14,099
Esta cosa de aquí,

322
00:18:14,099 --> 00:18:16,099
la veremos más adelante.

323
00:18:16,099 --> 00:18:18,099
¿Por qué está funcionando así?

324
00:18:18,099 --> 00:18:20,099
Pero es como funciona ya.

325
00:18:20,099 --> 00:18:22,099
Esto ya lo hemos experimentado.

326
00:18:22,100 --> 00:18:24,100
No sabemos por qué,

327
00:18:24,100 --> 00:18:26,100
todavía no lo sabemos,

328
00:18:26,100 --> 00:18:29,100
pero lo podemos medianamente intuir.

329
00:18:29,100 --> 00:18:32,100
Pero todo esto está basado en la herencia,

330
00:18:32,100 --> 00:18:35,100
en la sobreescriptura de métodos.

331
00:18:35,100 --> 00:18:38,100
Cuidado que no es la sobrecarga de métodos,

332
00:18:38,100 --> 00:18:42,100
es sobreescriptura, que ahora lo veremos.

333
00:18:42,100 --> 00:18:45,100
Fijaos también que object por sí mismo

334
00:18:45,100 --> 00:18:50,100
tiene varios métodos.

335
00:18:50,100 --> 00:18:52,100
Estos métodos,

336
00:18:52,100 --> 00:18:53,100
por ejemplo,

337
00:18:53,100 --> 00:18:54,100
white,

338
00:18:54,100 --> 00:18:55,100
notify all,

339
00:18:55,100 --> 00:18:56,100
etcétera,

340
00:18:56,100 --> 00:18:57,100
etcétera,

341
00:18:57,100 --> 00:19:00,100
los veréis en segundo o en tercero

342
00:19:00,100 --> 00:19:02,100
en DAM,

343
00:19:02,100 --> 00:19:11,100
en programación de procesos y servicios.

344
00:19:11,100 --> 00:19:13,100
Pues allí se ve que son estas cosas.

345
00:19:13,100 --> 00:19:15,100
En segundo de DAO no lo sé,

346
00:19:15,100 --> 00:19:17,100
si por algún lado veis algo de este tipo.

347
00:19:17,100 --> 00:19:19,100
Y otras cosillas,

348
00:19:19,100 --> 00:19:20,100
pues las veremos.

349
00:19:20,100 --> 00:19:21,100
Equals,

350
00:19:21,100 --> 00:19:23,100
igual se os suena de algo.

351
00:19:23,100 --> 00:19:26,100
Fijaos que está definido a nivel de objeto,

352
00:19:26,100 --> 00:19:28,100
de object.

353
00:19:28,100 --> 00:19:30,100
Luego cada objeto pues sobreescribirá esto,

354
00:19:30,100 --> 00:19:31,100
lo haremos,

355
00:19:31,100 --> 00:19:33,100
antes o después.

356
00:19:33,100 --> 00:19:35,100
Vale,

357
00:19:35,100 --> 00:19:37,100
entonces sigo.

358
00:19:37,100 --> 00:19:39,100
Entonces,

359
00:19:39,100 --> 00:19:41,100
aquí tenemos esta herencia.

360
00:19:41,100 --> 00:19:43,100
Acordaos que cualquier objeto que vosotros creáis,

361
00:19:43,100 --> 00:19:45,100
pues tiene los métodos de object,

362
00:19:45,100 --> 00:19:48,100
más todos los que están en su cadena,

363
00:19:48,100 --> 00:19:49,100
digamos,

364
00:19:49,100 --> 00:19:51,100
de las clases superiores.

365
00:19:51,100 --> 00:19:53,100
El alumno tiene todo lo que está en alumno,

366
00:19:53,100 --> 00:19:54,100
todo lo que está en persona,

367
00:19:54,100 --> 00:19:56,100
y todo lo que está en object.

368
00:19:56,100 --> 00:19:58,100
¿Sí?

369
00:19:58,100 --> 00:20:00,100
Venga.

370
00:20:00,100 --> 00:20:01,100
Constructores y herencias,

371
00:20:01,100 --> 00:20:03,100
más o menos de esto hemos hablado.

372
00:20:03,100 --> 00:20:05,100
Cuando creo un objeto,

373
00:20:05,100 --> 00:20:08,100
primero se crea la parte base,

374
00:20:08,100 --> 00:20:10,100
y luego se crea la parte derivada.

375
00:20:10,100 --> 00:20:12,100
Es el discurso de cuando creo un alumno,

376
00:20:12,100 --> 00:20:15,100
antes creo una persona,

377
00:20:15,100 --> 00:20:18,100
y luego después creo la extensión de esta persona,

378
00:20:18,100 --> 00:20:20,100
que es el alumno.

379
00:20:20,100 --> 00:20:23,100
¿Correcto?

380
00:20:23,100 --> 00:20:33,100
¿Hago algo más antes?

381
00:20:33,100 --> 00:20:34,100
En realidad,

382
00:20:34,100 --> 00:20:36,100
primero creo un objeto,

383
00:20:36,100 --> 00:20:39,100
luego lo extendo con las cosas de persona,

384
00:20:39,100 --> 00:20:42,100
y luego lo extendo con las cosas de alumno.

385
00:20:42,100 --> 00:20:44,100
Por el mismo principio.

386
00:20:44,100 --> 00:20:45,100
¿Vale?

387
00:20:45,100 --> 00:20:47,100
Como persona hereda de objeto,

388
00:20:47,100 --> 00:20:49,100
lo que estoy creando al fin y al cabo

389
00:20:49,100 --> 00:20:50,100
como primera parte,

390
00:20:50,100 --> 00:20:51,100
como parte base,

391
00:20:51,100 --> 00:20:53,100
es el objeto-object.

392
00:20:53,100 --> 00:20:57,100
A él le añado lo que es persona,

393
00:20:57,100 --> 00:20:59,100
con sus métodos, sus atributos, etc.

394
00:20:59,100 --> 00:21:02,100
Y a eso le añado lo que es el alumno.

395
00:21:02,100 --> 00:21:04,100
Y al final creo un objeto solo,

396
00:21:04,100 --> 00:21:06,100
es como si fueran tres partes.

397
00:21:06,100 --> 00:21:08,100
Cuidado que el objeto es único,

398
00:21:08,100 --> 00:21:09,100
no he creado tres objetos.

399
00:21:09,100 --> 00:21:11,100
He creado un objeto,

400
00:21:11,100 --> 00:21:13,100
y luego lo he extendido

401
00:21:13,100 --> 00:21:15,100
con las características de los otros objetos.

402
00:21:15,100 --> 00:21:16,100
¿Sí?

403
00:21:16,100 --> 00:21:18,100
Entonces,

404
00:21:18,100 --> 00:21:21,100
si la clase base de objeto hereda a su vez,

405
00:21:21,100 --> 00:21:24,100
pues en el paso uno se aplica la misma cosa,

406
00:21:24,100 --> 00:21:26,100
pero hasta llegar a object.

407
00:21:26,100 --> 00:21:27,100
¿Vale?

408
00:21:27,100 --> 00:21:28,100
En el sentido de,

409
00:21:28,100 --> 00:21:30,100
pillamos alumno que hereda a la persona.

410
00:21:30,100 --> 00:21:31,100
¿Cómo se crea esto?

411
00:21:31,100 --> 00:21:32,100
Pues el paso uno sería

412
00:21:32,100 --> 00:21:35,100
que se crea la parte correspondiente a persona.

413
00:21:35,100 --> 00:21:37,100
Porque alumno hereda de persona.

414
00:21:37,100 --> 00:21:39,100
Pero, ¿y cómo se crea esto?

415
00:21:39,100 --> 00:21:40,100
Pues esto se crea

416
00:21:40,100 --> 00:21:43,100
reaplicando estos dos pasos a persona.

417
00:21:43,100 --> 00:21:44,100
O sea,

418
00:21:44,100 --> 00:21:46,100
que se crea la parte correspondiente a persona,

419
00:21:46,100 --> 00:21:47,100
correspondiente a object,

420
00:21:47,100 --> 00:21:49,100
porque persona hereda de object.

421
00:21:49,100 --> 00:21:51,100
Entonces aquí he creado object.

422
00:21:51,100 --> 00:21:52,100
Luego,

423
00:21:52,100 --> 00:21:55,100
se añaden los elementos de personas,

424
00:21:55,100 --> 00:21:58,100
y después he acabado el punto uno de alumno,

425
00:21:58,100 --> 00:22:01,100
y entonces paso al punto dos de alumno,

426
00:22:01,100 --> 00:22:02,100
que es,

427
00:22:02,100 --> 00:22:04,100
añado la parte específica de alumno.

428
00:22:06,100 --> 00:22:07,100
¿Se entiende?

429
00:22:07,100 --> 00:22:09,100
Esta cosa de aquí,

430
00:22:09,100 --> 00:22:11,100
es el super,

431
00:22:11,100 --> 00:22:13,100
en un cierto sentido.

432
00:22:13,100 --> 00:22:15,100
¿No puede ser que la publica alumnos

433
00:22:15,100 --> 00:22:18,100
estén obviosos directamente?

434
00:22:18,100 --> 00:22:20,100
Sí, pero no te sirve de nada.

435
00:22:20,100 --> 00:22:22,100
Porque si no lo pones en automático,

436
00:22:22,100 --> 00:22:25,100
estén desobviosos.

437
00:22:25,100 --> 00:22:27,100
Si tú pones public class alumno,

438
00:22:27,100 --> 00:22:29,100
estás haciendo public class alumno,

439
00:22:29,100 --> 00:22:31,100
estén desobviosos.

440
00:22:31,100 --> 00:22:33,100
Pero luego no es una persona.

441
00:22:33,100 --> 00:22:35,100
Te ha saltado persona.

442
00:22:35,100 --> 00:22:37,100
No tiene nombre ese alumno.

443
00:22:37,100 --> 00:22:39,100
Pero si es que,

444
00:22:39,100 --> 00:22:42,100
directamente hereda de objeto,

445
00:22:42,100 --> 00:22:44,100
ya lo tengo declarado.

446
00:22:44,100 --> 00:22:47,100
Pero objeto no tiene nombre.

447
00:22:47,100 --> 00:22:50,100
Y tampoco alumno tiene nombre.

448
00:22:50,100 --> 00:22:52,100
Claro, pero por ejemplo,

449
00:22:52,100 --> 00:22:54,100
el profesor,

450
00:22:54,100 --> 00:22:56,100
puedo poner public class profesor,

451
00:22:56,100 --> 00:22:58,100
que estén personas directamente.

452
00:22:58,100 --> 00:22:59,100
Claro.

453
00:22:59,100 --> 00:23:00,100
Por ejemplo, empleado.

454
00:23:00,100 --> 00:23:01,100
¿Por qué no?

455
00:23:01,100 --> 00:23:03,100
Sí, pero probablemente empleado

456
00:23:03,100 --> 00:23:05,100
tendrá algo más que no tiene persona.

457
00:23:05,100 --> 00:23:07,100
Ahora, si te fijas en el escritorio

458
00:23:07,100 --> 00:23:09,100
que te hicimos nosotros,

459
00:23:09,100 --> 00:23:14,100
era aquí, ¿dónde está?

460
00:23:14,100 --> 00:23:15,100
Esto.

461
00:23:15,100 --> 00:23:17,100
Tú puedes decir que personas

462
00:23:17,100 --> 00:23:19,100
prende directamente persona,

463
00:23:19,100 --> 00:23:21,100
pero no tiene sueldo luego.

464
00:23:21,100 --> 00:23:23,100
El profesor luego no tiene sueldo.

465
00:23:23,100 --> 00:23:25,100
Porque el sueldo está en empleado.

466
00:23:27,100 --> 00:23:29,100
Tú puedes hacer lo que quieras,

467
00:23:29,100 --> 00:23:31,100
depende de cómo lo modelizas.

468
00:23:31,100 --> 00:23:33,100
Si tú no te interesa esta cosa aquí,

469
00:23:33,100 --> 00:23:35,100
puedes hacer que el profesor sea directamente una persona.

470
00:23:35,100 --> 00:23:37,100
Aquí, pero la idea es de estructurar

471
00:23:37,100 --> 00:23:39,100
de tal forma que todas las personas

472
00:23:39,100 --> 00:23:41,100
tengan un nombre.

473
00:23:41,100 --> 00:23:43,100
Entonces, tanto alumno como empleado

474
00:23:43,100 --> 00:23:45,100
como profesor tendrán un nombre.

475
00:23:45,100 --> 00:23:47,100
Pero alumno luego tiene las notas,

476
00:23:47,100 --> 00:23:49,100
pero no tiene ni materias que imparte

477
00:23:49,100 --> 00:23:51,100
ni un sueldo.

478
00:23:51,100 --> 00:23:53,100
Sin embargo, todos los empleados sí tienen un sueldo.

479
00:23:53,100 --> 00:23:55,100
Y esto incluirá, además de los profesores,

480
00:23:55,100 --> 00:23:57,100
los conserjes, los profesionales

481
00:23:57,100 --> 00:23:59,100
de la limpieza, qué sé yo.

482
00:23:59,100 --> 00:24:01,100
Y en particular está el profesor.

483
00:24:01,100 --> 00:24:03,100
El profesor que tendrá

484
00:24:03,100 --> 00:24:05,100
una lista

485
00:24:05,100 --> 00:24:07,100
de materias que imparte,

486
00:24:07,100 --> 00:24:09,100
tendrá un sueldo porque le viene

487
00:24:09,100 --> 00:24:11,100
de empleado y tendrá un nombre

488
00:24:11,100 --> 00:24:13,100
porque le viene de persona.

489
00:24:13,100 --> 00:24:15,100
Pero no tendrá una lista de notas.

490
00:24:15,100 --> 00:24:17,100
¿Entiendes?

491
00:24:19,100 --> 00:24:21,100
Vale.

492
00:24:21,100 --> 00:24:23,100
Entonces, este es el procedimiento.

493
00:24:23,100 --> 00:24:25,100
Esta primera parte, la 1,

494
00:24:25,100 --> 00:24:27,100
sería, sustancialmente, el hacer un

495
00:24:27,100 --> 00:24:29,100
súper, que se hace siempre.

496
00:24:29,100 --> 00:24:31,100
Si vosotros no lo ponéis,

497
00:24:31,100 --> 00:24:33,100
se hace un súper,

498
00:24:33,100 --> 00:24:35,100
una llamada al constructor de la

499
00:24:35,100 --> 00:24:37,100
superclase, lo que crea

500
00:24:37,100 --> 00:24:39,100
la parte base de la clase sin

501
00:24:39,100 --> 00:24:41,100
parámetros.

502
00:24:41,100 --> 00:24:43,100
Se llama el constructor por defecto.

503
00:24:43,100 --> 00:24:45,100
Es por esa razón que si vosotros

504
00:24:45,100 --> 00:24:47,100
el constructor por defecto de una clase

505
00:24:47,100 --> 00:24:49,100
os lo habéis cargado porque habéis creado

506
00:24:49,100 --> 00:24:51,100
otro constructor con otros parámetros

507
00:24:51,100 --> 00:24:53,100
y luego heredáis esa clase

508
00:24:53,100 --> 00:24:55,100
sin poner un súper

509
00:24:55,100 --> 00:24:57,100
explícitamente, pues os va a dar un error.

510
00:24:57,100 --> 00:24:59,100
Lo hemos hecho la última vez.

511
00:24:59,100 --> 00:25:01,100
Lo volveremos a hacer para

512
00:25:01,100 --> 00:25:03,100
que veáis ese error. Son esos errores

513
00:25:03,100 --> 00:25:05,100
de dónde viene si está todo escrito bien.

514
00:25:05,100 --> 00:25:07,100
Pues no, falta algo.

515
00:25:07,100 --> 00:25:09,100
¿Sí?

516
00:25:09,100 --> 00:25:11,100
Vale.

517
00:25:11,100 --> 00:25:13,100
Constructores y herencias. En el constructor

518
00:25:13,100 --> 00:25:15,100
de la clase derivada se realiza siempre

519
00:25:15,100 --> 00:25:17,100
una llamada al constructor de la clase base.

520
00:25:17,100 --> 00:25:19,100
Esta es la primera acción del

521
00:25:19,100 --> 00:25:21,100
constructor y

522
00:25:21,100 --> 00:25:23,100
hay dos posibilidades. Indicarlo explícitamente,

523
00:25:23,100 --> 00:25:25,100
entonces llama el súper sin nada,

524
00:25:25,100 --> 00:25:27,100
o indicarlo explícitamente, entonces

525
00:25:27,100 --> 00:25:29,100
tiene que estar obligatoriamente la primera línea.

526
00:25:29,100 --> 00:25:31,100
No se puede hacer, hago algo

527
00:25:31,100 --> 00:25:33,100
y luego súper.

528
00:25:33,100 --> 00:25:35,100
La idea es que si vas a utilizar

529
00:25:35,100 --> 00:25:37,100
súper, tiene que ser la primera línea de un

530
00:25:37,100 --> 00:25:39,100
constructor.

531
00:25:39,100 --> 00:25:41,100
¿Sí? Si no,

532
00:25:41,100 --> 00:25:43,100
ya se ha hecho.

533
00:25:43,100 --> 00:25:45,100
Si yo lo pongo

534
00:25:45,100 --> 00:25:47,100
algo antes, pues él en automático

535
00:25:47,100 --> 00:25:49,100
me ha hecho una llamada súper vacía

536
00:25:49,100 --> 00:25:51,100
arriba. Entonces estás

537
00:25:51,100 --> 00:25:53,100
llamando otra vez a otro constructor

538
00:25:53,100 --> 00:25:55,100
y eso no se puede hacer.

539
00:25:57,100 --> 00:25:59,100
Si no se indica explícitamente,

540
00:25:59,100 --> 00:26:01,100
ya va a insertar totalmente la llamada súper.

541
00:26:01,100 --> 00:26:03,100
O sea, aquí

542
00:26:03,100 --> 00:26:05,100
habría una llamada súper

543
00:26:05,100 --> 00:26:07,100
de este tipo, hasta

544
00:26:07,100 --> 00:26:09,100
si yo no la he escrito.

545
00:26:09,100 --> 00:26:11,100
¿Sí?

546
00:26:13,100 --> 00:26:15,100
Si lo indico explícitamente,

547
00:26:15,100 --> 00:26:17,100
en vez, la primera línea

548
00:26:17,100 --> 00:26:19,100
es súper con el constructor

549
00:26:19,100 --> 00:26:21,100
que yo quiero, que puede ser también súper sin nada.

550
00:26:21,100 --> 00:26:23,100
No hace falta, porque

551
00:26:23,100 --> 00:26:25,100
si quiero llamar súper sin nada, pues entonces

552
00:26:25,100 --> 00:26:27,100
puedo no ponerlo directamente, lo hace él

553
00:26:27,100 --> 00:26:29,100
de forma automática, pero si quiero ser explícito

554
00:26:29,100 --> 00:26:31,100
puedo poner súper sin

555
00:26:31,100 --> 00:26:33,100
parámetro.

556
00:26:33,100 --> 00:26:35,100
¿Sí?

557
00:26:35,100 --> 00:26:37,100
Persona.

558
00:26:37,100 --> 00:26:39,100
Si no ponías

559
00:26:39,100 --> 00:26:41,100
nada, te ponía el nombre que era anónimo.

560
00:26:41,100 --> 00:26:43,100
Entonces, en el ejemplo anterior

561
00:26:43,100 --> 00:26:45,100
...

562
00:26:47,100 --> 00:26:49,100
Antes te haría un nombre anónimo

563
00:26:49,100 --> 00:26:51,100
y luego le añadirías

564
00:26:51,100 --> 00:26:53,100
el número que era anónimo.

565
00:26:53,100 --> 00:26:55,100
Al crearte esto de aquí

566
00:26:55,100 --> 00:26:57,100
habría puesto en el nombre

567
00:26:57,100 --> 00:26:59,100
anónimo y luego al ejecutar

568
00:26:59,100 --> 00:27:01,100
esto, cambia nombre

569
00:27:01,100 --> 00:27:03,100
a esta cosa aquí.

570
00:27:03,100 --> 00:27:05,100
Ahora, como ya lo

571
00:27:05,100 --> 00:27:07,100
hace el otro,

572
00:27:07,100 --> 00:27:09,100
esto está mal,

573
00:27:09,100 --> 00:27:11,100
entre comillas, porque si le pasas nombre

574
00:27:11,100 --> 00:27:13,100
pues probablemente aquí habrías

575
00:27:13,100 --> 00:27:15,100
tenido que llamar esto.

576
00:27:15,100 --> 00:27:17,100
¿Sí? Esto es más correcto

577
00:27:17,100 --> 00:27:19,100
probablemente, porque si le pasas los mismos

578
00:27:19,100 --> 00:27:21,100
parámetros que luego sirven al constructor

579
00:27:21,100 --> 00:27:23,100
de arriba, pues esto es más elegante

580
00:27:23,100 --> 00:27:25,100
que el otro.

581
00:27:25,100 --> 00:27:27,100
Hay situaciones en las que

582
00:27:27,100 --> 00:27:29,100
a lo mejor el constructor de alumno

583
00:27:29,100 --> 00:27:31,100
no tiene algo que Persona sí tiene,

584
00:27:31,100 --> 00:27:33,100
entonces tú ya creas

585
00:27:33,100 --> 00:27:35,100
un objeto Persona, se te llenará lo que tenga

586
00:27:35,100 --> 00:27:37,100
que ser hasta por defecto y lo

587
00:27:37,100 --> 00:27:39,100
utilizarás de aquí.

588
00:27:39,100 --> 00:27:41,100
...

589
00:27:41,100 --> 00:27:43,100
...

590
00:27:43,100 --> 00:27:45,100
...

591
00:27:45,100 --> 00:27:47,100
...

592
00:27:47,100 --> 00:27:49,100
...

593
00:27:49,100 --> 00:27:51,100
...

594
00:27:51,100 --> 00:27:53,100
...

595
00:27:53,100 --> 00:27:55,100
...

596
00:27:55,100 --> 00:27:57,100
...

597
00:27:57,100 --> 00:27:59,100
...

598
00:27:59,100 --> 00:28:01,100
...

599
00:28:01,100 --> 00:28:03,100
...

600
00:28:03,100 --> 00:28:05,100
...

601
00:28:05,100 --> 00:28:07,100
...

602
00:28:07,100 --> 00:28:09,100
...

603
00:28:09,100 --> 00:28:11,100
...

604
00:28:11,100 --> 00:28:13,100
...

605
00:28:13,100 --> 00:28:15,100
...

606
00:28:15,100 --> 00:28:17,100
...

607
00:28:17,100 --> 00:28:19,100
...

608
00:28:19,100 --> 00:28:21,100
...

609
00:28:21,100 --> 00:28:23,100
...

610
00:28:23,100 --> 00:28:25,100
...

611
00:28:25,100 --> 00:28:27,100
...

612
00:28:27,100 --> 00:28:29,100
...

613
00:28:29,100 --> 00:28:31,100
...

614
00:28:31,100 --> 00:28:33,100
...

615
00:28:33,100 --> 00:28:35,100
...

616
00:28:35,100 --> 00:28:36,700
el overriding

617
00:28:36,700 --> 00:28:38,940
¿vale? que veremos

618
00:28:38,940 --> 00:28:40,380
después porque

619
00:28:40,380 --> 00:28:43,180
en 5 minutos no me da tiempo

620
00:28:43,180 --> 00:28:45,380
a