1
00:00:00,000 --> 00:00:01,980
venga pues a ver

2
00:00:01,980 --> 00:00:04,919
bueno pues entonces

3
00:00:04,919 --> 00:00:06,299
estábamos diciendo que

4
00:00:06,299 --> 00:00:09,540
gracias a que existe la herencia

5
00:00:09,540 --> 00:00:11,279
hacemos un único método

6
00:00:11,279 --> 00:00:13,019
que es realizar la acción

7
00:00:13,019 --> 00:00:15,359
que sea del animal que sea

8
00:00:15,359 --> 00:00:17,100
estupendo

9
00:00:17,100 --> 00:00:19,339
el método ya coge a ese animal

10
00:00:19,339 --> 00:00:21,440
sea el que sea y trata de realizar la acción

11
00:00:21,440 --> 00:00:23,160
y el problema es

12
00:00:23,160 --> 00:00:25,060
que la acción que se hace

13
00:00:25,060 --> 00:00:27,539
ladrar, maullar, nadar

14
00:00:27,539 --> 00:00:28,519
la acción que se hace

15
00:00:28,519 --> 00:00:31,160
depende del tipo de objeto que es

16
00:00:31,160 --> 00:00:33,519
depende de cómo se le hizo el new

17
00:00:33,519 --> 00:00:34,740
de cómo se le instanció

18
00:00:34,740 --> 00:00:36,759
entonces tenemos que poder distinguirlo

19
00:00:36,759 --> 00:00:38,619
pues cómo lo distinguimos

20
00:00:38,619 --> 00:00:40,560
gracias a que existe esta sentencia

21
00:00:40,560 --> 00:00:42,619
vale entonces en nuestro caso

22
00:00:42,619 --> 00:00:43,399
que eso lo tenemos

23
00:00:43,399 --> 00:00:45,780
pues

24
00:00:45,780 --> 00:00:49,579
perro y pez

25
00:00:49,579 --> 00:00:53,439
pues podríamos dejar así el método

26
00:00:53,439 --> 00:00:58,159
y entonces

27
00:00:58,159 --> 00:00:58,500
en ese caso

28
00:00:58,500 --> 00:00:58,960
en ese caso

29
00:00:58,960 --> 00:01:01,840
me falta aquí el A

30
00:01:01,840 --> 00:01:02,840
vale

31
00:01:02,840 --> 00:01:05,840
si esta condición

32
00:01:05,840 --> 00:01:11,040
si esta condición es true

33
00:01:11,040 --> 00:01:12,540
si esta condición es true

34
00:01:12,540 --> 00:01:14,780
es porque A que llegó aquí

35
00:01:14,780 --> 00:01:16,000
A que llegó ahí

36
00:01:16,000 --> 00:01:18,680
cuando se le instanció, se le instanció como pez

37
00:01:18,680 --> 00:01:20,740
entonces si esta condición es true

38
00:01:20,740 --> 00:01:22,180
es porque tenemos la seguridad

39
00:01:22,180 --> 00:01:24,920
de que A se instanció como objeto pez

40
00:01:24,920 --> 00:01:26,659
con lo cual como tenemos la seguridad

41
00:01:26,659 --> 00:01:28,480
de que A se instanció como objeto pez

42
00:01:28,500 --> 00:01:30,980
le podemos hacer un casting

43
00:01:30,980 --> 00:01:33,079
sin miedo a equivocarnos

44
00:01:33,079 --> 00:01:40,680
le hacemos un casting

45
00:01:40,680 --> 00:01:42,900
y ahora ya

46
00:01:42,900 --> 00:01:45,840
esto, como ha recibido un casting

47
00:01:45,840 --> 00:01:47,599
esto ya sí que es un objeto

48
00:01:47,599 --> 00:01:49,719
de tipo pet, porque se han hecho el casting

49
00:01:49,719 --> 00:01:51,680
a pet, eso ya sí es un objeto

50
00:01:51,680 --> 00:01:53,840
de tipo pet, entonces al ser un objeto

51
00:01:53,840 --> 00:01:55,840
de tipo pet, el compilador

52
00:01:55,840 --> 00:01:57,740
nos deja llamar a todos los

53
00:01:57,740 --> 00:01:58,480
métodos de pet

54
00:01:58,480 --> 00:02:02,020
entre ellos, el de nadar

55
00:02:02,020 --> 00:02:05,800
ah, directamente, no nos deja

56
00:02:05,800 --> 00:02:07,740
llamar a nadar, porque a es

57
00:02:07,740 --> 00:02:09,760
animal, esto es un

58
00:02:09,760 --> 00:02:11,620
tema del compilador, pero después de

59
00:02:11,620 --> 00:02:13,700
haberle hecho el casting, el compilador dice

60
00:02:13,700 --> 00:02:15,600
ah, vale, esto ya es pet

61
00:02:15,600 --> 00:02:17,560
lo has convertido a pet, pues te dejo llamar

62
00:02:17,560 --> 00:02:19,000
a los métodos de pet, que es nadar

63
00:02:19,000 --> 00:02:20,100
vale

64
00:02:20,100 --> 00:02:23,780
aquí en realidad

65
00:02:23,780 --> 00:02:25,560
también abrió

66
00:02:25,560 --> 00:02:27,000
un else, porque a

67
00:02:27,000 --> 00:02:28,719
hay tres opciones ahora mismo

68
00:02:28,719 --> 00:02:31,159
en nuestra aplicación, que se instanciara

69
00:02:31,159 --> 00:02:33,319
como pet, entonces entraríamos

70
00:02:33,319 --> 00:02:35,500
aquí, que se instanciara como perro

71
00:02:35,500 --> 00:02:37,419
o que se instanciara como

72
00:02:37,419 --> 00:02:39,439
animal, la clase animal también se puede

73
00:02:39,439 --> 00:02:39,979
instanciar

74
00:02:39,979 --> 00:02:43,360
entonces a podría ser un animal, podría

75
00:02:43,360 --> 00:02:45,240
venir de haber hecho a igual a new animal

76
00:02:45,240 --> 00:02:46,000
podría venir

77
00:02:46,000 --> 00:02:49,479
entonces en ese caso aquí, pues tiene sentido hacer un else

78
00:02:49,479 --> 00:02:51,340
y que queremos hacer, pues

79
00:02:51,340 --> 00:02:53,379
si no tiene acción el animal

80
00:02:53,379 --> 00:02:55,000
cualquiera, no tiene acción, pues podríamos

81
00:02:55,000 --> 00:02:56,000
poner

82
00:02:57,000 --> 00:03:07,400
el animal no tiene

83
00:03:07,400 --> 00:03:09,719
acción establecida, por ejemplo

84
00:03:09,719 --> 00:03:19,740
vale, entonces en único método

85
00:03:19,740 --> 00:03:21,280
ahora ya

86
00:03:21,280 --> 00:03:23,860
el programa pasa al animal que le dé la gana

87
00:03:23,860 --> 00:03:25,259
y ya está

88
00:03:25,259 --> 00:03:26,420
y pasará lo que sea

89
00:03:27,000 --> 00:03:29,680
vale, vamos a probarlo en el mail

90
00:03:29,680 --> 00:03:33,180
porque esto así visto es feo

91
00:03:33,180 --> 00:03:34,620
ahora veremos si lo podemos arreglar o no

92
00:03:34,620 --> 00:03:36,580
hombre es feo, tanto instan en todo es feo

93
00:03:36,580 --> 00:03:39,000
pero bueno, es un método que está ahí

94
00:03:39,000 --> 00:03:40,280
que una vez hecho

95
00:03:40,280 --> 00:03:43,500
ahora ya lo llamamos desde donde nos dé la gana

96
00:03:43,500 --> 00:03:44,960
con toda la comodidad del mundo

97
00:03:44,960 --> 00:03:45,520
con toda

98
00:03:45,520 --> 00:03:49,039
vale, bueno

99
00:03:49,039 --> 00:03:50,520
esto que hemos escrito aquí está claro, ¿no?

100
00:03:50,699 --> 00:03:51,580
lo que significa

101
00:03:51,580 --> 00:03:54,639
vale, no, está claro

102
00:03:54,639 --> 00:03:56,819
que si no hacemos el castro

103
00:03:57,000 --> 00:03:59,960
no podemos llamar a los métodos

104
00:03:59,960 --> 00:04:00,819
de perro ni de pez

105
00:04:00,819 --> 00:04:02,620
solo podemos llamar a los de animal

106
00:04:02,620 --> 00:04:05,219
y después de hacer el casting

107
00:04:05,219 --> 00:04:07,000
ya sí podemos llamar a los específicos

108
00:04:07,000 --> 00:04:07,939
del objeto que sea

109
00:04:07,939 --> 00:04:10,759
bueno, pues ahora nuestro main

110
00:04:10,759 --> 00:04:11,580
de aquí

111
00:04:11,580 --> 00:04:14,819
sí, Josi, no vayas a llegar puntual

112
00:04:14,819 --> 00:04:15,300
nunca

113
00:04:15,300 --> 00:04:17,680
a ver

114
00:04:17,680 --> 00:04:21,079
por ejemplo

115
00:04:21,079 --> 00:04:22,899
aquí, ahora ya

116
00:04:27,000 --> 00:04:28,019
operaciones

117
00:04:28,019 --> 00:04:29,439
realizar acción

118
00:04:29,439 --> 00:04:32,339
aquí estamos ya en el main

119
00:04:32,339 --> 00:04:34,980
al main ya como esté hecha la clase operaciones

120
00:04:34,980 --> 00:04:36,100
es que le da exactamente igual

121
00:04:36,100 --> 00:04:38,100
porque seguramente la hizo

122
00:04:38,100 --> 00:04:39,959
el de dos plantas más arriba

123
00:04:39,959 --> 00:04:41,959
que ni le conozco ni me interesa cómo la hizo

124
00:04:41,959 --> 00:04:43,060
me da igual

125
00:04:43,060 --> 00:04:46,019
pero yo sé que ahora ya puedo llamar a realizar acción

126
00:04:46,019 --> 00:04:47,079
para cualquier animal

127
00:04:47,079 --> 00:04:48,600
sea perro, sea gato

128
00:04:48,600 --> 00:04:50,079
lo que me dé la gana

129
00:04:50,079 --> 00:04:53,839
que quiero que el que realice la acción sea el perro

130
00:04:53,839 --> 00:04:54,560
pues ala

131
00:04:54,560 --> 00:04:56,839
le paso el perro y estupendo

132
00:04:57,000 --> 00:04:58,180
le he pasado un perro

133
00:04:58,180 --> 00:04:59,220
y realizo acción

134
00:04:59,220 --> 00:05:01,639
que ahora quiero que el que realice acción

135
00:05:01,639 --> 00:05:03,180
sea el pez

136
00:05:03,180 --> 00:05:07,060
pues estupendo

137
00:05:07,060 --> 00:05:08,620
le paso el pez

138
00:05:08,620 --> 00:05:10,439
le paso un objeto instanciado como pez

139
00:05:10,439 --> 00:05:10,860
genial

140
00:05:10,860 --> 00:05:12,980
entonces ahora mismo ya es comodísimo

141
00:05:12,980 --> 00:05:15,319
yo tengo un método de realizar acción

142
00:05:15,319 --> 00:05:16,439
y le paso cualquier animal

143
00:05:16,439 --> 00:05:17,540
el que sea

144
00:05:17,540 --> 00:05:19,139
cualquiera

145
00:05:19,139 --> 00:05:21,339
vale

146
00:05:21,339 --> 00:05:22,379
entonces de nuevo

147
00:05:22,379 --> 00:05:24,100
esto facilita el desarrollo

148
00:05:24,100 --> 00:05:26,339
de aplicaciones

149
00:05:27,000 --> 00:05:29,000
yo tengo un único método

150
00:05:29,000 --> 00:05:31,000
que me dice dame el animal que te dé la gana

151
00:05:31,000 --> 00:05:33,000
y yo ya hago lo que sea con ese animal

152
00:05:33,000 --> 00:05:35,000
dame el que te dé la gana

153
00:05:35,000 --> 00:05:37,000
y yo luego tengo un montón de objetos diferentes

