1
00:00:00,110 --> 00:00:06,349
porque tengo miedo que luego no funcione el después de haber hecho el zoom no funciona

2
00:00:06,349 --> 00:00:14,550
grabación vale entonces estamos aquí sí entonces siempre siempre siempre hay una llamada al

3
00:00:14,550 --> 00:00:19,710
constructor superior o no lo indicó entonces en automático me hace un súper vacío o si no

4
00:00:19,710 --> 00:00:26,190
lo indicó explícitamente y agradece el súper que yo quiero constructor herencia si no se

5
00:00:26,190 --> 00:00:27,750
indica específicamente, pues

6
00:00:27,750 --> 00:00:30,210
aquí, ¿vale? si yo hago un alumno

7
00:00:30,210 --> 00:00:32,030
con estas cosas aquí y hago esta cosa aquí

8
00:00:32,030 --> 00:00:32,670
pues en

9
00:00:32,670 --> 00:00:36,310
implícitamente

10
00:00:36,310 --> 00:00:38,009
aquí habría hecho una llamada invisible

11
00:00:38,009 --> 00:00:39,750
a super, ¿sí?

12
00:00:39,850 --> 00:00:40,689
y luego hago esto

13
00:00:40,689 --> 00:00:44,130
si en vez lo indico específicamente, pues aquí

14
00:00:44,130 --> 00:00:46,189
estoy diciendo esto, entonces aquí no se hace

15
00:00:46,189 --> 00:00:47,670
la llamada super vacío

16
00:00:47,670 --> 00:00:49,469
¿sí?

17
00:00:50,350 --> 00:00:50,829
¿dudas?

18
00:00:52,649 --> 00:00:53,490
¿preguntas hasta aquí?

19
00:00:55,939 --> 00:00:57,740
vale, entonces

20
00:00:57,740 --> 00:01:18,719
Si hemos entendido un poquito de herencia, hemos entendido un poquito de generalización, especificación, hemos entendido cómo funciona el constructor, hemos entendido que yo tengo por arriba unos parámetros, unos métodos y unos atributos que se reutilizan en las clases heredadas.

21
00:01:18,719 --> 00:01:20,859
Vamos a ver

22
00:01:20,859 --> 00:01:22,900
Unas cosillas un poquito más

23
00:01:22,900 --> 00:01:24,719
Finas

24
00:01:24,719 --> 00:01:26,159
¿Vale? Unas

25
00:01:26,159 --> 00:01:28,859
Cosas que a lo mejor hasta se os ha ocurrido

26
00:01:28,859 --> 00:01:30,159
Pero, no sé

27
00:01:30,159 --> 00:01:32,239
¿Vale? Que se puedan hacer

28
00:01:32,239 --> 00:01:34,319
Dentro del mundo de la herencia

29
00:01:34,319 --> 00:01:36,519
¿Vale? Que son los shadowing

30
00:01:36,519 --> 00:01:37,599
Y el overriding

31
00:01:37,599 --> 00:01:39,439
El overriding lo hemos hecho ya

32
00:01:39,439 --> 00:01:42,879
¿Vale? Era equals, cuando hicimos equals el viernes

33
00:01:42,879 --> 00:01:43,659
Eso hemos

34
00:01:43,659 --> 00:01:45,980
Sobrescrito, override

35
00:01:45,980 --> 00:01:48,780
un método de la clase superior

36
00:01:48,780 --> 00:01:50,819
¿vale? lo veremos después otra vez

37
00:01:50,819 --> 00:01:52,040
y lo formalizaremos

38
00:01:52,040 --> 00:01:53,739
pero es ese el concepto

39
00:01:53,739 --> 00:01:55,260
yo tengo equals de object

40
00:01:55,260 --> 00:01:58,079
pero quiero que cuando comparo dos strings

41
00:01:58,079 --> 00:02:00,799
por ejemplo, no sea el igual igual

42
00:02:00,799 --> 00:02:02,280
la comparación entre dos strings

43
00:02:02,280 --> 00:02:04,840
sino quiero que ir por carácter por carácter

44
00:02:04,840 --> 00:02:07,120
y demostrar que los carácteres son los mismos carácteres

45
00:02:07,120 --> 00:02:08,120
por un lado y por el otro

46
00:02:08,120 --> 00:02:12,180
entonces sobre escribo el método equals en string

47
00:02:12,180 --> 00:02:15,819
para que cuando se haga un equals en tres strings

48
00:02:15,819 --> 00:02:17,939
No se usa el equals de object

49
00:02:17,939 --> 00:02:19,879
Mas se usa el equals de string

50
00:02:19,879 --> 00:02:21,500
Lo veremos

51
00:02:21,500 --> 00:02:22,599
¿Vale? Otra vez

52
00:02:22,599 --> 00:02:25,879
Pero antes vamos a ver el shadowing

53
00:02:25,879 --> 00:02:27,319
Que es una cosa que

54
00:02:27,319 --> 00:02:29,800
En mi experiencia

55
00:02:29,800 --> 00:02:31,740
De programador he utilizado muy poco

56
00:02:31,740 --> 00:02:33,099
Pero existe

57
00:02:33,099 --> 00:02:35,259
¿Vale? Entonces como tal

58
00:02:35,259 --> 00:02:37,479
A lo mejor en algunas clases

59
00:02:37,479 --> 00:02:39,580
En algunos proyectos pues lo vais a

60
00:02:39,580 --> 00:02:41,479
Encontrar y por lo tanto

61
00:02:41,479 --> 00:02:42,879
Tienes que saber que es

62
00:02:42,879 --> 00:02:43,460
¿Vale?

63
00:02:43,460 --> 00:02:46,740
tanto shadowing como overriding

64
00:02:46,740 --> 00:02:48,139
se basan sobre el hecho de

65
00:02:48,139 --> 00:02:49,800
reescribir

66
00:02:49,800 --> 00:02:52,300
en una clase derivada

67
00:02:52,300 --> 00:02:54,699
algo que ya existía

68
00:02:54,699 --> 00:02:56,780
en una clase padre, en una clase base

69
00:02:56,780 --> 00:03:01,199
cuando es shadowing

70
00:03:01,199 --> 00:03:02,439
se está hablando que

71
00:03:02,439 --> 00:03:04,960
un atributo de la clase

72
00:03:04,960 --> 00:03:05,860
que hereda

73
00:03:05,860 --> 00:03:08,159
tiene el mismo nombre

74
00:03:08,159 --> 00:03:11,000
de un atributo de la clase base

75
00:03:11,000 --> 00:03:12,599
yo tenía

76
00:03:12,599 --> 00:03:15,479
string nombre en la clase base

77
00:03:15,479 --> 00:03:18,180
y ahora en la clase

78
00:03:18,180 --> 00:03:22,240
que hereda, en la subclase

79
00:03:22,240 --> 00:03:24,939
vuelvo a utilizar nombre

80
00:03:24,939 --> 00:03:27,659
pero con otro atributo, por ejemplo

81
00:03:27,659 --> 00:03:28,360
int nombre

82
00:03:28,360 --> 00:03:35,889
mientras que el overriding

83
00:03:35,889 --> 00:03:38,469
es cuando tengo un método en la clase base

84
00:03:38,469 --> 00:03:41,909
y este método se vuelve a declarar

85
00:03:41,909 --> 00:03:44,330
con el mismo nombre los mismos atributos

86
00:03:44,330 --> 00:03:46,669
dentro de la clase hija

87
00:03:46,669 --> 00:03:48,550
cuidado que esto no es un overload

88
00:03:48,550 --> 00:03:49,650
porque no se puede

89
00:03:49,650 --> 00:03:51,770
escribir dos veces

90
00:03:51,770 --> 00:03:54,509
el mismo método con el mismo

91
00:03:54,509 --> 00:03:56,050
nombre y los mismos parámetros

92
00:03:56,050 --> 00:03:58,530
es un override

93
00:03:58,530 --> 00:04:00,150
lo estoy reescribiendo

94
00:04:00,150 --> 00:04:02,270
y veremos después

95
00:04:02,270 --> 00:04:04,530
para que me sirve y para que es útil

96
00:04:04,530 --> 00:04:06,349
lo más usual

97
00:04:06,349 --> 00:04:07,629
cuando se produce la estructura es que

98
00:04:07,629 --> 00:04:09,930
se describe el método

99
00:04:09,930 --> 00:04:12,050
el overriding es muy utilizado

100
00:04:12,050 --> 00:04:16,149
en los shadowing yo lo he visto pocas veces

101
00:04:16,149 --> 00:04:17,790
ejemplo de shadowing

102
00:04:17,790 --> 00:04:22,589
tengo la clase persona con public string nombre juan

103
00:04:22,589 --> 00:04:24,910
y luego tengo la clase alumno

104
00:04:24,910 --> 00:04:26,430
que extiende persona

105
00:04:26,430 --> 00:04:29,250
pero public int nombre es igual

106
00:04:29,250 --> 00:04:31,050
a un número

107
00:04:31,050 --> 00:04:33,810
veis que el parámetro se llama igual

108
00:04:33,810 --> 00:04:36,470
pero en la clase persona era un string

109
00:04:36,470 --> 00:04:39,069
y en la clase alumno es un int

110
00:04:39,069 --> 00:04:40,329
esto

111
00:04:40,329 --> 00:04:42,689
hace shadowing, hace shadow, es sombra.

112
00:04:43,329 --> 00:04:50,709
Es como si proyectara la sombra de este parámetro aquí sobre este de aquí.

113
00:04:50,870 --> 00:04:55,350
Este se queda oculto detrás de la sombra de este señor de aquí.

114
00:04:56,110 --> 00:05:00,470
Es decir, que si yo ahora uso un alumno, me espero que el nombre sea un entero,

115
00:05:01,029 --> 00:05:04,269
y si uso una persona, me espero que el nombre sea un string.

116
00:05:08,050 --> 00:05:11,449
Entonces, por ejemplo, si me creo un alumno A,

117
00:05:12,730 --> 00:05:19,050
que es un alumno y luego me creó otra variable p de tipo persona que apunta al

118
00:05:19,050 --> 00:05:31,079
mismo objeto lo puede hacer esto momento paint y yo aquí tengo un alumno

119
00:05:31,079 --> 00:05:41,490
que apunta a un objeto alumno y ahora hago esta cosa de aquí persona p es

120
00:05:41,490 --> 00:05:48,149
igual a lo que estoy haciendo este es a lo que estoy haciendo es crearme una

121
00:05:48,149 --> 00:05:49,509
Una variable p

122
00:05:49,509 --> 00:05:52,149
De tipo persona

123
00:05:52,149 --> 00:05:56,449
Que apunta a este mismo objeto

124
00:05:56,449 --> 00:05:57,149
Lo puedo hacer

125
00:05:57,149 --> 00:06:01,220
Pero si este es un objeto alumno

126
00:06:01,220 --> 00:06:04,000
¿Cómo puedo ponerlo en una variable de tipo persona?

127
00:06:09,230 --> 00:06:09,750
Y entonces

128
00:06:09,750 --> 00:06:11,769
Entonces

129
00:06:11,769 --> 00:06:13,589
Alumno

130
00:06:13,589 --> 00:06:16,610
Es una persona

131
00:06:16,610 --> 00:06:20,490
Allá donde puedo usar

132
00:06:20,490 --> 00:06:21,769
Persona

133
00:06:21,769 --> 00:06:22,970
Puedo poner un alumno

134
00:06:22,970 --> 00:06:24,470
Lo puede hacer, pero cuidado

135
00:06:24,470 --> 00:06:26,629
Que ahora esta de aquí es una referencia a una persona

136
00:06:26,629 --> 00:06:28,730
Esta de aquí es una referencia a un alumno, es un poco distinto

137
00:06:28,730 --> 00:06:30,550
¿Están de acuerdo?

138
00:06:31,810 --> 00:06:32,250
Entonces

139
00:06:32,250 --> 00:06:35,149
Si después de haber declarado estos dos

140
00:06:35,149 --> 00:06:36,430
Y haber hecho

141
00:06:36,430 --> 00:06:40,410
Estas dos líneas aquí

142
00:06:40,410 --> 00:06:42,949
Hago system.out.println

143
00:06:42,949 --> 00:06:44,290
P.nombre

144
00:06:44,290 --> 00:06:46,050
Usando esto

145
00:06:46,050 --> 00:06:48,589
Lo que escribe este println

146
00:06:48,589 --> 00:06:49,290
Será Juan

147
00:06:49,290 --> 00:06:52,350
Porque estoy usando este

148
00:06:52,350 --> 00:06:54,990
nombre, porque es un nombre

149
00:06:54,990 --> 00:06:56,449
de una persona, sí, pero es

150
00:06:56,449 --> 00:06:58,870
una instancia de un alumno, sí

151
00:06:58,870 --> 00:07:00,829
pero lo estoy usando como si fuera una persona