154
00:05:37,000 --> 00:05:39,000
tengo peces, gatos, perros

155
00:05:39,000 --> 00:05:41,000
pero a todos los puedo enviar

156
00:05:41,000 --> 00:05:43,000
al mismo método a todos

157
00:05:43,000 --> 00:05:45,000
cuando no teníamos herencia

158
00:05:45,000 --> 00:05:47,000
yo tenía que tratar

159
00:05:47,000 --> 00:05:49,000
cada animal de forma separada

160
00:05:49,000 --> 00:05:51,000
un método para pasarle el perro

161
00:05:51,000 --> 00:05:53,000
otro método para poder pasarle el gato

162
00:05:53,000 --> 00:05:55,000
otro método para poder pasarle el pez

163
00:05:55,000 --> 00:05:56,180
ahora no

164
00:05:56,180 --> 00:05:59,180
ahora un único método al que le paso

165
00:05:59,180 --> 00:06:00,699
animal, venga, ala

166
00:06:00,699 --> 00:06:01,600
el animal que sea

167
00:06:01,600 --> 00:06:05,579
vale, de hecho vamos a instanciar

168
00:06:05,579 --> 00:06:06,980
un animal normal y corriente

169
00:06:06,980 --> 00:06:08,460
que no se anigue

170
00:06:08,460 --> 00:06:11,879
aquí por ejemplo este

171
00:06:11,879 --> 00:06:15,220
vale y vamos a llamar

172
00:06:15,220 --> 00:06:17,199
a realizar la acción del animal

173
00:06:17,199 --> 00:06:18,899
este normal y corriente

174
00:06:18,899 --> 00:06:20,960
que no es ni gato, ni pez, ni nada

175
00:06:20,960 --> 00:06:23,620
ni perro, ni dromedario

176
00:06:23,620 --> 00:06:24,340
este

177
00:06:26,180 --> 00:06:27,180
vale

178
00:06:27,180 --> 00:06:29,420
pues vamos a ejecutar el código

179
00:06:29,420 --> 00:06:32,879
bueno primero

180
00:06:32,879 --> 00:06:34,959
para no liarme voy a comentar

181
00:06:34,959 --> 00:06:36,400
lo de mostrar las iniciales

182
00:06:36,400 --> 00:06:43,000
vale

183
00:06:43,000 --> 00:06:44,500
y efectivamente

184
00:06:44,500 --> 00:06:47,300
este realizó la acción del perro

185
00:06:47,300 --> 00:06:49,000
al método al que se llamó

186
00:06:49,000 --> 00:06:51,040
fue el que está en la clase perro

187
00:06:51,040 --> 00:06:53,160
sin embargo este realizó la acción

188
00:06:53,160 --> 00:06:53,860
del pez

189
00:06:53,860 --> 00:06:56,240
y este nos dijo

190
00:06:56,240 --> 00:06:56,560
uy

191
00:06:56,560 --> 00:06:59,139
no sé, me has pasado un animal

192
00:06:59,139 --> 00:07:00,060
vale

193
00:07:00,060 --> 00:07:03,040
entonces esto nos permite unificar

194
00:07:03,040 --> 00:07:06,259
si se hace uno un buen diseño

195
00:07:06,259 --> 00:07:08,360
de clases, una buena jerarquía

196
00:07:08,360 --> 00:07:10,540
de clases, luego hacer el main

197
00:07:10,540 --> 00:07:12,319
hacer los programas que ya

198
00:07:12,319 --> 00:07:13,420
ejecutan cosas

199
00:07:13,420 --> 00:07:15,600
son muchísimo más sencillos

200
00:07:15,600 --> 00:07:18,439
si uno hace un buen diseño de clases, una buena jerarquía, etc.

201
00:07:18,540 --> 00:07:19,900
es mucho más sencillo

202
00:07:19,900 --> 00:07:22,460
tener un único método, realizar acción al que le paso el animal

203
00:07:22,460 --> 00:07:23,819
que tener

204
00:07:24,379 --> 00:07:26,759
realizar acción del gato, del perro, del no sé qué

205
00:07:26,759 --> 00:07:27,300
vale

206
00:07:27,300 --> 00:07:29,400
pues para esto se inventó

207
00:07:29,400 --> 00:07:31,400
la herencia, para esto se inventó

208
00:07:31,400 --> 00:07:35,220
bueno pues está claro, ¿no?

209
00:07:35,220 --> 00:07:36,860
la motivación y lo que hay de fondo

210
00:07:36,860 --> 00:07:37,639
de esto

211
00:07:37,639 --> 00:07:39,080
está claro, ¿no?

212
00:07:39,620 --> 00:07:42,180
vale, lo que tenemos es que seguir viendo ahora ya detalles

213
00:07:42,180 --> 00:07:44,160
lo que es ya de escritura de código

214
00:07:44,160 --> 00:07:45,379
detalles de pulido

215
00:07:45,379 --> 00:07:46,960
tenemos que seguirlos viendo

216
00:07:46,960 --> 00:07:49,540
pero entendiendo que hay un detrás

217
00:07:49,540 --> 00:07:50,600
para hacer estas cosas

218
00:07:51,540 --> 00:07:52,600
bueno, digo

219
00:07:53,860 --> 00:07:57,800
tenemos una acción en animal

220
00:07:57,800 --> 00:07:59,160
que es comer

221
00:07:59,160 --> 00:08:02,960
porque nos llama a esa acción

222
00:08:02,960 --> 00:08:05,840
no la hemos llamado en operaciones

223
00:08:05,840 --> 00:08:07,319
bueno, a ver, es que también

224
00:08:07,319 --> 00:08:10,060
bueno, porque aquí estamos viendo, podríamos llamar

225
00:08:10,060 --> 00:08:11,720
bueno, porque aquí lo que estamos viendo

226
00:08:11,720 --> 00:08:12,740
es la acción de

227
00:08:12,740 --> 00:08:15,040
ladrar, o sea, estamos haciendo esto

228
00:08:15,040 --> 00:08:17,840
pero a ver, que lo que queremos es que ahora que el animal

229
00:08:17,840 --> 00:08:19,639
coma, tú puedes llamar al método

230
00:08:19,639 --> 00:08:20,980
comer de cualquiera de ellos

231
00:08:20,980 --> 00:08:23,720
¿vale?

232
00:08:23,860 --> 00:08:25,980
vamos a hacer

233
00:08:25,980 --> 00:08:27,120
que el animal A coma

234
00:08:27,120 --> 00:08:29,520
pues puedes llamar a su método comer

235
00:08:29,520 --> 00:08:31,000
porque comer está en la clase animal

236
00:08:31,000 --> 00:08:34,000
¿vale? y también puede

237
00:08:34,000 --> 00:08:34,820
comer este

238
00:08:34,820 --> 00:08:39,100
¿vale?

239
00:08:39,860 --> 00:08:41,320
porque comer

240
00:08:41,320 --> 00:08:43,259
al estar en la clase animal

241
00:08:43,259 --> 00:08:45,860
lo ha heredado

242
00:08:45,860 --> 00:08:47,039
también la clase perro

243
00:08:47,039 --> 00:08:48,620
¿vale?

244
00:08:49,700 --> 00:08:51,620
y también puede comer el otro

245
00:08:51,620 --> 00:08:51,700
¿vale?

246
00:08:53,860 --> 00:08:54,840
si le da la gana

247
00:08:54,840 --> 00:08:58,240
¿vale? porque como comer está

248
00:08:58,240 --> 00:09:00,060
en la clase animal

249
00:09:00,060 --> 00:09:02,399
pues también lo puede llamar

250
00:09:02,399 --> 00:09:04,419
la subclase

251
00:09:04,419 --> 00:09:09,340
pez

252
00:09:09,340 --> 00:09:12,820
cualquiera lo puede llamar porque comer está en la clase animal

253
00:09:12,820 --> 00:09:13,680
¿vale?

254
00:09:13,700 --> 00:09:16,259
la pregunta sería, pero está lo siguiente antes de que cerremos

255
00:09:16,259 --> 00:09:18,200
esto es, y si yo quiero que coman

256
00:09:18,200 --> 00:09:19,120
de forma distinta

257
00:09:19,120 --> 00:09:21,899
claro, pero esto ya es otra cosa, entonces hay que

258
00:09:21,899 --> 00:09:23,240
sobre escribir, ¿vale?

259
00:09:23,860 --> 00:09:25,379
pero vamos a olvidarnos ahora de esto

260
00:09:25,379 --> 00:09:27,399
vamos a seguir con lo que estábamos

261
00:09:27,399 --> 00:09:29,399
¿vale? bueno, pues entonces

262
00:09:29,399 --> 00:09:31,519
ahora lo que estamos haciendo en concreto es

263
00:09:31,519 --> 00:09:33,379
definir unas acciones para cada animal

264
00:09:33,379 --> 00:09:35,879
y ir viendo, pues bueno, esta situación en concreto

265
00:09:35,879 --> 00:09:36,759
cómo resolverla

266
00:09:36,759 --> 00:09:39,659
¿vale? pues entendido esto, vamos a volver

267
00:09:39,659 --> 00:09:41,060
a nuestro método de aquí

268
00:09:41,060 --> 00:09:43,019
a nuestro método

269
00:09:43,019 --> 00:09:45,860
que ya hemos entendido

270
00:09:45,860 --> 00:09:46,560
cómo funciona

271
00:09:46,560 --> 00:09:49,899
¿vale? pues lo hemos

272
00:09:49,899 --> 00:09:50,539
entendido

273
00:09:50,539 --> 00:09:52,700
pero

274
00:09:53,860 --> 00:09:56,060
vamos a cambiarlo para que no sea tan feo

275
00:09:56,060 --> 00:09:57,080
esto está bien

276
00:09:57,080 --> 00:10:00,560
y de hecho vamos a dejarlo así, vamos a incorporarlo en otro método

277
00:10:00,560 --> 00:10:01,700
otra forma de hacer las cosas

278
00:10:01,700 --> 00:10:03,460
otra forma, esto está bien

279
00:10:03,460 --> 00:10:05,840
y lo vais a ver, obviamente, en mil sitios

280
00:10:05,840 --> 00:10:08,000
así funcionan las cosas, y el instansoft a veces

281
00:10:08,000 --> 00:10:10,060
es que no hay tutía, hay que usarlo

282
00:10:10,060 --> 00:10:12,080
porque uno recibe un objeto

283
00:10:12,080 --> 00:10:13,580
que sabe

284
00:10:13,580 --> 00:10:15,539
que pertenece a una superclase

285
00:10:15,539 --> 00:10:18,039
pero necesita además saber

286
00:10:18,039 --> 00:10:19,680
a qué subclase en particular

287
00:10:19,680 --> 00:10:22,000
entonces ahí es el instansoft

288
00:10:22,000 --> 00:10:22,500
no hay otro

289
00:10:22,500 --> 00:10:23,320
¿vale?

290
00:10:23,860 --> 00:10:26,300
bueno, pero vamos a ver otra forma de diseñar esta misma idea

291
00:10:26,300 --> 00:10:27,759
otra manera de diseñar esta misma idea

292
00:10:27,759 --> 00:10:28,680
que estamos diciendo

293
00:10:28,680 --> 00:10:31,080
de un único método

294
00:10:31,080 --> 00:10:33,300
al que yo le paso al animal

295
00:10:33,300 --> 00:10:34,680
y realice la acción

296
00:10:34,680 --> 00:10:37,000
de cualquiera de los animales

297
00:10:37,000 --> 00:10:39,740
independientemente de si es perro, pues otra forma

298
00:10:39,740 --> 00:10:41,379
otra forma de plantearse esto

299
00:10:41,379 --> 00:10:44,019
bueno, pues uno podría preguntar

300
00:10:44,019 --> 00:10:46,060
oye, esto del instansoft

301
00:10:46,060 --> 00:10:47,279
qué feo

302
00:10:47,279 --> 00:10:49,360
ladrar, nadar, qué feo

303
00:10:49,360 --> 00:10:51,440
y si yo en lugar de

304
00:10:51,440 --> 00:10:53,779
diseñarlo así