152
00:07:00,829 --> 00:07:02,910
en el shadowing, porque luego veremos que

153
00:07:02,910 --> 00:07:04,089
en el overriding no es así

154
00:07:04,089 --> 00:07:08,569
sin embargo, si

155
00:07:08,569 --> 00:07:10,230
uso directamente una

156
00:07:10,230 --> 00:07:11,990
referencia de tipo alumno

157
00:07:11,990 --> 00:07:14,329
a punto nombre, usará

158
00:07:14,329 --> 00:07:19,060
este nombre de aquí y me lo escribirá

159
00:07:19,060 --> 00:07:20,180
esto es

160
00:07:20,180 --> 00:07:23,100
la utilidad

161
00:07:23,100 --> 00:07:24,839
real, en campo real

162
00:07:24,839 --> 00:07:27,660
de esta cosa, no me queda clara

163
00:07:27,660 --> 00:07:30,459
¿vale? pero en un cierto sentido

164
00:07:30,459 --> 00:07:33,860
yo podría, estaría dando al mismo concepto

165
00:07:33,860 --> 00:07:36,920
al mismo nombre, la misma variable nombre, dos posibles valores

166
00:07:36,920 --> 00:07:39,500
hasta distintos a nivel de

167
00:07:39,500 --> 00:07:42,779
de lo que contiene, ¿sí? y que luego

168
00:07:42,779 --> 00:07:45,220
dentro de aquí, dependiendo de si uso

169
00:07:45,220 --> 00:07:49,060
una referencia a persona o una referencia a alumno

170
00:07:49,060 --> 00:07:51,120
puedo sacar una o la otra cosa

171
00:07:51,120 --> 00:07:56,079
Por ejemplo, en un sistema de corrección de exámenes

172
00:07:56,079 --> 00:08:00,600
La persona tiene su nombre, pero el alumno tiene un número

173
00:08:00,600 --> 00:08:03,740
De esta forma, cuando yo profesor accedo al alumno

174
00:08:03,740 --> 00:08:07,639
El sistema me hace ver su nombre como alumno

175
00:08:07,639 --> 00:08:09,560
Entonces yo no sé quién es

176
00:08:09,560 --> 00:08:12,740
Y corrijo el examen sin saber quién es

177
00:08:12,740 --> 00:08:18,439
Pero luego, cuando el sistema tiene que escribir a este alumno

178
00:08:18,439 --> 00:08:25,740
Es decir, hacer un listado de saber cuánto alumno ha sacado, pues entonces lo trata como persona.

179
00:08:26,100 --> 00:08:30,819
Y entonces me aparecerá, en vez de su numerito, su nombre.

180
00:08:31,779 --> 00:08:33,240
No sé si me explico como ejemplo.

181
00:08:35,259 --> 00:08:40,580
Entonces estaría utilizando el mismo objeto, el mismo objeto alumno, pero al profesor no le hago saber quién es.

182
00:08:40,720 --> 00:08:45,279
Así cuando corrige, no tiene, este me cae bien, este me cae mal, lo corrijo mejor o peor.

183
00:08:45,279 --> 00:08:47,659
Sin embargo, cuando luego hago el listado

184
00:08:47,659 --> 00:08:48,980
Tengo que saber quién es

185
00:08:48,980 --> 00:08:50,820
Para luego guardarlo donde sea

186
00:08:50,820 --> 00:08:52,000
Entonces uso la persona

187
00:08:52,000 --> 00:08:55,159
A posteriori, después, cuando se ha cerrado la corrección

188
00:08:55,159 --> 00:08:56,679
Y ya no se pueden modificar las notas

189
00:08:56,679 --> 00:08:57,899
Pues a este punto

190
00:08:57,899 --> 00:09:00,860
Ya lo trato como persona y sé quién es

191
00:09:00,860 --> 00:09:01,899
¿Se entiende?

192
00:09:02,840 --> 00:09:04,759
Pues un programa como esto

193
00:09:04,759 --> 00:09:05,960
Un caso como esto

194
00:09:05,960 --> 00:09:09,080
Lo podría trabajar haciendo una cosa de este estilo

195
00:09:09,080 --> 00:09:10,059
Haciendo shadowing

196
00:09:10,059 --> 00:09:12,139
De este valor de aquí

197
00:09:12,139 --> 00:09:13,259
Aquí dentro

198
00:09:13,259 --> 00:09:16,000
¿Dudas?

199
00:09:16,000 --> 00:09:42,580
Si definimos una subclase un atributo del mismo nombre y tipo que la superclase, la de la superclase queda oculta, ¿vale? La variable, el atributo de la superclase queda oculto detrás del nuevo variable que tiene el mismo nombre que le hace sombra al otro, ¿vale?

200
00:09:42,580 --> 00:09:49,639
Podemos acceder a la variable de la superclase o de la subclase de la superclase usando this is super

201
00:09:49,639 --> 00:09:59,379
Si yo uso dentro de alumno this.nombre estoy usando este nombre de aquí

202
00:09:59,379 --> 00:10:06,039
Si dentro de alumno quisiera usar este nombre de aquí podría usar super.nombre

203
00:10:06,039 --> 00:10:10,379
Esta es una versión distinta del uso de super

204
00:10:10,379 --> 00:10:17,379
Nosotros antes usábamos super con paréntesis para utilizar el constructor de la superclase.

205
00:10:18,100 --> 00:10:19,379
Aquí estamos usando super.nombre.

206
00:10:20,279 --> 00:10:24,539
Estamos usando un atributo de mi clase superior.

207
00:10:26,940 --> 00:10:33,120
No sería this.nombre porque this.nombre haría referencia al que he hecho aquí que está haciendo shadowing.

208
00:10:33,340 --> 00:10:35,899
Entonces no vería el de la superclase.

209
00:10:35,899 --> 00:10:41,639
Si quisiera desde alumno acceder a este de aquí podría hacerlo con super.nombre.

210
00:10:41,820 --> 00:10:51,590
En vez de utilizar este objeto como dis, utilízamelo como si fuera de la superclase y accede a su campo nombre.

211
00:10:55,070 --> 00:10:59,549
Shadowing, ¿vale? Entonces, veamos cómo se puede utilizar estas cosas.

212
00:10:59,970 --> 00:11:03,730
Tengo la clase abuela, entre comillas, que es transporte.

213
00:11:04,250 --> 00:11:07,730
Tengo dos clases que heredan de transporte, que son tren y vehículo.

214
00:11:08,210 --> 00:11:13,730
Y luego tengo la clase que heredan de vehículo, que son moto y coche, ¿vale?