305
00:10:53,860 --> 00:10:55,960
me hago un método

306
00:10:55,960 --> 00:10:57,519
¿vale?

307
00:10:57,560 --> 00:10:59,039
me hago un método en cada clase

308
00:10:59,039 --> 00:11:01,200
total, que se llame

309
00:11:01,200 --> 00:11:02,519
realizar su acción

310
00:11:02,519 --> 00:11:04,300
y si se llaman igual

311
00:11:04,300 --> 00:11:07,480
pues entonces no tengo por qué distinguir

312
00:11:07,480 --> 00:11:09,580
no podría pensar, no tengo por qué distinguir

313
00:11:09,580 --> 00:11:11,800
si ladrar, nadar

314
00:11:11,800 --> 00:11:12,580
lo que sea

315
00:11:12,580 --> 00:11:15,279
lo que se hace específicamente en cada clase

316
00:11:15,279 --> 00:11:17,480
lo recojo yo en un método

317
00:11:17,480 --> 00:11:19,320
que se llama igual en cada clase

318
00:11:19,320 --> 00:11:20,399
realizar acción

319
00:11:20,399 --> 00:11:23,480
pues entonces uno pensaría, no tengo por qué

320
00:11:23,480 --> 00:11:24,159
distinguir

321
00:11:24,159 --> 00:11:25,879
me da igual el objeto que sea

322
00:11:25,879 --> 00:11:27,360
llamo a realizar acción

323
00:11:27,360 --> 00:11:29,560
y ya ese realizar acción

324
00:11:29,560 --> 00:11:31,920
dentro de cada clase hará lo que sea

325
00:11:31,920 --> 00:11:33,820
¿no? esa podría ser una cosa

326
00:11:33,820 --> 00:11:34,800
que nos plantearíamos

327
00:11:34,800 --> 00:11:38,180
efectivamente

328
00:11:38,180 --> 00:11:39,899
sí, entonces vamos a incorporar aquí

329
00:11:39,899 --> 00:11:42,139
un método, vamos a cambiar el diseño

330
00:11:42,139 --> 00:11:43,700
y decir, venga, vamos a hacernos

331
00:11:43,700 --> 00:11:45,539
un

332
00:11:45,539 --> 00:11:47,980
realizar acción que se llame igual en todas

333
00:11:47,980 --> 00:11:49,779
en lugar de llamarlo ladrar, nadar

334
00:11:49,779 --> 00:11:51,399
decir, pues para qué complicarnos la vida

335
00:11:51,399 --> 00:11:51,580
¿para qué?

336
00:11:51,580 --> 00:11:51,600
¿para qué?

337
00:11:51,600 --> 00:11:51,659
¿para qué?

338
00:11:51,659 --> 00:11:51,740
¿para qué?

339
00:11:51,740 --> 00:11:51,779
¿para qué?

340
00:11:51,779 --> 00:11:51,820
¿para qué?

341
00:11:51,820 --> 00:11:51,860
¿para qué?

342
00:11:51,860 --> 00:11:51,940
¿para qué?

343
00:11:51,940 --> 00:11:52,000
¿para qué?

344
00:11:52,000 --> 00:11:52,060
¿para qué?

345
00:11:52,060 --> 00:11:52,100
¿para qué?

346
00:11:52,100 --> 00:11:52,139
¿para qué?

347
00:11:52,139 --> 00:11:52,220
¿para qué?

348
00:11:52,220 --> 00:11:52,440
¿para qué?

349
00:11:52,440 --> 00:11:54,240
¿para qué complicárnosla?

350
00:11:57,340 --> 00:11:58,820
vamos a llamar un método

351
00:11:58,820 --> 00:12:00,200
que sea realizar acción

352
00:12:00,200 --> 00:12:02,300
y que en el caso del perro

353
00:12:02,300 --> 00:12:03,340
sea esta

354
00:12:03,340 --> 00:12:05,120
sea ladrar

355
00:12:05,120 --> 00:12:07,260
vale, estupendo

356
00:12:07,260 --> 00:12:11,040
vale, en el caso del perro

357
00:12:11,040 --> 00:12:12,580
es ladrar

358
00:12:12,580 --> 00:12:15,120
es esto

359
00:12:15,120 --> 00:12:16,820
vale

360
00:12:16,820 --> 00:12:19,100
en el caso del pez

361
00:12:22,440 --> 00:12:24,080
en el caso del pez

362
00:12:24,080 --> 00:12:27,000
es esta

363
00:12:27,000 --> 00:12:28,540
es nadar

364
00:12:28,540 --> 00:12:36,840
uy, me sobra la llave

365
00:12:36,840 --> 00:12:40,500
entonces ya

366
00:12:40,500 --> 00:12:42,560
parecería que uno ha arreglado algo

367
00:12:42,560 --> 00:12:43,660
ha facilitado las cosas

368
00:12:43,660 --> 00:12:45,560
parecería que uno las ha facilitado

369
00:12:45,560 --> 00:12:48,660
porque dice, a ver, si mi problema era en este método

370
00:12:48,660 --> 00:12:50,520
mi problema era

371
00:12:50,520 --> 00:12:52,420
que tenía yo que distinguir

372
00:12:52,440 --> 00:12:54,460
si hablaba de perros o peces

373
00:12:54,460 --> 00:12:56,800
para decidir si llamar a ladrar o nadar

374
00:12:56,800 --> 00:12:58,240
si mi problema era ese

375
00:12:58,240 --> 00:13:00,800
pues hombre, si tengo la opción

376
00:13:00,800 --> 00:13:03,080
voy a llamar al método igual

377
00:13:03,080 --> 00:13:04,620
en todas las clases

378
00:13:04,620 --> 00:13:06,440
aunque haga cosas distintas dentro

379
00:13:06,440 --> 00:13:08,660
voy a llamarlo igual en todas las clases

380
00:13:08,660 --> 00:13:10,340
y como tiene el mismo nombre

381
00:13:10,340 --> 00:13:12,260
yo lo llamo con ese nombre

382
00:13:12,260 --> 00:13:15,180
me da igual que sea perro, que sea gato, que sea no sé qué

383
00:13:15,180 --> 00:13:17,540
vale, tendría sentido

384
00:13:17,540 --> 00:13:19,380
planteárselo así

385
00:13:19,380 --> 00:13:20,140
tendría sentido

386
00:13:20,140 --> 00:13:22,280
y es lo que hemos empezado a hacer

387
00:13:22,440 --> 00:13:26,000
y aquí me falta una llave

388
00:13:26,000 --> 00:13:29,640
esta no es

389
00:13:29,640 --> 00:13:30,460
esta sí

390
00:13:30,460 --> 00:13:31,220
vale

391
00:13:31,220 --> 00:13:33,620
bueno, es lo que hemos empezado a hacer

392
00:13:33,620 --> 00:13:34,720
y tendría todo el sentido del mundo

393
00:13:34,720 --> 00:13:35,740
vale, pues vamos a

394
00:13:35,740 --> 00:13:36,740
para no borrar este método

395
00:13:36,740 --> 00:13:38,400
vamos a hacernos otra versión de este método

396
00:13:38,400 --> 00:13:40,240
realizar acción al que se le pasa un animal

397
00:13:40,240 --> 00:13:43,500
otra versión que tenga en cuenta esto

398
00:13:43,500 --> 00:13:44,460
ahora que hemos hecho

399
00:13:44,460 --> 00:13:50,180
realizar acción

400
00:13:50,180 --> 00:13:51,900
vale

401
00:13:52,440 --> 00:13:54,200
versión 2

402
00:13:54,200 --> 00:13:57,380
otra versión

403
00:13:57,380 --> 00:13:58,220
de realizar acción

404
00:13:58,220 --> 00:14:00,180
teniendo en cuenta ahora ese método que acabamos de hacer

405
00:14:00,180 --> 00:14:02,680
entonces uno tendería a pensar

406
00:14:02,680 --> 00:14:04,440
a ver, me da igual

407
00:14:04,440 --> 00:14:07,660
si ese animal es perro, pez, gato

408
00:14:07,660 --> 00:14:10,260
porque pertenezca a la clase que pertenezca

409
00:14:10,260 --> 00:14:12,700
según el diseño que yo he hecho

410
00:14:12,700 --> 00:14:15,000
hay un método que se llama igual en todas

411
00:14:15,000 --> 00:14:16,440
que es realizar acción

412
00:14:16,440 --> 00:14:17,180
que realiza la acción

413
00:14:17,180 --> 00:14:19,700
con lo cual la llamada que tenemos que hacer

414
00:14:19,700 --> 00:14:20,380
es la misma

415
00:14:20,380 --> 00:14:22,420
sea perro, sea gato, sea no sé qué

416
00:14:22,440 --> 00:14:23,440
sea gato, sea pez

417
00:14:23,440 --> 00:14:24,640
entonces, ¿no?

418
00:14:24,800 --> 00:14:26,920
para eso hemos hecho un método igual en todas las clases

419
00:14:26,920 --> 00:14:28,180
entonces uno diría

420
00:14:28,180 --> 00:14:29,120
pues magnífico

421
00:14:29,120 --> 00:14:29,880
entonces me da igual

422
00:14:29,880 --> 00:14:31,120
ah, me da igual lo que sea

423
00:14:31,120 --> 00:14:33,400
yo sé que sea perro

424
00:14:33,400 --> 00:14:35,360
sea gato, sea lo que sea

425
00:14:35,360 --> 00:14:37,700
tengo mi método

426
00:14:37,700 --> 00:14:39,400
realizar acción en todas ellas

427
00:14:39,400 --> 00:14:40,960
en pez

428
00:14:40,960 --> 00:14:42,020
hará esto

429
00:14:42,020 --> 00:14:44,100
en perro hará esto

430
00:14:44,100 --> 00:14:45,380
en gato hará lo que sea

431
00:14:45,380 --> 00:14:46,440
pero la tengo en todas

432
00:14:46,440 --> 00:14:48,100
para eso lo hemos hecho

433
00:14:48,100 --> 00:14:48,520
¿no?

434
00:14:49,280 --> 00:14:50,140
entonces uno hace

435
00:14:50,140 --> 00:14:52,020
pues venga, lo llamo y tan ricamente

436
00:14:52,440 --> 00:14:54,640
pero no puede

437
00:14:54,640 --> 00:14:56,080
el compilador de nuevo

438
00:14:56,080 --> 00:14:56,880
que es el que

439
00:14:56,880 --> 00:14:58,800
está mirando

440
00:14:58,800 --> 00:15:01,480
que todas las reglas del juego sintáctico

441
00:15:01,480 --> 00:15:03,700
al compilador solo le importan las sintaxis

442
00:15:03,700 --> 00:15:05,780
no le importa la ejecución

443
00:15:05,780 --> 00:15:07,980
le importa que todas las reglas sintácticas

444
00:15:07,980 --> 00:15:09,980
estén cubiertas

445
00:15:09,980 --> 00:15:12,120
pues el compilador que es el que mira

446
00:15:12,120 --> 00:15:13,140
las reglas del juego dice

447
00:15:13,140 --> 00:15:13,920
no

448
00:15:13,920 --> 00:15:17,260
¿por qué nos dice que no?

449
00:15:22,440 --> 00:15:25,320
si, realizar acción

450
00:15:25,320 --> 00:15:25,920
se llama

451
00:15:25,920 --> 00:15:27,680
en pez se llama

452
00:15:27,680 --> 00:15:32,280
se llama realizar acción

453
00:15:32,280 --> 00:15:33,220
en pez

454
00:15:33,220 --> 00:15:34,700
y en perro se llama

455
00:15:34,700 --> 00:15:36,160
realizar acción

456
00:15:36,160 --> 00:15:37,500
o sea, el método se llama igual en todas

457
00:15:37,500 --> 00:15:40,700
no hombre, no, pero este es

458
00:15:40,700 --> 00:15:42,840
ya, a ver

459
00:15:42,840 --> 00:15:45,040
sí, pero este es el método

460
00:15:45,040 --> 00:15:46,220
a ver, tienes razón

461
00:15:46,220 --> 00:15:48,880
pero este método es el método de la clase operaciones