215
00:11:13,730 --> 00:11:39,990
Nos ponemos en coche. Imaginémonos que en cada uno de estos niveles hemos hecho shadowing del atributo nombre anterior, ¿vale? Si es en transporte, nombre vale terrestre. Si es vehículo, nombre vale turismo. Y si es coche, nombre vale Ferrari, mi coche, ¿vale?

216
00:11:39,990 --> 00:11:45,350
Entonces, ¿cómo acceder a variables ocultas desde la clase hija?

217
00:11:45,490 --> 00:11:50,289
Es decir, si yo estoy en coche y uso nombre, ¿qué me pondrá?

218
00:11:53,220 --> 00:11:59,259
Si yo estoy dentro de coche y uso nombre, ¿nombre cuánto valdrá?

219
00:11:59,500 --> 00:12:00,080
¿Qué valdrá?

220
00:12:04,860 --> 00:12:07,820
Hola, como Nuri.

221
00:12:09,019 --> 00:12:09,539
Ferrari.

222
00:12:11,620 --> 00:12:11,799
¿Sí?

223
00:12:11,940 --> 00:12:15,179
Porque dentro de coche la definición de nombre es Ferrari.

224
00:12:16,120 --> 00:12:16,759
¿Sí?

225
00:12:16,759 --> 00:12:19,960
Ahora, si yo dentro de coche

226
00:12:19,960 --> 00:12:21,019
Estoy siempre dentro de coche

227
00:12:21,019 --> 00:12:22,720
Uso dis.nombre

228
00:12:22,720 --> 00:12:24,659
¿Cuánto me vale dis.nombre?

229
00:12:24,740 --> 00:12:26,200
System.at.pln

230
00:12:26,200 --> 00:12:27,299
Dis.nombre

231
00:12:27,299 --> 00:12:28,259
¿Qué me escribe?

232
00:12:30,320 --> 00:12:30,919
Ferrari

233
00:12:30,919 --> 00:12:34,340
El nombre es dis.nombre

234
00:12:34,340 --> 00:12:35,299
Estoy siempre en coche

235
00:12:35,299 --> 00:12:36,759
¿Sí?

236
00:12:37,100 --> 00:12:39,399
Ahora, si yo pongo super.nombre

237
00:12:39,399 --> 00:12:40,080
¿Qué me escribe?

238
00:12:41,220 --> 00:12:41,860
Turismo

239
00:12:41,860 --> 00:12:44,399
Porque desde aquí

240
00:12:44,399 --> 00:12:46,059
Si hago super

241
00:12:46,059 --> 00:12:56,000
Me estoy yendo a mi superclase, entonces ahora soy un vehículo, y cuando accedo a vehículo.nombre, encontraré esto.

242
00:12:57,419 --> 00:12:59,179
Entonces me escribirá turismo.

243
00:13:00,259 --> 00:13:06,600
Y si yo hago vehículo de this.nombre, turismo.

244
00:13:07,299 --> 00:13:14,720
Porque estoy diciendo, pilla este objeto, pero castéalo a un vehículo, o sea, trátalo como si fuera un vehículo.

245
00:13:14,720 --> 00:13:17,320
Y ahora accede a su campo nombre

246
00:13:17,320 --> 00:13:19,879
Por lo tanto accedo a este nombre

247
00:13:19,879 --> 00:13:24,740
¿Puedo hacer super punto super punto nombre?

248
00:13:25,899 --> 00:13:26,580
No, ¿por qué?

249
00:13:26,679 --> 00:13:30,100
Porque está una línea roja en el medio

250
00:13:30,100 --> 00:13:32,279
Y porque está escrito mal

251
00:13:32,279 --> 00:13:33,720
¿Sí?

252
00:13:34,000 --> 00:13:34,919
Entonces esto no

253
00:13:34,919 --> 00:13:37,500
¿Cómo hago entonces acceder a este de aquí?

254
00:13:37,919 --> 00:13:39,720
Pues la misma cosa que he hecho aquí

255
00:13:39,720 --> 00:13:42,200
Pero hago con transporte

256
00:13:42,200 --> 00:13:43,559
O sea, pillas este objeto

257
00:13:43,559 --> 00:13:46,399
Dices, castéalo a transporte

258
00:13:46,399 --> 00:13:52,960
O sea, considéralo como fuera un transporte. ¿Lo puedo hacer? Sí, porque coche es un vehículo y vehículo es un transporte.

259
00:13:53,019 --> 00:13:59,019
Por lo tanto, coche es un transporte. Lo puedo hacer. Y a este punto accede al nombre. Estoy accediendo a este nombre.

260
00:14:02,940 --> 00:14:15,639
¿Se entiende? Entonces, si yo declaro otra vez el mismo atributo, fijaos que aquí le hemos cambiado también el tipo,

261
00:14:15,639 --> 00:14:34,139
Pero no es necesario, ¿vale? En varias clases que se heredan, los nuevos, los más heredados, pues hacen, los nuevos definidos hacen sombra a los que ya existían, a los heredados, ¿sí?

262
00:14:34,139 --> 00:14:38,039
Pero hay formas de poder acceder a eso si yo quiero

263
00:14:38,039 --> 00:14:41,250
¿Dudas hasta aquí?

264
00:14:47,200 --> 00:14:48,879
Esto más o menos es el shadowing

265
00:14:48,879 --> 00:14:52,679
El otro tema es el overriding

266
00:14:52,679 --> 00:14:55,080
¿Vale? El sobreescribir

267
00:14:55,080 --> 00:15:00,840
La escritura de un método es útil para ampliar la funcionalidad de un método

268
00:15:00,840 --> 00:15:04,600
O particularizar las funcionalidades de un método a la clase derivada

269
00:15:04,600 --> 00:15:06,620
Es decir, el overriding es lo mismo

270
00:15:06,620 --> 00:15:11,240
Solo que en vez de estar reescribiendo un parámetro, un atributo

271
00:15:11,240 --> 00:15:13,019
Estoy reescribiendo un método

272
00:15:13,019 --> 00:15:23,220
Y lo puedo usar para dos cosas. La primera es que el método que estaba en persona hace algo, pero no es suficiente para alumno.

273
00:15:23,539 --> 00:15:32,779
Alumno debería hacer ese algo y algo más. Por ejemplo, yo tengo el método Descríbete.

274
00:15:33,559 --> 00:15:40,899
Pues cuando uso Descríbete en persona, me dirá me llamo Estefano. Vale, porque tiene nombre.

275
00:15:41,440 --> 00:15:43,200
Ahora, alumno tiene también sus notas.