462
00:15:48,880 --> 00:15:50,280
y este es el de la clase animal

463
00:15:50,280 --> 00:15:52,320
bueno, espera, vamos a cambiarle de nombres

464
00:15:52,320 --> 00:15:52,420
¿qué es el método de la clase operaciones?

465
00:15:52,440 --> 00:15:52,720
si

466
00:15:52,720 --> 00:15:56,740
para que sea más claro

467
00:15:56,740 --> 00:15:58,520
pero vamos, que están en diferentes clases

468
00:15:58,520 --> 00:15:59,620
da igual que se llaman igual

469
00:15:59,620 --> 00:16:02,240
vamos a cambiarle si quieres

470
00:16:02,240 --> 00:16:04,300
a realizar acción del animal

471
00:16:04,300 --> 00:16:06,280
para que

472
00:16:06,280 --> 00:16:08,280
realizar acción del animal

473
00:16:08,280 --> 00:16:10,660
aquí

474
00:16:10,660 --> 00:16:12,380
ahora este

475
00:16:12,380 --> 00:16:14,300
realizar acción del animal

476
00:16:14,300 --> 00:16:16,400
aquí

477
00:16:16,400 --> 00:16:20,520
y ahora entonces este tiene que llamar

478
00:16:20,520 --> 00:16:21,780
a realizar acción del animal

479
00:16:22,440 --> 00:16:23,240
vale

480
00:16:23,240 --> 00:16:26,160
entonces todas las clases tienen un método

481
00:16:26,160 --> 00:16:27,700
que es realizar acción del animal

482
00:16:27,700 --> 00:16:29,540
la que sea, y cada uno hace lo suyo

483
00:16:29,540 --> 00:16:32,460
entonces me da igual que hace a gato, perro

484
00:16:32,460 --> 00:16:33,680
lo que sea, me da igual

485
00:16:33,680 --> 00:16:36,520
sé que va a tener un método

486
00:16:36,520 --> 00:16:38,700
que se llama realizar acción del animal

487
00:16:38,700 --> 00:16:39,760
al que yo quiero llamar

488
00:16:39,760 --> 00:16:42,260
entonces uno pensaría que

489
00:16:42,260 --> 00:16:44,480
uno tiene que distinguir, le da lo mismo, llama a este

490
00:16:44,480 --> 00:16:46,920
y el compilador que es el que vela por las reglas del juego

491
00:16:46,920 --> 00:16:48,440
sigue diciendo

492
00:16:48,440 --> 00:16:49,800
no puedes

493
00:16:49,800 --> 00:16:51,740
¿por qué no puedes?

494
00:16:52,440 --> 00:16:55,020
claro

495
00:16:55,020 --> 00:16:56,840
vale, esto ya surgió el otro día

496
00:16:56,840 --> 00:16:57,860
porque el compilador

497
00:16:57,860 --> 00:17:00,200
mira esto y dice

498
00:17:00,200 --> 00:17:01,660
ah, ¿de dónde viene?

499
00:17:02,360 --> 00:17:05,080
se va hacia arriba hasta que encuentra la declaración

500
00:17:05,080 --> 00:17:07,279
él sigue unas reglas muy claras

501
00:17:07,279 --> 00:17:08,720
o sea, programar un compilador

502
00:17:08,720 --> 00:17:10,519
es sencillísimo

503
00:17:10,519 --> 00:17:12,480
es cogerte las

504
00:17:12,480 --> 00:17:14,880
1500 reglas sintácticas que tiene

505
00:17:14,880 --> 00:17:15,860
y programarlas

506
00:17:15,860 --> 00:17:19,039
es un ejercicio básico de la carrera

507
00:17:19,039 --> 00:17:21,440
hazme el compilador del lenguaje patatín

508
00:17:21,440 --> 00:17:22,240
porque el compilador

509
00:17:22,240 --> 00:17:24,240
sigue sus reglas sotacayo y rey

510
00:17:24,240 --> 00:17:27,240
el compilador, veo aquí una referencia

511
00:17:27,240 --> 00:17:29,240
empieza a ir linas hacia arriba

512
00:17:29,240 --> 00:17:31,240
hasta que encuentra la declaración

513
00:17:31,240 --> 00:17:33,240
y dice animal

514
00:17:33,240 --> 00:17:35,240
vamos a ver qué hace

515
00:17:35,240 --> 00:17:37,240
a ver si realizar acción está en animal

516
00:17:37,240 --> 00:17:39,240
vamos a ver si está

517
00:17:39,240 --> 00:17:41,240
y en animal no está

518
00:17:41,240 --> 00:17:43,240
y te dice, lo siento, no puedes

519
00:17:43,240 --> 00:17:45,240
vale, entonces

520
00:17:45,240 --> 00:17:47,240
¿cuál es la solución? efectivamente

521
00:17:47,240 --> 00:17:49,240
la única solución posible

522
00:17:49,240 --> 00:17:51,859
la única solución posible

523
00:17:51,860 --> 00:17:53,860
para poder dejar este método así

524
00:17:53,860 --> 00:17:55,860
tan bonito y tan cómodo

525
00:17:55,860 --> 00:17:58,860
sin instance of y sin nada

526
00:17:58,860 --> 00:18:00,860
declarar ese método en la superclase

527
00:18:00,860 --> 00:18:02,860
¿verdad?

528
00:18:02,860 --> 00:18:04,860
estamos en realidad repasando lo del otro día

529
00:18:04,860 --> 00:18:06,860
en una aplicación más pequeñita para no perdernos

530
00:18:06,860 --> 00:18:08,860
entonces

531
00:18:08,860 --> 00:18:10,860
vamos a declarar, realizar acción

532
00:18:10,860 --> 00:18:12,860
del animal aquí

533
00:18:21,860 --> 00:18:25,860
realizar acción del animal

534
00:18:27,860 --> 00:18:29,860
claro, yo la declaro aquí

535
00:18:31,860 --> 00:18:33,860
la declaro aquí

536
00:18:33,860 --> 00:18:35,860
vale, el compilador ya se queda

537
00:18:35,860 --> 00:18:37,860
encantado de la vida, dice genial

538
00:18:37,860 --> 00:18:39,860
¿a qué es? a es una referencia de tipo animal

539
00:18:39,860 --> 00:18:41,860
entonces él se va a animal automáticamente

540
00:18:41,860 --> 00:18:43,860
porque a está declarado como animal

541
00:18:43,860 --> 00:18:45,860
se va a animal

542
00:18:45,860 --> 00:18:47,860
animal tiene realizar acción

543
00:18:47,860 --> 00:18:49,860
va mirando

544
00:18:49,860 --> 00:18:51,860
uy sí, la tiene

545
00:18:51,860 --> 00:18:53,860
y ya está, y se acabó

546
00:18:53,860 --> 00:18:55,860
el compilador ha acabado su tarea, ya no mira más

547
00:18:55,860 --> 00:18:57,860
ya está, dice, has cumplido

548
00:18:57,860 --> 00:18:59,860
las reglas del juego, fenomenal, te dejo seguir

549
00:19:01,860 --> 00:19:03,860
vale, ahora ya, claro, entra nuestra cabeza a pensar

550
00:19:03,860 --> 00:19:05,860
y decimos, vale

551
00:19:05,860 --> 00:19:07,860
me has obligado a declarar

552
00:19:07,860 --> 00:19:09,860
este método para poder llamarlo

553
00:19:09,860 --> 00:19:11,860
pero cuando lo hemos declarado

554
00:19:11,860 --> 00:19:13,860
pues nos surge la

555
00:19:13,860 --> 00:19:15,860
gran pregunta

556
00:19:15,860 --> 00:19:17,860
y es, ¿qué código metemos ahí?

557
00:19:17,860 --> 00:19:19,860
¿estoy en la clase animal?

558
00:19:19,860 --> 00:19:21,860
¿no sé qué hay que hacer?

559
00:19:21,860 --> 00:19:23,860
si hay que nadar, si hay que maullar

560
00:19:23,860 --> 00:19:25,860
si hay que correr, si hay que comer, si hay que nadar

561
00:19:25,860 --> 00:19:27,860
no tengo ni idea

562
00:19:27,860 --> 00:19:29,860
¿qué código metemos ahí?

563
00:19:29,860 --> 00:19:31,860
pues no metemos ninguno

564
00:19:31,860 --> 00:19:33,860
lo dejamos en blanco

565
00:19:33,860 --> 00:19:35,860
vale, no metemos nada

566
00:19:35,860 --> 00:19:37,860
lo dejamos en blanco

567
00:19:37,860 --> 00:19:39,860
claro

568
00:19:39,860 --> 00:19:41,860
entonces, ahora ya cada clase

569
00:19:41,860 --> 00:19:43,860
que hereda

570
00:19:43,860 --> 00:19:45,860
que lo sobrescriba

571
00:19:45,860 --> 00:19:47,860
vale

572
00:19:47,860 --> 00:19:49,860
esa es la famosa sobrescritura

573
00:19:49,860 --> 00:19:51,860
de métodos, la sobrescritura

574
00:19:51,860 --> 00:19:53,860
pues overwrite

575
00:19:53,860 --> 00:19:55,860
cuando lo miráis en manuales

576
00:19:55,860 --> 00:19:57,860
que en ciertas condiciones

577
00:19:57,860 --> 00:19:59,860
que veremos dentro de un poquito

578
00:19:59,860 --> 00:20:01,860
hay que anotarlo, pero eso ya lo veremos más adelante

579
00:20:01,860 --> 00:20:03,860
esa es la sobrescritura

580
00:20:03,860 --> 00:20:05,860
entonces, ahora ya

581
00:20:05,860 --> 00:20:07,860
cada clase que quiera realizar una acción propia

582
00:20:07,860 --> 00:20:09,860
lo sobrescribe

583
00:20:09,860 --> 00:20:11,860
que yo me hago una clase

584
00:20:11,860 --> 00:20:13,860
que no quiero que tenga una realizar acción propia

585
00:20:13,860 --> 00:20:15,860
que no la tenga definida

586
00:20:15,860 --> 00:20:17,860
no la sobrescribo, entonces hereda el blanco

587
00:20:17,860 --> 00:20:19,860
hereda el vacío

588
00:20:19,860 --> 00:20:21,860
y cuando se llame para ese animal un realizar acción

589
00:20:21,860 --> 00:20:23,860
del animal, no hará nada

590
00:20:23,860 --> 00:20:25,860
pero para cualquier otra subclase

591
00:20:25,860 --> 00:20:27,860
que yo quiero que haga algo en concreto

592
00:20:27,860 --> 00:20:29,860
lo sobrescribe

593
00:20:29,860 --> 00:20:31,860
y sobrescribirlo significa

594
00:20:31,860 --> 00:20:33,860
hacer otro método

595
00:20:33,860 --> 00:20:35,860
con la misma cabecera, la misma

596
00:20:35,860 --> 00:20:37,860
idéntica, hacer otro método con la misma

597
00:20:37,860 --> 00:20:39,860
y ya poner el código que a mi me dé la gana

598
00:20:39,860 --> 00:20:41,860
entonces, este método

599
00:20:41,860 --> 00:20:43,860
sobrescribe al de arriba

600
00:20:43,860 --> 00:20:45,860
lo sustituye

601
00:20:45,860 --> 00:20:47,860
directamente, lo sustituye

602
00:20:47,860 --> 00:20:49,860
y el de arriba

603
00:20:49,860 --> 00:20:51,860
ya ha desaparecido

604
00:20:51,860 --> 00:20:53,860
para la clase perro

605
00:20:53,860 --> 00:20:55,860
ya ha desaparecido

606
00:20:55,860 --> 00:20:57,860
y en la clase perro igual

607
00:20:57,860 --> 00:20:59,860
este sobrescribe

608
00:20:59,860 --> 00:21:01,860
al de arriba

609
00:21:01,860 --> 00:21:03,860
y en la clase perro

610
00:21:03,860 --> 00:21:05,860
ya el de arriba

611
00:21:05,860 --> 00:21:07,860
no existe, porque ha quedado sobrescrito

612
00:21:07,860 --> 00:21:09,860
por esto