276
00:15:43,659 --> 00:15:47,679
Entonces, si yo le digo, alumno, descríbete, me dice, me llamo Estefano, me falta algo.

277
00:15:47,919 --> 00:15:51,120
Porque debería decir, me llamo Estefano y mis notas son 3, 7 y 9.

278
00:15:53,210 --> 00:15:53,370
¿Sí?

279
00:15:53,929 --> 00:15:59,350
Por lo tanto, yo lo que puedo hacer es sobrescribir el método de escríbete de persona,

280
00:15:59,929 --> 00:16:04,070
diciendo, oye, mira, haz lo mismo que hace persona y algo más.

281
00:16:04,990 --> 00:16:09,549
Te describes, hola, soy Estefano, y luego me pones la lista de tus notas.

282
00:16:09,549 --> 00:16:13,309
Esto sería el primer caso, ampliar la funcionalidad de un método

283
00:16:13,309 --> 00:16:23,850
La segunda opción podría ser cambiar o particularizar la cosa

284
00:16:23,850 --> 00:16:28,210
Por ejemplo, imaginaos una situación de este estilo

285
00:16:28,210 --> 00:16:49,509
Yo tengo aquí animal y aquí tengo que heredan de animal gato y perro

286
00:16:49,509 --> 00:17:13,200
como no. Ahora, yo tengo en animal un método que es produce sonido. Ahora, cuando un animal

287
00:17:13,200 --> 00:17:21,259
produce un sonido, yo no sé qué animal, qué sonido hace. Entonces pondrá system.auto.println

288
00:17:21,259 --> 00:17:23,740
Este animal produce un sonido

289
00:17:23,740 --> 00:17:30,059
Ahora, cuando yo voy a hacer el gato

290
00:17:30,059 --> 00:17:32,880
Yo no quiero que ponga

291
00:17:32,880 --> 00:17:34,440
Este animal produce un sonido

292
00:17:34,440 --> 00:17:36,299
Porque sé que hace el gato

293
00:17:36,299 --> 00:17:41,680
Entonces, sobreescribo este método

294
00:17:41,680 --> 00:17:42,380
Pero no diciendo

295
00:17:42,380 --> 00:17:45,220
Haz lo mismo que hace un animal y algo más

296
00:17:45,220 --> 00:17:47,880
Pero no, lo particularizo para mi animal

297
00:17:47,880 --> 00:17:51,339
Entonces diré que cuando gato hace y produce sonido

298
00:17:51,339 --> 00:17:54,160
ahora system.auto.ptln

299
00:17:54,160 --> 00:17:54,740
miau

300
00:17:54,740 --> 00:17:59,349
y cuando hace el perro

301
00:17:59,349 --> 00:18:00,950
el perro claramente

302
00:18:00,950 --> 00:18:02,069
hace bau

303
00:18:02,069 --> 00:18:04,809
vosotros si os equivocáis en España

304
00:18:04,809 --> 00:18:05,950
decís que hace guau

305
00:18:05,950 --> 00:18:09,009
pero no, hace bau

306
00:18:09,009 --> 00:18:09,769
porque aquí

307
00:18:09,769 --> 00:18:12,210
efectivamente

308
00:18:12,210 --> 00:18:13,509
si

309
00:18:13,509 --> 00:18:15,490
entendéis

310
00:18:15,490 --> 00:18:17,950
es sutil la diferencia

311
00:18:17,950 --> 00:18:19,130
pero hay una diferencia

312
00:18:19,130 --> 00:18:21,549
yo puedo sobre escribir este método

313
00:18:21,549 --> 00:18:22,910
en una clase redada

314
00:18:22,910 --> 00:18:25,029
Para o extender

315
00:18:25,029 --> 00:18:27,369
Lo que hacía antes, ahora hace algo más

316
00:18:27,369 --> 00:18:28,470
¿Vale?

317
00:18:28,569 --> 00:18:31,150
O cambiarlo completamente en base a que

318
00:18:31,150 --> 00:18:32,410
Esta clase que hereda

319
00:18:32,410 --> 00:18:34,470
Hace una funcionalidad un poquito distinta

320
00:18:34,470 --> 00:18:36,230
¿Sí?

321
00:18:36,710 --> 00:18:40,809
Si definimos en una subclase

322
00:18:40,809 --> 00:18:42,450
Un método con la misma

323
00:18:42,450 --> 00:18:44,710
Signature

324
00:18:44,710 --> 00:18:46,250
Con la misma firma, ¿vale?

325
00:18:46,289 --> 00:18:48,349
Nombre, tipo y número de parámetros

326
00:18:48,349 --> 00:18:50,930
Que en la superclase

327
00:18:50,930 --> 00:18:51,490
De la clase

328
00:18:51,490 --> 00:18:54,170
El método de la superclase

329
00:18:54,170 --> 00:18:56,730
queda oculto

330
00:18:56,730 --> 00:18:57,809
es decir

331
00:18:57,809 --> 00:19:00,289
si gato produce sonido

332
00:19:00,289 --> 00:19:02,109
sin parámetros

333
00:19:02,109 --> 00:19:04,609
y animal produce sonido

334
00:19:04,609 --> 00:19:06,549
sin parámetros, ahora produce

335
00:19:06,549 --> 00:19:08,609
sonido

336
00:19:08,609 --> 00:19:10,569
de animal, se queda oculto

337
00:19:10,569 --> 00:19:12,869
cuando yo tengo un gato, usaré el de gato

338
00:19:12,869 --> 00:19:14,789
no el de

339
00:19:14,789 --> 00:19:16,849
de animal

340
00:19:16,849 --> 00:19:18,710
parecido

341
00:19:18,710 --> 00:19:19,769
a los shadowing de antes

342
00:19:19,769 --> 00:19:22,849
cuando declaraba una cosa en una clase

343
00:19:22,849 --> 00:19:29,549
inferior, pues lo que está haciendo es ocultar lo de la clase superior. Entonces, si yo tengo

344
00:19:29,549 --> 00:19:35,029
el método arrancar, estamos siempre en esta cosa de aquí, ¿vale? Y tenemos el método

345
00:19:35,029 --> 00:19:41,890
arrancar. Si yo en coche uso arrancar, pues estoy usando el método de arrancar de coche.

346
00:19:42,630 --> 00:19:50,890
Si uso dis.arrancar, estoy utilizando el método de coche. Si uso super.arrancar, voy a utilizar

347
00:19:50,890 --> 00:19:52,130
el método del vehículo