613
00:21:09,860 --> 00:21:11,860
entonces la superclase

614
00:21:11,860 --> 00:21:13,860
te da una plantilla de cosas

615
00:21:13,860 --> 00:21:15,860
que por ahora están abiertas

616
00:21:15,860 --> 00:21:17,860
y las subclases

617
00:21:17,860 --> 00:21:19,860
las definen

618
00:21:19,860 --> 00:21:21,860
y ahora ya esto ya si que es cómodo

619
00:21:21,860 --> 00:21:23,860
porque yo me despreocupo

620
00:21:23,860 --> 00:21:25,860
y digo, me da igual el animal que sea

621
00:21:25,860 --> 00:21:27,860
me da lo mismo

622
00:21:27,860 --> 00:21:29,860
yo llamo a realizar acción del animal

623
00:21:29,860 --> 00:21:31,860
y ahora ya cuando entramos a ejecutar

624
00:21:31,860 --> 00:21:33,860
que fue con lo que nos quedamos al final

625
00:21:33,860 --> 00:21:35,860
el viernes pasado

626
00:21:35,860 --> 00:21:37,860
cuando entramos a ejecutar

627
00:21:37,860 --> 00:21:39,860
la máquina virtual

628
00:21:39,860 --> 00:21:41,860
ella ya si que se hace preguntas

629
00:21:41,860 --> 00:21:43,860
no es como el compilador

630
00:21:43,860 --> 00:21:45,860
que se limita a mirar el código

631
00:21:45,860 --> 00:21:47,860
a ver si encaja o no encaja

632
00:21:47,860 --> 00:21:49,860
la máquina virtual ya dice

633
00:21:49,860 --> 00:21:51,860
vamos a ver

634
00:21:51,860 --> 00:21:53,860
tiene que llamar a realizar acción

635
00:21:53,860 --> 00:21:55,860
ahora ya estoy ejecutando

636
00:21:55,860 --> 00:21:57,860
no estoy mirando a ver si la sintaxis es correcta

637
00:21:57,860 --> 00:21:59,860
yo soy la máquina virtual, no soy el compilador

638
00:21:59,860 --> 00:22:01,860
y tengo que ejecutar

639
00:22:01,860 --> 00:22:03,860
objeto A

640
00:22:03,860 --> 00:22:05,860
quieres hacer realizar acción

641
00:22:05,860 --> 00:22:07,860
vale, tu objeto A que eres

642
00:22:07,860 --> 00:22:09,860
y tendrá que ver como se instanció

643
00:22:09,860 --> 00:22:11,860
la propia máquina virtual

644
00:22:11,860 --> 00:22:13,860
es la que se hace internamente

645
00:22:13,860 --> 00:22:15,860
la máquina virtual dice

646
00:22:15,860 --> 00:22:17,860
tu A que eres

647
00:22:17,860 --> 00:22:19,860
va mirando a ver el new que se hizo

648
00:22:19,860 --> 00:22:21,860
exacto que eres

649
00:22:21,860 --> 00:22:23,860
y cuando ya mira

650
00:22:23,860 --> 00:22:25,860
ya haya averiguado lo que es

651
00:22:25,860 --> 00:22:27,860
porque esto ya es un objeto que exista

652
00:22:27,860 --> 00:22:29,860
estamos en tiempo de ejecución

653
00:22:29,860 --> 00:22:31,860
ya es un objeto que exista

654
00:22:31,860 --> 00:22:33,860
pues cuando ya sepa ese objeto que ya existe

655
00:22:33,860 --> 00:22:35,860
como se creo

656
00:22:35,860 --> 00:22:37,860
pues se va al método en concreto

657
00:22:37,860 --> 00:22:39,860
se va al método en concreto

658
00:22:39,860 --> 00:22:41,860
entonces por eso aquí

659
00:22:41,860 --> 00:22:43,860
en nuestro main

660
00:22:43,860 --> 00:22:45,860
si hacemos la versión 2

661
00:22:47,860 --> 00:22:49,860
del otro

662
00:22:49,860 --> 00:22:51,860
vale

663
00:22:51,860 --> 00:22:53,860
a ver

664
00:22:57,860 --> 00:22:59,860
realizar acción

665
00:22:59,860 --> 00:23:01,860
versión 2

666
00:23:01,860 --> 00:23:03,860
de A1

667
00:23:03,860 --> 00:23:05,860
realizar acción versión 2

668
00:23:05,860 --> 00:23:07,860
de A1 que hará

669
00:23:07,860 --> 00:23:09,860
pues llamará

670
00:23:09,860 --> 00:23:11,860
a la versión de realizar acción del animal

671
00:23:11,860 --> 00:23:13,860
que hay

672
00:23:13,860 --> 00:23:15,860
en la clase a la que pertenece A1

673
00:23:15,860 --> 00:23:17,860
A1 pertenece a que

674
00:23:17,860 --> 00:23:19,860
a perro

675
00:23:19,860 --> 00:23:21,860
como A1 pertenece a perro

676
00:23:21,860 --> 00:23:23,860
perdón estoy

677
00:23:23,860 --> 00:23:25,860
donde estoy aquí

678
00:23:25,860 --> 00:23:27,860
como A1 pertenece a perro

679
00:23:27,860 --> 00:23:29,860
pues esta llamada

680
00:23:29,860 --> 00:23:31,860
será la de la clase perro

681
00:23:31,860 --> 00:23:33,860
cuando lleguemos

682
00:23:33,860 --> 00:23:35,860
aquí

683
00:23:35,860 --> 00:23:37,860
a la versión 2

684
00:23:37,860 --> 00:23:39,860
la máquina virtual mirará este objeto de que clase es

685
00:23:39,860 --> 00:23:41,860
verá que

686
00:23:41,860 --> 00:23:43,860
este objeto pertenece a la clase pez

687
00:23:43,860 --> 00:23:45,860
como

688
00:23:45,860 --> 00:23:47,860
se instanció como clase pez

689
00:23:47,860 --> 00:23:49,860
llamará al realizar acción

690
00:23:49,860 --> 00:23:51,860
del animal que esté en la clase pez

691
00:23:51,860 --> 00:23:53,860
este de aquí

692
00:23:53,860 --> 00:23:55,860
A

693
00:23:55,860 --> 00:23:57,860
este de aquí

694
00:23:57,860 --> 00:23:59,860
perdón ponemos aquí la versión 2

695
00:23:59,860 --> 00:24:01,860
este que va a hacer

696
00:24:03,860 --> 00:24:05,860
vamos a ver que hace

697
00:24:05,860 --> 00:24:07,860
este

698
00:24:07,860 --> 00:24:09,860
mirará

699
00:24:09,860 --> 00:24:11,860
de como se instanció

700
00:24:11,860 --> 00:24:13,860
este de aquí A

701
00:24:13,860 --> 00:24:15,860
este se instanció

702
00:24:15,860 --> 00:24:17,860
como animal

703
00:24:17,860 --> 00:24:19,860
se instanció como animal

704
00:24:19,860 --> 00:24:21,860
llamará

705
00:24:21,860 --> 00:24:23,860
a realizar acción del animal

706
00:24:23,860 --> 00:24:25,860
la que hay en la clase animal

707
00:24:25,860 --> 00:24:27,860
que no hace nada

708
00:24:27,860 --> 00:24:29,860
entonces no hará nada

709
00:24:29,860 --> 00:24:31,860
no hará nada

710
00:24:31,860 --> 00:24:33,860
entonces

711
00:24:33,860 --> 00:24:35,860
este me mostrará la acción del

712
00:24:35,860 --> 00:24:37,860
del perro

713
00:24:37,860 --> 00:24:39,860
este me mostrará del gato

714
00:24:39,860 --> 00:24:41,860
y luego no veré nada más

715
00:24:41,860 --> 00:24:43,860
no veremos nada más

716
00:24:43,860 --> 00:24:45,860
vale

717
00:24:45,860 --> 00:24:47,860
y efectivamente eso es lo que ha hecho

718
00:24:47,860 --> 00:24:49,860
y efectivamente eso es lo que ha hecho

719
00:24:49,860 --> 00:24:51,860
esto vale

720
00:24:51,860 --> 00:24:53,860
lo de arriba eran las llamadas a la otra versión

721
00:24:53,860 --> 00:24:55,860
pues es justo lo que ha hecho

722
00:24:55,860 --> 00:24:57,860
vale

723
00:24:57,860 --> 00:24:59,860
entonces

724
00:24:59,860 --> 00:25:01,860
es infinitamente más cómodo

725
00:25:01,860 --> 00:25:03,860
trabajar así

726
00:25:03,860 --> 00:25:05,860
pues entonces

727
00:25:05,860 --> 00:25:07,860
la sobrescritura

728
00:25:07,860 --> 00:25:09,860
y el polimorfismo

729
00:25:09,860 --> 00:25:11,860
son dos términos

730
00:25:11,860 --> 00:25:13,860
que van juntos

731
00:25:13,860 --> 00:25:15,860
que pasa cuando sobrescribimos

732
00:25:15,860 --> 00:25:17,860
métodos

733
00:25:17,860 --> 00:25:19,860
un método que está en la superclase

734
00:25:19,860 --> 00:25:21,860
y lo sobrescribimos

735
00:25:21,860 --> 00:25:23,860
de forma distinta en cada subclase

736
00:25:23,860 --> 00:25:25,860
pues que lo estamos haciendo polimorfo

737
00:25:25,860 --> 00:25:27,860
o lo que es lo mismo

738
00:25:27,860 --> 00:25:29,860
le estamos dando formas distintas

739
00:25:29,860 --> 00:25:31,860
en función de la clase en la que está

740
00:25:31,860 --> 00:25:33,860
lo estamos haciendo polimorfo

741
00:25:33,860 --> 00:25:35,860
le estamos dando formas distintas

742
00:25:35,860 --> 00:25:37,860
entonces

743
00:25:37,860 --> 00:25:39,860
esta llamada de aquí

744
00:25:39,860 --> 00:25:41,860
esta llamada

745
00:25:41,860 --> 00:25:43,860
que parece que es la llamada

746
00:25:43,860 --> 00:25:45,860
un único método

747
00:25:45,860 --> 00:25:47,860
en realidad es

748
00:25:47,860 --> 00:25:49,860
a la del perro si es que A es un perro

749
00:25:49,860 --> 00:25:51,860
o a la del gato

750
00:25:51,860 --> 00:25:53,860
o a la del pez si es que A es un pez

751
00:25:53,860 --> 00:25:55,860
entonces aquí estamos haciendo polimorfismo

752
00:25:55,860 --> 00:25:57,860
porque este método

753
00:25:57,860 --> 00:25:59,860
adopta diferentes formas

754
00:25:59,860 --> 00:26:01,860
y las formas que adopta

755
00:26:01,860 --> 00:26:03,860
dependerá de si A es perro

756
00:26:03,860 --> 00:26:05,860
es gato

757
00:26:05,860 --> 00:26:07,860
es no sé qué

758
00:26:07,860 --> 00:26:09,860
vale

759
00:26:09,860 --> 00:26:11,860
pues a eso se le llama polimorfismo

760
00:26:11,860 --> 00:26:13,860
aquí un método

761
00:26:13,860 --> 00:26:15,860
al que tú le llamas con un nombre único

762
00:26:15,860 --> 00:26:17,860
este nombre

763
00:26:17,860 --> 00:26:19,860
pues o te está haciendo este código

764
00:26:19,860 --> 00:26:21,860
se llama polimorfismo

765
00:26:21,860 --> 00:26:23,860
y cómo se consigue el polimorfismo

766
00:26:23,860 --> 00:26:25,860
se consigue sobreescribiendo métodos

767
00:26:25,860 --> 00:26:27,860
haciendo esto

768
00:26:27,860 --> 00:26:29,860
si yo este método lo sobreescribo aquí

769
00:26:29,860 --> 00:26:31,860
y lo sobreescribo aquí

770
00:26:31,860 --> 00:26:33,860
pues le estoy dando diferentes formas

771
00:26:33,860 --> 00:26:35,860
vale

772
00:26:35,860 --> 00:26:37,860
vale pues esto es

773
00:26:37,860 --> 00:26:39,860
esta es la motivación

774
00:26:39,860 --> 00:26:41,860
y lo que está en la base de la herencia

775
00:26:41,860 --> 00:26:43,860
para esto sirve

776
00:26:43,860 --> 00:26:45,860
no tanto porque al heredar

777
00:26:45,860 --> 00:26:47,860
yo hay un código que directamente

778
00:26:47,860 --> 00:26:49,860
estoy como haciendo un copia y pega y ahorrándomelo

779
00:26:49,860 --> 00:26:51,860
eso en sí mismo no es ninguna motivación

780
00:26:51,860 --> 00:26:53,860
en total copiar y pegar

781
00:26:53,860 --> 00:26:55,860
tampoco se tarda tanto

782
00:26:55,860 --> 00:26:57,860
no es esa la motivación de la herencia

783
00:26:57,860 --> 00:26:59,860
sino esta otra

784
00:26:59,860 --> 00:27:01,860
la comodidad de poder hacer cosas como esta

785
00:27:01,860 --> 00:27:03,860
vale

786
00:27:03,860 --> 00:27:05,860
un único método

787
00:27:05,860 --> 00:27:07,860
al que le cae cualquier clase

788
00:27:07,860 --> 00:27:09,860
cualquier animal cualquier cosa

789
00:27:09,860 --> 00:27:11,860
y hace

790
00:27:11,860 --> 00:27:13,860
lo que toque

791
00:27:15,860 --> 00:27:17,860
si no tuviéramos la herencia

792
00:27:17,860 --> 00:27:19,860
tendríamos que trabajar por separado con los gatos

793
00:27:19,860 --> 00:27:21,860
los perros

794
00:27:21,860 --> 00:27:23,860
y aquí

795
00:27:23,860 --> 00:27:25,860
ala todo junto

796
00:27:25,860 --> 00:27:27,860
en dos líneas de código

797
00:27:27,860 --> 00:27:29,860
vale solamente porque

798
00:27:29,860 --> 00:27:31,860
hay una jerarquía y además hay

799
00:27:31,860 --> 00:27:33,860
sobre escritura de métodos y polimorfismo

800
00:27:33,860 --> 00:27:35,860
pues lo hemos conseguido en eso

801
00:27:35,860 --> 00:27:37,860
y si no hubiera esto las aplicaciones serían

802
00:27:37,860 --> 00:27:39,860
inmanejables

803
00:27:39,860 --> 00:27:41,860
si no hubiera esto

804
00:27:41,860 --> 00:27:43,860
bueno claro claro

805
00:27:47,860 --> 00:27:49,860
vale

806
00:27:49,860 --> 00:27:51,860
lo que nos produce

807
00:27:51,860 --> 00:27:53,860
un poco de ansiedad

808
00:27:53,860 --> 00:27:55,860
es esto de tener que dejar ahí un método vacío

809
00:27:55,860 --> 00:27:57,860
es bastante feo

810
00:27:57,860 --> 00:27:59,860
no

811
00:27:59,860 --> 00:28:01,860
no parecimos

812
00:28:01,860 --> 00:28:03,860
convencidos de que eso

813
00:28:03,860 --> 00:28:05,860
no sea feo

814
00:28:05,860 --> 00:28:07,860
hombre es feo

815
00:28:07,860 --> 00:28:09,860
es decir jolín yo parece que voy a hacer un método

816
00:28:09,860 --> 00:28:11,860
pero como no tengo ni idea de lo que escribir ahí

817
00:28:11,860 --> 00:28:13,860
porque es que no tiene sentido

818
00:28:13,860 --> 00:28:15,860
porque es un animal genérico y no tiene acción

819
00:28:15,860 --> 00:28:17,860
pues lo dejo vacío

820
00:28:17,860 --> 00:28:19,860
pero lo hemos tenido que poner

821
00:28:19,860 --> 00:28:21,860
porque si no lo poníamos

822
00:28:21,860 --> 00:28:23,860
el compilador aquí

823
00:28:23,860 --> 00:28:25,860
nos decía eh no

824
00:28:25,860 --> 00:28:27,860
no la razón de ponerlo

825
00:28:27,860 --> 00:28:29,860
era porque el compilador nos decía

826
00:28:29,860 --> 00:28:31,860
lo siento

827
00:28:31,860 --> 00:28:33,860
a está declarado

828
00:28:33,860 --> 00:28:35,860
como animal como esta instancia me da igual

829
00:28:35,860 --> 00:28:37,860
porque las instancias se hacen en tiempo

830
00:28:37,860 --> 00:28:39,860
de ejecución cuando el programa arranca

831
00:28:39,860 --> 00:28:41,860
en el compilador no hay nada arrancado

832
00:28:41,860 --> 00:28:43,860
ni tiempo de ejecución ni nada

833
00:28:43,860 --> 00:28:45,860
el compilador dice perdona a

834
00:28:45,860 --> 00:28:47,860
está declarado como animal

835
00:28:47,860 --> 00:28:49,860
pues lo siento mucho tiene que haber

836
00:28:49,860 --> 00:28:51,860
un método de realizar el animal

837
00:28:51,860 --> 00:28:53,860
entonces lo hemos hecho por eso

838
00:28:53,860 --> 00:28:55,860
es que si no no hay tutía es imposible hacer esto

839
00:28:55,860 --> 00:28:57,860
y al hacerlo nos hemos

840
00:28:57,860 --> 00:28:59,860
encontrado que hemos tenido que hacer esta cosa tan fea

841
00:29:01,860 --> 00:29:03,860
de dejarlo así

842
00:29:03,860 --> 00:29:05,860
eh vacío

843
00:29:05,860 --> 00:29:07,860
y hombre esto es feo

844
00:29:07,860 --> 00:29:09,860
vale esto es feo

845
00:29:11,860 --> 00:29:13,860
bueno pero

846
00:29:13,860 --> 00:29:15,860
es que

847
00:29:15,860 --> 00:29:17,860
ocurre que

848
00:29:17,860 --> 00:29:19,860
hay clases en las cuales

849
00:29:19,860 --> 00:29:21,860
el método todavía no se puede definir

850
00:29:21,860 --> 00:29:23,860
porque no tengo la información suficiente

851
00:29:23,860 --> 00:29:25,860
si yo no se que animal es

852
00:29:25,860 --> 00:29:27,860
si yo no se que animal es

853
00:29:27,860 --> 00:29:29,860
no puedo realizar su acción

854
00:29:29,860 --> 00:29:31,860
en ese momento no lo puedo definir

855
00:29:31,860 --> 00:29:33,860
entonces

856
00:29:33,860 --> 00:29:35,860
esto

857
00:29:35,860 --> 00:29:37,860
podría definirse

858
00:29:37,860 --> 00:29:39,860
como que esto es un método abstracto

859
00:29:39,860 --> 00:29:41,860
es un método abstracto

860
00:29:41,860 --> 00:29:43,860
verdad es un método abstracto

861
00:29:43,860 --> 00:29:45,860
no es un método que haga nada concreto

862
00:29:45,860 --> 00:29:47,860
esto ya si

863
00:29:47,860 --> 00:29:49,860
estos son métodos que hacen con que

864
00:29:49,860 --> 00:29:51,860
hacer cosas concretas

865
00:29:51,860 --> 00:29:53,860
esto si

866
00:29:53,860 --> 00:29:55,860
pero este es un método abstracto

867
00:29:55,860 --> 00:29:57,860
vale pues si yo decido

868
00:29:57,860 --> 00:29:59,860
dentro de mi diseño que es abstracto

869
00:29:59,860 --> 00:30:01,860
y quiero que quede reflejado

870
00:30:01,860 --> 00:30:03,860
y quiero que quede reflejado

871
00:30:03,860 --> 00:30:05,860
pues lo que puede hacer

872
00:30:05,860 --> 00:30:07,860
lo que puedo hacer es

873
00:30:07,860 --> 00:30:09,860
no ponerle ni cuerpo

874
00:30:11,860 --> 00:30:13,860
le pongo ahí un punto y coma

875
00:30:13,860 --> 00:30:15,860
y esto lo puedo hacer

876
00:30:15,860 --> 00:30:17,860
termino el método

877
00:30:17,860 --> 00:30:19,860
ni llaves ni nada

878
00:30:19,860 --> 00:30:21,860
termino con punto y coma

879
00:30:21,860 --> 00:30:23,860
con eso que quiero indicar

880
00:30:23,860 --> 00:30:25,860
que este método

881
00:30:25,860 --> 00:30:27,860
es abstracto

882
00:30:37,860 --> 00:30:39,860
vale el siguiente método

883
00:30:39,860 --> 00:30:41,860
es abstracto

884
00:30:43,860 --> 00:30:45,860
porque termina en punto y coma

885
00:30:45,860 --> 00:30:47,860
no tiene cuerpo

886
00:30:47,860 --> 00:30:49,860
el cuerpo de un método es lo que va entre llaves

887
00:30:49,860 --> 00:30:51,860
vale es lo que va entre llaves

888
00:30:51,860 --> 00:30:53,860
ese es el cuerpo de un método

889
00:30:53,860 --> 00:30:55,860
si un método no tiene cuerpo

890
00:30:55,860 --> 00:30:57,860
puede ocurrir

891
00:30:57,860 --> 00:30:59,860
que no tenga

892
00:30:59,860 --> 00:31:01,860
y yo lo termino con punto y coma

893
00:31:01,860 --> 00:31:03,860
entonces lo convierto en abstracto

894
00:31:03,860 --> 00:31:05,860
vale

895
00:31:07,860 --> 00:31:09,860
pero si el método

896
00:31:09,860 --> 00:31:11,860
es abstracto

897
00:31:11,860 --> 00:31:13,860
entonces esto ya tiene implicaciones

898
00:31:13,860 --> 00:31:15,860
entonces ahora yo ya estoy

899
00:31:15,860 --> 00:31:17,860
convirtiendo mi clase

900
00:31:17,860 --> 00:31:19,860
en lo que se llama una clase abstracta

901
00:31:19,860 --> 00:31:21,860
vale

902
00:31:21,860 --> 00:31:23,860
una clase que tiene

903
00:31:23,860 --> 00:31:25,860
un método por definir

904
00:31:25,860 --> 00:31:27,860
vacío que yo no puedo definirlo

905
00:31:27,860 --> 00:31:29,860
porque me falta información

906
00:31:29,860 --> 00:31:31,860
se convierte en una clase abstracta

907
00:31:31,860 --> 00:31:33,860
y eso lo tenemos que avisar

908
00:31:33,860 --> 00:31:35,860
lo tenemos que avisar

909
00:31:35,860 --> 00:31:37,860
poniendo un abstract

910
00:31:37,860 --> 00:31:39,860
ahí

911
00:31:39,860 --> 00:31:41,860
vale

912
00:31:41,860 --> 00:31:43,860
lo tenemos que avisar

913
00:31:43,860 --> 00:31:45,860
poniendo un abstract ahí

914
00:31:45,860 --> 00:31:47,860
y poniendo un abstract

915
00:31:47,860 --> 00:31:49,860
aquí vale

916
00:31:49,860 --> 00:31:51,860
no vale

917
00:31:51,860 --> 00:31:53,860
con que yo lo termine con punto y coma

918
00:31:53,860 --> 00:31:55,860
no vale

919
00:31:55,860 --> 00:31:57,860
con que yo lo termine con punto y coma

920
00:31:57,860 --> 00:31:59,860
valdrá más adelante

921
00:31:59,860 --> 00:32:01,860
cuando

922
00:32:01,860 --> 00:32:03,860
incorporemos otras cosas

923
00:32:03,860 --> 00:32:05,860
pero

924
00:32:05,860 --> 00:32:07,860
ahora mismo no

925
00:32:07,860 --> 00:32:09,860
vale yo entonces

926
00:32:09,860 --> 00:32:11,860
reconectar con el proceso

927
00:32:11,860 --> 00:32:13,860
de funcionamiento

928
00:32:13,860 --> 00:32:15,860
yo he visto que este método