348
00:19:52,130 --> 00:20:03,779
el shadowing es sobre

349
00:20:03,779 --> 00:20:05,200
parámetros, sobre atributos

350
00:20:05,200 --> 00:20:07,359
y el overriding es sobre métodos

351
00:20:07,359 --> 00:20:09,799
pero tiene una diferencia fundamental

352
00:20:09,799 --> 00:20:11,259
que la veremos

353
00:20:11,259 --> 00:20:16,240
ahora, fijaos que no puedo

354
00:20:16,240 --> 00:20:17,940
usar super, super, punto nombre

355
00:20:17,940 --> 00:20:20,400
¿vale? pero el problema

356
00:20:20,400 --> 00:20:22,339
es que no puedo usar esto

357
00:20:22,339 --> 00:20:27,299
es decir, que en una situación

358
00:20:27,299 --> 00:20:28,200
como esta

359
00:20:28,200 --> 00:20:31,400
desde coche, no puedo

360
00:20:31,400 --> 00:20:33,220
usar arrancar de transporte

361
00:20:35,640 --> 00:20:36,619
puedo llegar como

362
00:20:36,619 --> 00:20:40,140
máximo a vehículo usando super punto arrancar

363
00:20:40,140 --> 00:20:44,700
si quisiera llegar a transporte debería en vehículo

364
00:20:44,700 --> 00:20:48,700
poner un método que hace super punto arrancar

365
00:20:48,700 --> 00:20:52,380
entonces vehículo puede acceder a transporte y yo puedo acceder a vehículo

366
00:20:52,380 --> 00:20:54,119
por lo tanto lo puedo hacer

367
00:20:54,119 --> 00:20:59,279
pero no lo puedo hacer directamente, esto porque

368
00:20:59,279 --> 00:21:04,440
cuando hago shadowing esta cosa de aquí funciona

369
00:21:04,440 --> 00:21:11,920
Si yo le digo, o esta, si yo le digo this, tráctamelo como transporte, para él es un transporte, entonces accederá a esto.

370
00:21:12,980 --> 00:21:25,460
Cuando uso el overriding, si yo hago this y lo casteo a otra cosa, a vehículo en este caso, no se usa el tipo de la referencia,

371
00:21:25,460 --> 00:21:40,940
Entonces, no obstante la referencia sea transporte, porque la he casteado a transporte, y el objeto que he creado es un coche, y por lo tanto uso el de coche.

372
00:21:40,940 --> 00:21:44,460
no se usa

373
00:21:44,460 --> 00:21:57,789
no se usa

374
00:21:57,789 --> 00:21:58,970
el tipo

375
00:21:58,970 --> 00:22:01,009
de la referencia

376
00:22:01,009 --> 00:22:03,430
mas se usa el tipo

377
00:22:03,430 --> 00:22:05,509
del objeto

378
00:22:05,509 --> 00:22:06,769
de la instancia

379
00:22:06,769 --> 00:22:10,140
si

380
00:22:10,140 --> 00:22:13,099
en el shadowing

381
00:22:13,099 --> 00:22:15,960
el tipo de la referencia cuenta

382
00:22:15,960 --> 00:22:18,619
en el overriding

383
00:22:18,619 --> 00:22:19,259
overriding

384
00:22:19,259 --> 00:22:19,700
no se

385
00:22:19,700 --> 00:22:22,519
se usa

386
00:22:22,519 --> 00:22:25,539
el tipo de la instancia

387
00:22:25,539 --> 00:22:28,920
queda claro

388
00:22:28,920 --> 00:22:33,319
o sea que si yo hago

389
00:22:33,319 --> 00:22:35,019
a.arrancar

390
00:22:35,019 --> 00:22:37,599
o bueno aquí es alumno

391
00:22:37,599 --> 00:22:40,299
si yo hago a.saludar

392
00:22:40,299 --> 00:22:43,279
o p.saludar

393
00:22:43,279 --> 00:22:46,140
siempre estaría utilizando

394
00:22:46,140 --> 00:22:47,960
la implementación de saludar

395
00:22:47,960 --> 00:22:49,559
de la clase alumno

396
00:22:49,559 --> 00:22:53,670
porque esto es un alumno

397
00:22:53,670 --> 00:22:56,490
entonces es normal que use el de alumno

398
00:22:56,490 --> 00:22:58,250
pero esto debería ser una persona

399
00:22:58,250 --> 00:23:01,569
pero Java se da cuenta que no obstante

400
00:23:01,569 --> 00:23:03,650
tú lo estés llamando con una referencia

401
00:23:03,650 --> 00:23:05,589
de tipo persona, en realidad

402
00:23:05,589 --> 00:23:07,630
esto no es una persona, este es un

403
00:23:07,630 --> 00:23:09,529
alumno, y entonces te va

404
00:23:09,529 --> 00:23:11,450
a utilizar los métodos de la clase

405
00:23:11,450 --> 00:23:17,819
más específica, queda claro

406
00:23:17,819 --> 00:23:21,859
esta es la diferencia entre shadowing

407
00:23:21,859 --> 00:23:23,779
y además que une sobre

408
00:23:23,779 --> 00:23:26,140
parámetros y une sobre métodos

409
00:23:26,140 --> 00:23:27,660
funcionan un poquito

410
00:23:27,660 --> 00:23:31,700
distinto, si entonces por ejemplo

411
00:23:31,700 --> 00:23:33,759
en overriding, yo aquí tenía recurso

412
00:23:33,759 --> 00:23:35,680
tenía decir descripción, ahora

413
00:23:35,680 --> 00:23:37,579
decir descripción vale para

414
00:23:37,579 --> 00:23:39,640
todo, pero por ejemplo la descripción de un aula

415
00:23:39,640 --> 00:23:41,339
o de un ordenador son distintos

416
00:23:41,339 --> 00:23:43,279
pues entonces aquí

417
00:23:43,279 --> 00:23:46,059
sobrescribo decir descripción

418
00:23:46,059 --> 00:23:47,619
esto quiere decir que cuando

419
00:23:47,619 --> 00:23:50,079
desde aquí uso this.decir

420
00:23:50,079 --> 00:23:51,359
descripción estoy usando

421
00:23:51,359 --> 00:23:53,559
esta definición

422
00:23:53,559 --> 00:23:55,779
si desde aula uso

423
00:23:55,779 --> 00:23:57,619
super.decir descripción

424
00:23:57,619 --> 00:23:59,680
estoy usando el método de

425
00:23:59,680 --> 00:24:03,829
recurso, ¿se entiende?

426
00:24:03,829 --> 00:24:08,980
al mandar un mensaje a un objeto

427
00:24:08,980 --> 00:24:10,519
el método seleccionado

428
00:24:10,519 --> 00:24:12,720
depende de la clase real

429
00:24:12,720 --> 00:24:14,680
del objeto, del que el objeto es

430
00:24:14,680 --> 00:24:16,599
una instancia, lo que decimos ahora

431
00:24:16,599 --> 00:24:19,019
si yo llamo

432
00:24:19,019 --> 00:24:20,700
el decir descripción

433
00:24:20,700 --> 00:24:22,740
y no sé si voy a utilizar

434
00:24:22,740 --> 00:24:24,220
el de recurso o el de aula

435
00:24:24,220 --> 00:24:27,240
no voy a mirar el tipo de la variable

436
00:24:27,240 --> 00:24:28,579
sino voy a mirar

437
00:24:28,579 --> 00:24:30,059
el tipo de la instancia

438
00:24:30,059 --> 00:24:32,380
¿dónde se define el tipo de la instancia?

439
00:24:39,539 --> 00:24:40,960
¿dónde se define el tipo de la instancia?

440
00:24:40,960 --> 00:24:58,559
¿Vosotros queréis ser programadores en la vida o queréis ser gente que mira cosas al azar?

441
00:24:59,500 --> 00:25:04,200
Pues, ¿dónde se define qué tipo tiene el objeto que creo?

442
00:25:07,660 --> 00:25:08,980
¿En qué parte del código?

443
00:25:12,319 --> 00:25:13,559
¡Exacto! En la new

444
00:25:13,559 --> 00:25:17,880
Cuando yo hago new cocodrilo

445
00:25:17,880 --> 00:25:21,160
Estoy creando un objeto de tipo cocodrilo

446
00:25:21,160 --> 00:25:22,680
En la instancia de tipo cocodrilo

447
00:25:22,680 --> 00:25:26,400
Ahora, luego este cocodrilo lo puedo guardar en otra cosa

448
00:25:26,400 --> 00:25:33,079
No, es una instancia de cocodrilo

449
00:25:33,079 --> 00:25:35,119
Pero la referencia es de otro tipo

450
00:25:35,119 --> 00:25:37,119
Si yo hago persona p

451
00:25:37,119 --> 00:25:38,880
Es igual a new alumno

452
00:25:38,880 --> 00:25:39,839
Lo puedo hacer

453
00:25:39,839 --> 00:25:43,920
Porque alumno es una persona

454
00:25:43,920 --> 00:25:47,019
La referencia es persona

455
00:25:47,019 --> 00:25:49,079
Pero la instancia

456
00:25:49,079 --> 00:25:50,259
Sigue siendo un alumno

457
00:25:50,259 --> 00:25:52,319
En un cierto sentido es lo que ha hecho aquí

458
00:25:52,319 --> 00:25:53,559
¿Dónde estaba?

459
00:25:55,640 --> 00:25:56,240
Aquí

460
00:25:56,240 --> 00:25:59,500
Yo he creado un nuevo alumno

461
00:25:59,500 --> 00:26:01,420
Esto es un alumno

462
00:26:01,420 --> 00:26:03,380
Pero luego he creado una referencia

463
00:26:03,380 --> 00:26:04,440
Que no tiene el mismo tipo

464
00:26:04,440 --> 00:26:06,019
Pero tiene un tipo compatible

465
00:26:06,019 --> 00:26:10,980
Yes

466
00:26:10,980 --> 00:26:15,900
¿Y si dejara la instancia de persona?

467
00:26:17,740 --> 00:26:18,640
Probablemente también

468
00:26:18,640 --> 00:26:24,029
Porque el alumno tiene dentro una instancia de persona

469
00:26:24,029 --> 00:26:28,059
¿Sí?

470
00:26:32,029 --> 00:26:33,569
Vale, estamos acabando

471
00:26:33,569 --> 00:26:35,329
Casi

472
00:26:35,329 --> 00:26:40,519
Entonces

473
00:26:40,519 --> 00:26:42,000
Ejemplo de overriding

474
00:26:42,000 --> 00:26:43,779
No lo sé como se dice

475
00:26:43,779 --> 00:26:46,700
Aquí tengo persona

476
00:26:46,700 --> 00:26:49,079
con imprimir, aquí tengo alumno

477
00:26:49,079 --> 00:26:51,119
que extiende personas con imprimir

478
00:26:51,119 --> 00:26:52,940
fijaos que esto, el cambio aquí

479
00:26:52,940 --> 00:26:55,000
es simplemente que esto escribe persona y esto escribe alumno

480
00:26:55,000 --> 00:26:55,579
¿vale?

481
00:26:56,339 --> 00:26:58,259
si yo uso

482
00:26:58,259 --> 00:27:00,660
alumno A es igual a null alumno

483
00:27:00,660 --> 00:27:02,740
persona P es igual a A, lo que hemos

484
00:27:02,740 --> 00:27:05,259
hecho antes, y luego llamo A.imprimir

485
00:27:05,259 --> 00:27:06,519
o P.imprimir

486
00:27:06,519 --> 00:27:08,759
los dos me escriben

487
00:27:08,759 --> 00:27:09,180
alumno

488
00:27:09,180 --> 00:27:12,180
esto, porque es obvio

489
00:27:12,180 --> 00:27:14,599
este aquí es menos obvio, pero

490
00:27:14,599 --> 00:27:16,640
él va a mirar P, ve que

491
00:27:16,640 --> 00:27:20,519
p apunta a una instancia de tipo alumno y entonces

492
00:27:20,519 --> 00:27:24,480
decide de utilizar el imprimir de alumno, no el imprimir de persona

493
00:27:24,480 --> 00:27:33,140
¿si? y tiene sentido, lo veremos con polimorfismo

494
00:27:33,140 --> 00:27:35,319
y cosas por el estilo, que tiene sentido que funcione así

495
00:27:35,319 --> 00:27:42,349
super, vale, y son 3, 4, 3, 3, 3

496
00:27:42,349 --> 00:27:47,470
super es una referencia al objeto actual como si fuera una instancia

497
00:27:47,470 --> 00:27:51,349
de la superclase, vale, lo hemos visto aquí, cuando yo hago

498
00:27:51,349 --> 00:27:54,609
SuperPuntaArrancar

499
00:27:54,609 --> 00:27:56,250
Estoy diciendo, oye mira

500
00:27:56,250 --> 00:27:58,150
Voy a utilizar este objeto