929
00:32:15,860 --> 00:32:17,860
tiene que estar ahí

930
00:32:17,860 --> 00:32:19,860
tiene que estar ahí obligatoriamente

931
00:32:19,860 --> 00:32:21,860
no se lo puedo dar cuerpo

932
00:32:21,860 --> 00:32:23,860
no se lo puedo dar

933
00:32:23,860 --> 00:32:25,860
porque está por definir

934
00:32:25,860 --> 00:32:27,860
ya lo definirán las subclases

935
00:32:27,860 --> 00:32:29,860
ya lo definirán

936
00:32:29,860 --> 00:32:31,860
bueno pues entonces el diseño va a quedar

937
00:32:31,860 --> 00:32:33,860
yo lo puedo dejar como estaba

938
00:32:33,860 --> 00:32:35,860
ya está y no pasa nada

939
00:32:35,860 --> 00:32:37,860
pero el diseño va a quedar más bonito

940
00:32:37,860 --> 00:32:39,860
y como os lo vais a encontrar

941
00:32:39,860 --> 00:32:41,860
ese yo digo pues no

942
00:32:41,860 --> 00:32:43,860
si está en blanco está en blanco

943
00:32:43,860 --> 00:32:45,860
entonces le digo tú eres abstracto

944
00:32:45,860 --> 00:32:47,860
tú eres abstracto porque estás en blanco

945
00:32:47,860 --> 00:32:49,860
y aviso de que es abstracto poniendo esto

946
00:32:49,860 --> 00:32:51,860
aviso

947
00:32:51,860 --> 00:32:53,860
vale

948
00:32:53,860 --> 00:32:55,860
pues entonces desde el momento en que

949
00:32:55,860 --> 00:32:57,860
una clase tiene

950
00:32:57,860 --> 00:32:59,860
aunque sea sólo uno

951
00:32:59,860 --> 00:33:01,860
una clase puede tener mil métodos

952
00:33:01,860 --> 00:33:03,860
y uno sólo de ellos es abstracto

953
00:33:03,860 --> 00:33:05,860
o más de uno

954
00:33:05,860 --> 00:33:07,860
pero desde el momento en que tiene uno al menos

955
00:33:07,860 --> 00:33:09,860
y sólo uno

956
00:33:09,860 --> 00:33:11,860
esa clase se convierte en una clase abstracta

957
00:33:11,860 --> 00:33:13,860
y hay que avisar de ello

958
00:33:13,860 --> 00:33:15,860
poniéndole el astra delante

959
00:33:15,860 --> 00:33:17,860
vale

960
00:33:17,860 --> 00:33:19,860
...

961
00:33:19,860 --> 00:33:21,860
...

962
00:33:21,860 --> 00:33:23,860
...

963
00:33:23,860 --> 00:33:25,860
esta clase es abstracta

964
00:33:25,860 --> 00:33:27,860
porque tiene al menos

965
00:33:27,860 --> 00:33:29,860
puede tener más

966
00:33:29,860 --> 00:33:31,860
un método

967
00:33:31,860 --> 00:33:33,860
abstracto

968
00:33:33,860 --> 00:33:35,860
...

969
00:33:35,860 --> 00:33:37,860
vale

970
00:33:37,860 --> 00:33:39,860
se convierte en abstracta

971
00:33:39,860 --> 00:33:41,860
entonces así queda pues más bonito

972
00:33:41,860 --> 00:33:43,860
...

973
00:33:43,860 --> 00:33:45,860
...

974
00:33:45,860 --> 00:33:47,860
...

975
00:33:47,860 --> 00:33:49,860
...

976
00:33:49,860 --> 00:33:51,860
...

977
00:33:51,860 --> 00:33:53,860
pero bueno esto tiene una pequeña implicación

978
00:33:53,860 --> 00:33:55,860
que puede hacernos daño o puede no hacernos daño

979
00:33:55,860 --> 00:33:57,860
depende de mi aplicación

980
00:33:57,860 --> 00:33:59,860
en concreto

981
00:33:59,860 --> 00:34:01,860
la implicación que tiene

982
00:34:01,860 --> 00:34:03,860
es que de una clase abstracta

983
00:34:03,860 --> 00:34:05,860
no se pueden instanciar objetos

984
00:34:05,860 --> 00:34:07,860
...

985
00:34:07,860 --> 00:34:09,860
...

986
00:34:09,860 --> 00:34:11,860
...

987
00:34:11,860 --> 00:34:13,860
...

988
00:34:13,860 --> 00:34:15,860
...

989
00:34:15,860 --> 00:34:21,860
...

990
00:34:21,860 --> 00:34:23,860
...

991
00:34:23,860 --> 00:34:25,860
...

992
00:34:25,860 --> 00:34:27,860
...

993
00:34:27,860 --> 00:34:29,860
de una clase abstracta no se puede instanciar objetos

994
00:34:29,860 --> 00:34:31,860
...

995
00:34:31,860 --> 00:34:33,860
...

996
00:34:33,860 --> 00:34:35,860
...

997
00:34:35,860 --> 00:34:37,860
no se pueden

998
00:34:37,860 --> 00:34:39,860
la cyclone

999
00:34:39,860 --> 00:34:41,860
y de hecho efectivamente

1000
00:34:41,860 --> 00:34:43,860
si nos vamos a nuestro main

1001
00:34:43,860 --> 00:34:45,940
Yo tenía aquí un anio-animal.

1002
00:34:46,500 --> 00:34:48,599
Antes he podido instanciar un animal sin problemas.

1003
00:34:49,380 --> 00:34:51,960
Ahora, el compilador ya me lo ha puesto en rojo.

1004
00:34:52,120 --> 00:34:52,579
Me ha dicho, ¿eh?

1005
00:34:54,180 --> 00:34:55,360
Animal es abstracta.

1006
00:34:55,460 --> 00:34:58,720
Lo siento, no puedes instanciar objetos de la clase abstracta.

1007
00:34:58,980 --> 00:34:59,420
No puedes.

1008
00:35:00,440 --> 00:35:02,059
Puedes instanciar de la subclase,

1009
00:35:02,240 --> 00:35:04,579
pero de la clase abstracta no puedes.

1010
00:35:07,140 --> 00:35:08,400
Hombre, entonces uno diría,

1011
00:35:08,599 --> 00:35:10,940
jodido, ¿entonces para qué necesito una clase abstracta?

1012
00:35:10,940 --> 00:35:13,360
Es que, bueno, es que muchas veces

1013
00:35:13,360 --> 00:35:16,200
la clase la quieres simplemente como plantilla.

1014
00:35:16,780 --> 00:35:18,800
O sea, como marco de paraguas

1015
00:35:18,800 --> 00:35:21,579
para dar un código común que la hereden las demás.

1016
00:35:22,380 --> 00:35:25,320
Pero tú no quieres instanciar animales en concreto.

1017
00:35:26,000 --> 00:35:28,000
Quieres instanciar perros, gatos, no sé qué,

1018
00:35:28,079 --> 00:35:30,280
pero un animal genérico no quieres instanciarlo.

1019
00:35:31,200 --> 00:35:32,820
Suele ser lo que ocurre la mayoría de las veces.

1020
00:35:33,380 --> 00:35:35,360
Tú tienes tu aplicación con muchos tipos de clientes.

1021
00:35:36,280 --> 00:35:40,559
Y como todos ellos comparten parte de sus propiedades y métodos,

1022
00:35:40,880 --> 00:35:43,099
las recoges todas por comodidad arriba.

1023
00:35:43,360 --> 00:35:46,820
Por comodidad y así también para poder hacerte

1024
00:35:46,820 --> 00:35:48,260
una RAI común de todos, etcétera.

1025
00:35:48,680 --> 00:35:51,260
Pero objetos cliente en concreto no te vas a instanciar.

1026
00:35:51,539 --> 00:35:53,980
Te vas a instanciar cliente, tienda, presencial, patatín.

1027
00:35:54,519 --> 00:35:55,840
Suele ser el uso habitual,

1028
00:35:56,260 --> 00:35:58,420
que de la superclase no se necesite instancia.

1029
00:35:58,880 --> 00:36:02,840
Que esté solamente para dar un marco común para todas

1030
00:36:02,840 --> 00:36:05,800
y para poder tratarlas a todas en la misma referencia.

1031
00:36:06,620 --> 00:36:09,039
Para poder meterlas a todas en variable cliente.

1032
00:36:10,980 --> 00:36:12,620
Entonces, si ese es el caso,

1033
00:36:12,619 --> 00:36:15,619
si uno no necesita instanciar objetos de la superclase,

1034
00:36:16,099 --> 00:36:17,440
pues estupendo que se abstracta.

1035
00:36:18,359 --> 00:36:19,259
Estupendo que lo sea.

1036
00:36:20,940 --> 00:36:24,139
Porque el código va a quedar más claro, más bonito.

1037
00:36:24,699 --> 00:36:27,839
Y si yo lo termino aquí en un punto y coma

1038
00:36:27,839 --> 00:36:29,940
y digo que es abstracto y todo, va a quedar mucho mejor.

1039
00:36:31,000 --> 00:36:33,400
Pero claro, en ese caso no podemos instanciar.

1040
00:36:35,059 --> 00:36:36,619
Lo voy a...

1041
00:36:41,460 --> 00:36:42,599
Vale, esto.

1042
00:36:42,619 --> 00:36:52,619
No lo podríamos hacer si es abstracta.

1043
00:36:53,400 --> 00:36:54,219
No podríamos hacerlo.

1044
00:36:59,960 --> 00:37:02,139
Vale, entonces uno tiene que elegir

1045
00:37:02,139 --> 00:37:06,059
cómo diseña su aplicación.

1046
00:37:07,139 --> 00:37:10,940
Como veis, a partir de ahora y en el resto del curso,

1047
00:37:10,940 --> 00:37:14,940
asumiendo que todas las destrezas de programación las tenemos claras,

1048
00:37:14,940 --> 00:37:17,940
sobre todo se trata de entender diseños.

1049
00:37:17,940 --> 00:37:20,940
Sobre todo se trata de entender estas herramientas,

1050
00:37:20,940 --> 00:37:26,940
de estas potencialidades que nos da el lenguaje,

1051
00:37:26,940 --> 00:37:28,940
entenderlas y aplicarlas.

1052
00:37:33,940 --> 00:37:38,940
Entonces diríais, bueno, vale, pues me vale para eso exclusivamente,

1053
00:37:38,940 --> 00:37:40,940
para dar una especie de paraguas común.

1054
00:37:40,940 --> 00:37:43,940
De cosas compartidas y las otras ya lo heredan.

1055
00:37:43,940 --> 00:37:44,940
Para eso me vale.

1056
00:37:46,940 --> 00:37:48,940
Sí, me vale para eso.

1057
00:37:48,940 --> 00:37:50,940
Y además el hecho de hacerle abstracta,

1058
00:37:50,940 --> 00:37:55,940
ya me ha metido otra cosa que es muy útil y muy interesante.

1059
00:37:55,940 --> 00:37:58,940
Ya con esto paramos, hacemos el descansito.

1060
00:38:00,940 --> 00:38:01,940
Vale, y es.

1061
00:38:02,940 --> 00:38:03,940
Mi clase es abstracta.

1062
00:38:04,940 --> 00:38:05,940
Vale, pues ya ahora voy a...

1063
00:38:05,940 --> 00:38:07,940
De repente me ha aparecido otro animal.

1064
00:38:07,940 --> 00:38:09,940
En mi aplicación que es Gestión de Animales,

1065
00:38:09,940 --> 00:38:16,940
ahora me ha aparecido el ave.

1066
00:38:18,940 --> 00:38:22,940
Pues nada, yo meto una nueva clase que también va a heredar de animal.

1067
00:38:26,940 --> 00:38:30,940
Hala, me ha aparecido el ave porque ahora quiero trabajar con ellos.

1068
00:38:30,940 --> 00:38:34,940
Entonces el ave tendrá, vale, si yo quiero que sea un animal,

1069
00:38:34,940 --> 00:38:37,940
pues tendrá que heredar de animal.

1070
00:38:37,940 --> 00:38:39,940
De animal.