501
00:27:58,150 --> 00:28:00,630
Pero no como si fuera de esta clase

502
00:28:00,630 --> 00:28:02,170
Como si fuera de la clase superior

503
00:28:02,170 --> 00:28:04,450
Entonces cuando llamo

504
00:28:04,450 --> 00:28:05,710
SuperPuntaArrancar

505
00:28:05,710 --> 00:28:08,589
Voy a usar el método arrancar

506
00:28:08,589 --> 00:28:09,809
De mi superclase

507
00:28:09,809 --> 00:28:11,150
O sea en este caso de vehículo

508
00:28:11,150 --> 00:28:15,140
Aquí

509
00:28:15,140 --> 00:28:17,500
A través de la referencia super

510
00:28:17,500 --> 00:28:19,400
Se puede acceder específicamente

511
00:28:19,400 --> 00:28:21,019
A métodos de la superclase

512
00:28:21,019 --> 00:28:23,160
o a variables

513
00:28:23,160 --> 00:28:25,140
de la superclase si tienen

514
00:28:25,140 --> 00:28:27,220
shadowing, vale, lo hemos visto

515
00:28:27,220 --> 00:28:29,619
antes, yo tenía nombre, dis.nombre

516
00:28:29,619 --> 00:28:31,079
me daba una cosa, si pero

517
00:28:31,079 --> 00:28:32,720
usaba super.nombre

518
00:28:32,720 --> 00:28:34,279
iba a mi padre

519
00:28:34,279 --> 00:28:35,960
o sea, iba

520
00:28:35,960 --> 00:28:39,119
al valor que le había dado a esa

521
00:28:39,119 --> 00:28:40,839
variable como si fuera

522
00:28:40,839 --> 00:28:43,160
una clase de tipo superclase

523
00:28:43,160 --> 00:28:46,920
para reescribir métodos

524
00:28:46,920 --> 00:28:48,039
no solo el constructor

525
00:28:48,039 --> 00:28:52,140
puede ser útil usar la referencia super, ¿vale?

526
00:28:52,759 --> 00:28:56,440
¿Os acordáis? Antes decíamos, yo podría hacer

527
00:28:56,440 --> 00:29:00,279
todo lo que hace, un método que hace todo lo que hace el método

528
00:29:00,279 --> 00:29:03,700
de mi superclase y algo más. Como

529
00:29:03,700 --> 00:29:07,859
me voy a presentar y digo, hola, soy Estefano, y luego

530
00:29:07,859 --> 00:29:11,960
poner todas mis notas, porque soy un alumno.

531
00:29:13,039 --> 00:29:16,299
¿Os acordáis? Pues, la parte de escribir

532
00:29:16,299 --> 00:29:19,180
Hola soy Stefano, ya la tengo, la tengo en persona

533
00:29:19,180 --> 00:29:24,380
Entonces lo que puedo hacer es, vale, mi método imprime de alumno es

534
00:29:24,380 --> 00:29:29,539
Haz todo lo que hacía la clase superior, super.imprime

535
00:29:29,539 --> 00:29:34,099
Llama el método de arriba, entonces se escribirá ya Hola soy Stefano

536
00:29:34,099 --> 00:29:41,930
Y a continuación sigues con las cosas nuevas, ¿se entiende?

537
00:29:41,930 --> 00:29:53,779
En este caso este super no es necesario utilizarlo como primera línea del método

538
00:29:53,779 --> 00:29:56,460
Se puede usar cuando te da la gana, lo puedes usar hasta dos veces

539
00:29:56,460 --> 00:30:05,470
Entonces para resumir de super, super se puede utilizar así o así

540
00:30:05,470 --> 00:30:09,390
Para hacer referencia a un constructor

541
00:30:09,390 --> 00:30:13,109
Y que este de aquí

542
00:30:13,109 --> 00:30:14,309
Si no pongo nada

543
00:30:14,309 --> 00:30:15,789
Se llama implícitamente

544
00:30:15,789 --> 00:30:20,779
Puede usar super como referencia

545
00:30:20,779 --> 00:30:22,240
Parecido al dis

546
00:30:22,240 --> 00:30:23,980
A un método

547
00:30:23,980 --> 00:30:25,259
O a un atributo

548
00:30:25,259 --> 00:30:27,960
Que sería, usa este método

549
00:30:27,960 --> 00:30:29,140
Usa este atributo

550
00:30:29,140 --> 00:30:31,400
Como si fuera yo

551
00:30:31,400 --> 00:30:33,680
Un objeto de mi superclase

552
00:30:33,680 --> 00:30:45,500
Y luego está esta cosa

553
00:30:45,500 --> 00:30:49,420
del instanceOf. Como ahora tengo el caos

554
00:30:49,420 --> 00:30:53,440
porque puedo tener variables que no sé dentro si tienen

555
00:30:53,440 --> 00:30:57,460
un alumno, una persona, un empleado o lo que sea, tengo

556
00:30:57,460 --> 00:31:01,779
este mecanismo de aquí, que sostancialmente

557
00:31:01,779 --> 00:31:05,140
le digo una variable instanceOf una clase

558
00:31:05,140 --> 00:31:09,359
y él me devuelve true si este

559
00:31:09,359 --> 00:31:13,480
señor es una instancia de este de aquí o false si este

560
00:31:13,480 --> 00:31:15,039
no es. Aquí error, pero en realidad

561
00:31:15,039 --> 00:31:15,519
sí es false.

562
00:31:16,819 --> 00:31:19,400
Entonces, si yo hago gato, gato es igual a new gato.

563
00:31:19,759 --> 00:31:21,240
Y luego le pregunto, ¿gato es un animal?

564
00:31:21,740 --> 00:31:23,039
Sí, porque

565
00:31:23,039 --> 00:31:24,819
gato hereda de animal.

566
00:31:25,140 --> 00:31:26,700
Entonces, gato es un animal.

567
00:31:27,460 --> 00:31:29,079
¿Gato es un gato?

568
00:31:29,220 --> 00:31:31,099
Sí, porque gato es un gato.

569
00:31:31,880 --> 00:31:33,599
Pero si le digo, ¿gato es un perro?

570
00:31:33,859 --> 00:31:38,289
No. Con esto

571
00:31:38,289 --> 00:31:39,670
puedo saber

572
00:31:39,670 --> 00:31:42,190
una variable, qué tipo

573
00:31:42,190 --> 00:31:43,950
es, y en base a eso

574
00:31:43,950 --> 00:31:45,789
poder hacer casting, etc.

575
00:31:46,390 --> 00:31:47,430
Vale