1071
00:38:42,940 --> 00:38:45,940
Entonces, por hacer la heredera de animal,

1072
00:38:45,940 --> 00:38:49,940
ya sabemos, ya sabemos que todo lo que haya en animal lo hereda.

1073
00:38:50,940 --> 00:38:51,940
Hereda el nombre.

1074
00:38:52,940 --> 00:38:53,940
Hereda los métodos.

1075
00:38:54,940 --> 00:38:55,940
Los constructores no.

1076
00:38:55,940 --> 00:38:56,940
Los constructores no se heredan.

1077
00:38:56,940 --> 00:38:57,940
Hay que hacerlos específicamente.

1078
00:38:58,940 --> 00:38:59,940
Vale, los constructores no.

1079
00:38:59,940 --> 00:39:01,940
Hay que hacerles específico para el ave.

1080
00:39:01,940 --> 00:39:02,940
No se heredan.

1081
00:39:02,940 --> 00:39:03,940
Vale.

1082
00:39:04,940 --> 00:39:05,940
Hay que hacerlos específicamente.

1083
00:39:05,940 --> 00:39:06,940
Vale.

1084
00:39:08,940 --> 00:39:10,940
Pero es que pasa una cosa más.

1085
00:39:10,940 --> 00:39:12,940
Al ser animal abstracta,

1086
00:39:14,940 --> 00:39:17,940
todas las herederas de una clase abstracta

1087
00:39:17,940 --> 00:39:22,940
están obligadas, obligadas a sobreescribir los métodos abstractos.

1088
00:39:23,940 --> 00:39:25,940
Es una obligación que tienen.

1089
00:39:25,940 --> 00:39:43,940
Tiene que sobreescribir obligatoriamente

1090
00:39:47,940 --> 00:39:49,940
todos los métodos abstractos de la que hereda.

1091
00:39:55,940 --> 00:40:01,940
abstractos de la superclase.

1092
00:40:06,940 --> 00:40:08,940
Por eso se me ha puesto en rojo.

1093
00:40:08,940 --> 00:40:10,940
Y esta obligación es interesante.

1094
00:40:10,940 --> 00:40:13,940
Esta obligación te dice, tú has hecho un diseño estupendo.

1095
00:40:13,940 --> 00:40:15,940
Me has hecho una clase abstracta animal.

1096
00:40:15,940 --> 00:40:18,940
Con un método vacío para que la sobreescriban.

1097
00:40:18,940 --> 00:40:22,940
Vale, pues con eso estás generando un compromiso.

1098
00:40:22,940 --> 00:40:24,940
Estás diciendo, que me hereda el que quiera.

1099
00:40:24,940 --> 00:40:29,940
Pero ojo, el que me herede tiene la obligación y el compromiso

1100
00:40:29,940 --> 00:40:32,940
de sobreescribir los métodos que yo he dejado vacíos.

1101
00:40:32,940 --> 00:40:33,940
Lo siento.

1102
00:40:33,940 --> 00:40:35,940
Los tiene que sobreescribir.

1103
00:40:35,940 --> 00:40:37,940
Y eso está bien.

1104
00:40:37,940 --> 00:40:39,940
Porque cuando tú haces una clase abstracta,

1105
00:40:39,940 --> 00:40:42,940
para que toda la aplicación en conjunto tenga sentido,

1106
00:40:42,940 --> 00:40:45,940
tiene sentido que tú digas, oye, tú quieres ser animal.

1107
00:40:45,940 --> 00:40:48,940
Perdona, si quieres ser animal, entonces tendrás que realizar acción.

1108
00:40:48,940 --> 00:40:49,940
Si no, no lo seas.

1109
00:40:49,940 --> 00:40:52,940
Vale, no puede ser que alguien herede de ti

1110
00:40:52,940 --> 00:40:53,940
y luego quiera hacer las cosas por libre.

1111
00:40:53,940 --> 00:40:56,940
Llamando al método joven en la gana.

1112
00:40:56,940 --> 00:41:00,940
Eso genera aplicaciones un poquito incoherentes.

1113
00:41:00,940 --> 00:41:02,940
Entonces tiene sentido la idea de,

1114
00:41:02,940 --> 00:41:04,940
tú te has hecho una clase cliente.

1115
00:41:04,940 --> 00:41:07,940
Vale, muy bien, la clase cliente,

1116
00:41:07,940 --> 00:41:10,940
tú le pones un método abstracto, pagar factura.

1117
00:41:10,940 --> 00:41:13,940
Entonces, perdona, todos los clientes que hereden de aquí

1118
00:41:13,940 --> 00:41:16,940
van a tener que sobreescribir, pagar factura.

1119
00:41:16,940 --> 00:41:19,940
Y si no quieres, no heredes de cliente, hereda de otra.

1120
00:41:19,940 --> 00:41:21,940
De esta no puedes.

1121
00:41:21,940 --> 00:41:23,940
Entonces es una forma de crear una obligación.

1122
00:41:23,940 --> 00:41:26,940
Una obligación a las clases que te heredan.

1123
00:41:26,940 --> 00:41:29,940
Y eso resta libertades, efectivamente,

1124
00:41:29,940 --> 00:41:31,940
resta libertades a la hora de hacer una aplicación.

1125
00:41:31,940 --> 00:41:35,940
Porque las libertades suelen conducir a errores de ejecución.

1126
00:41:35,940 --> 00:41:38,940
Entonces, cuantas más libertades se cierren

1127
00:41:38,940 --> 00:41:41,940
en tiempo de compilación mejor,

1128
00:41:41,940 --> 00:41:43,940
pues es lo que nos dice este.

1129
00:41:43,940 --> 00:41:44,940
El compilador nos está diciendo,

1130
00:41:44,940 --> 00:41:46,940
¿qué quieres heredar de animal?

1131
00:41:46,940 --> 00:41:49,940
El compilador se va animal y dice, muy bien,

1132
00:41:49,940 --> 00:41:51,940
pero es que animal tiene un método abstracto.

1133
00:41:51,940 --> 00:41:52,940
Pues lo siento mucho,

1134
00:41:52,940 --> 00:41:54,940
pero tienes que heredarlo.

1135
00:41:54,940 --> 00:41:56,940
Antes no pasaba eso.

1136
00:41:56,940 --> 00:41:57,940
O sea, cuando no era abstracto,

1137
00:41:57,940 --> 00:42:01,940
y yo lo tenía con el cuerpo vacío, así,

1138
00:42:01,940 --> 00:42:03,940
lo tenía así,

1139
00:42:03,940 --> 00:42:07,940
y entonces esto no era abstracto,

1140
00:42:07,940 --> 00:42:10,940
al no estar marcado como abstracto,

1141
00:42:10,940 --> 00:42:13,940
no había ninguna obligación de sobreescribirlo.

1142
00:42:13,940 --> 00:42:16,940
Tú lo heredabas y lo heredabas vacío.

1143
00:42:16,940 --> 00:42:18,940
Lo heredabas vacío.

1144
00:42:18,940 --> 00:42:20,940
Entonces, aquí en ave,

1145
00:42:20,940 --> 00:42:21,940
¿vale?,

1146
00:42:22,940 --> 00:42:23,940
aquí en ave, bueno,

1147
00:42:23,940 --> 00:42:24,940
este error me sale por el constructor,

1148
00:42:24,940 --> 00:42:25,940
¿vale?,

1149
00:42:25,940 --> 00:42:26,940
por el súper,

1150
00:42:26,940 --> 00:42:27,940
pero no me sale por eso.

1151
00:42:27,940 --> 00:42:29,940
Aquí en ave,

1152
00:42:29,940 --> 00:42:31,940
vamos a ponerle un constructor para que se calle

1153
00:42:31,940 --> 00:42:33,940
y veamos que el error,

1154
00:42:33,940 --> 00:42:34,940
¿vale?,

1155
00:42:34,940 --> 00:42:36,940
como nos hemos metido con los constructores todavía,

1156
00:42:36,940 --> 00:42:37,940
¿vale?,

1157
00:42:37,940 --> 00:42:39,940
aquí en ave se me quita el error.

1158
00:42:39,940 --> 00:42:41,940
Se me quita el error y, ¿vale?,

1159
00:42:41,940 --> 00:42:42,940
tú heredas de animal,

1160
00:42:42,940 --> 00:42:43,940
si te da la gana,

1161
00:42:43,940 --> 00:42:44,940
animal no es abstracta,

1162
00:42:44,940 --> 00:42:47,940
tiene un método aquí que no tiene cuerpo,

1163
00:42:47,940 --> 00:42:48,940
pero no es lo mismo.

1164
00:42:48,940 --> 00:42:50,940
Tener un cuerpo sin código,

1165
00:42:50,940 --> 00:42:51,940
no es lo mismo que ser abstracto.

1166
00:42:51,940 --> 00:42:52,940
No es lo mismo que ser abstracto.

1167
00:42:52,940 --> 00:42:53,940
Son dos cosas diferentes.

1168
00:42:53,940 --> 00:42:54,940
No es lo mismo.

1169
00:42:54,940 --> 00:42:57,940
Entonces, la clase ave hereda esto.

1170
00:42:57,940 --> 00:42:59,940
Que lo sobrescribe, genial.

1171
00:42:59,940 --> 00:43:00,940
Que no lo sobrescribe,

1172
00:43:00,940 --> 00:43:02,940
se queda con su método vacío.

1173
00:43:02,940 --> 00:43:03,940
Lo hereda.

1174
00:43:03,940 --> 00:43:05,940
Pero si yo he cambiado el diseño,

1175
00:43:05,940 --> 00:43:06,940
lo cambio y digo,

1176
00:43:06,940 --> 00:43:07,940
no, no, espera.

1177
00:43:07,940 --> 00:43:10,940
Lo de un cuerpo vacío es una cosa muy rara.

1178
00:43:10,940 --> 00:43:16,940
Lo voy a cambiar a que sea abstracto

1179
00:43:16,940 --> 00:43:18,940
y entonces ya mi clase es abstracta.

1180
00:43:21,940 --> 00:43:23,940
Vale.

1181
00:43:23,940 --> 00:43:26,940
Pues si yo lo cambio a este modelo

1182
00:43:26,940 --> 00:43:28,940
y digo, oye, este es un método abstracto

1183
00:43:28,940 --> 00:43:29,940
y la clase es abstracta,

1184
00:43:29,940 --> 00:43:32,940
automáticamente ave ya se acabó.

1185
00:43:32,940 --> 00:43:33,940
Ya casca.

1186
00:43:33,940 --> 00:43:36,940
Porque ave ya está en la obligación

1187
00:43:36,940 --> 00:43:37,940
de sobreescribir el método abstracto.

1188
00:43:37,940 --> 00:43:39,940
No tiene que sobreescribir.

1189
00:43:39,940 --> 00:43:43,940
Lo tiene que sobreescribir y ya está.

1190
00:43:43,940 --> 00:43:45,940
Pues para eso valen los métodos

1191
00:43:45,940 --> 00:43:47,940
y las clases abstractas.

1192
00:43:47,940 --> 00:43:48,940
Para generar esa obligación,

1193
00:43:48,940 --> 00:43:50,940
para poner esas limitaciones a las herederas

1194
00:43:50,940 --> 00:43:53,940
y así forzar una coherencia.

1195
00:43:53,940 --> 00:43:55,940
Forzar una coherencia en la aplicación.

1196
00:43:55,940 --> 00:43:57,940
Que todos los clientes

1197
00:43:57,940 --> 00:43:59,940
tengan que obligatoriamente pagar factura.

1198
00:43:59,940 --> 00:44:01,940
Que todos los animales

1199
00:44:01,940 --> 00:44:03,940
tengan que obligatoriamente realizar acción.

1200
00:44:03,940 --> 00:44:04,940
¿Vale?

1201
00:44:04,940 --> 00:44:05,940
Para eso sirve.

1202
00:44:05,940 --> 00:44:07,940
Para eso sirven las clases abstractas.

1203
00:44:07,940 --> 00:44:10,940
¿Vale?

1204
00:44:10,940 --> 00:44:15,039
Venga, ahora sí que vamos a descansar aquí un poquito.