1
00:00:01,520 --> 00:00:11,199
Bueno, pues con lo que estábamos, ¿verdad? Era con la herencia, ¿vale?

2
00:00:12,060 --> 00:00:19,980
Entonces, realmente yo creo que todos estamos ya en el punto en el cual entendemos por qué esto tiene sentido y tiene razón de ser, ¿no?

3
00:00:19,980 --> 00:00:23,859
Que no es un invento que se pone en otras cosas. ¿Verdad que sí?

4
00:00:24,160 --> 00:00:25,420
No. Hola.

5
00:00:27,859 --> 00:00:35,020
David, tú por ejemplo, ¿qué has atendido? ¿Podrías decirme una razón por la que la herencia tenga sentido?

6
00:00:35,020 --> 00:00:38,880
Bueno, pues inténtalo

7
00:00:38,880 --> 00:00:40,659
porque tendrás que dar charlas

8
00:00:40,659 --> 00:00:42,820
y debe ser con tu trabajo

9
00:00:42,820 --> 00:00:48,450
No me lo podías explicar tú, Juan

10
00:00:48,450 --> 00:00:52,950
No, porque la hered...

11
00:00:52,950 --> 00:00:56,549
Una, reutilizar código

12
00:00:56,549 --> 00:00:58,350
¿Vale?

13
00:00:58,450 --> 00:01:00,890
Efectivamente, porque tú heredas de una clase

14
00:01:00,890 --> 00:01:02,549
y al heredar de ella o extender

15
00:01:02,549 --> 00:01:04,469
todo lo que tenía esa clase

16
00:01:04,469 --> 00:01:05,469
está ya en ti

17
00:01:05,469 --> 00:01:10,769
Entonces, eso es una ventaja para el tiempo de desarrollo, ¿vale?

18
00:01:11,469 --> 00:01:13,750
Para hacer métodos más fáciles,

19
00:01:13,810 --> 00:01:16,909
tipo poner métodos en todas las partes de las herencias,

20
00:01:18,310 --> 00:01:19,870
y luego meter verazas y todo eso.

21
00:01:20,349 --> 00:01:24,469
Bueno, esencialmente, sobre todo, la ventaja de la herencia es el polimorfismo.

22
00:01:25,469 --> 00:01:27,469
Es decir, yo tengo...

23
00:01:28,010 --> 00:01:30,930
Le he dicho 200.000 veces.

24
00:01:30,930 --> 00:01:35,049
Le he dicho 200.000 veces.

25
00:01:35,469 --> 00:01:49,930
Entonces, esencialmente, la herencia es una herramienta para describir mejor la realidad que vamos a gestionar, ¿verdad?

26
00:01:50,049 --> 00:01:54,870
Porque nuestra aplicación va a gestionar una serie de conceptos y entidades.

27
00:01:55,450 --> 00:02:01,170
Entonces, si hacemos un diseño que los represente correctamente con sus clases, propiedades y métodos,

28
00:02:01,650 --> 00:02:04,989
luego ya la aplicación, lo que para nosotros ahora mismo es el main solamente,

29
00:02:05,469 --> 00:02:12,969
La aplicación va a ser mucho más sencilla de hacer, más fácil de mantener, de escalar, aumentar funcionalidades, etc.

30
00:02:13,090 --> 00:02:16,969
Entonces, la herramienta esencialmente es un diseño para representar mejor la realidad.

31
00:02:17,430 --> 00:02:19,409
¿Y por qué la representa mejor?

32
00:02:19,870 --> 00:02:25,530
Porque en la realidad muchos conceptos distintos comparten una raíz común, ¿no?

33
00:02:25,969 --> 00:02:27,530
Comparten cosas, ¿vale?

34
00:02:27,530 --> 00:02:29,189
Un gato y un perro, pues los dos son animales.

35
00:02:29,710 --> 00:02:33,889
Entonces, en lugar de hacer un gato y un perro por separado, hacemos una clase animal.

36
00:02:33,889 --> 00:02:39,889
Un gato cree de esta y un perro cree de esta, pues estaremos reutilizando todo lo de animal y además estaremos particularizando.

37
00:02:41,110 --> 00:02:48,349
Entonces, al particularizar, lo que hacemos es, todos los animales comen, pero el perro come diferente del gato.

38
00:02:49,210 --> 00:02:57,189
Entonces, al particularizar, yo particularizo el método comer en gato y el método comer en perro.

39
00:02:57,189 --> 00:03:18,189
¿Vale? Pero luego mi aplicación le da exactamente igual que cada clase heredera o cada subclase tenga su propia versión. A la aplicación le da igual. La aplicación, gracias a que hay una raíz común, sabe que yo puedo tener 37 animales que si todos heredan de mi raíz común animal, todos van a comer.

40
00:03:18,189 --> 00:03:20,650
y la aplicación llamará a comer

41
00:03:20,650 --> 00:03:22,949
y la aplicación será

42
00:03:22,949 --> 00:03:24,330
completamente transparente

43
00:03:24,330 --> 00:03:25,629
que luego en realidad

44
00:03:25,629 --> 00:03:28,689
cada uno de los animales o subclases

45
00:03:28,689 --> 00:03:29,969
lo hace a su manera

46
00:03:29,969 --> 00:03:32,349
será completamente transparente

47
00:03:32,349 --> 00:03:33,770
la aplicación sabe que llamará

48
00:03:33,770 --> 00:03:35,629
al método de la superclase

49
00:03:35,629 --> 00:03:37,750
y ya sabe que la máquina virtual

50
00:03:37,750 --> 00:03:38,930
hará el trabajo sucio

51
00:03:38,930 --> 00:03:42,849
es decir, vale, estás llamando al método de la superclase

52
00:03:42,849 --> 00:03:44,009
pero yo tengo que ver

53
00:03:44,009 --> 00:03:46,830
el objeto concreto, cuál es su propia versión

54
00:03:46,830 --> 00:03:49,069
entonces la máquina virtual hace el trabajo sucio

55
00:03:49,069 --> 00:03:51,069
de irse a la clase

56
00:03:51,069 --> 00:03:52,990
concreta del objeto que ha llamado

57
00:03:52,990 --> 00:03:54,889
al método de la superclase a ver si tiene

58
00:03:54,889 --> 00:03:56,069
una versión suya propia

59
00:03:56,069 --> 00:03:59,030
entonces todo ese trabajo sucio que hace la máquina virtual

60
00:03:59,030 --> 00:04:01,069
se lo quita el desarrollador

61
00:04:01,069 --> 00:04:02,870
porque si no el desarrollador

62
00:04:02,870 --> 00:04:04,949
tendría que especificar en el código

63
00:04:04,949 --> 00:04:06,949
no, estoy llamando a la versión

64
00:04:06,949 --> 00:04:08,830
de comer de gato, a la versión de comer de perro

65
00:04:08,830 --> 00:04:10,949
no, el desarrollador dice yo llamo a comer de la de arriba

66
00:04:10,949 --> 00:04:12,830
de la de arriba y la máquina virtual

67
00:04:12,830 --> 00:04:14,789
que se preocupe el objeto

68
00:04:14,789 --> 00:04:16,990
en concreto que versión

69
00:04:16,990 --> 00:04:18,730
propia tiene, ese es el

70
00:04:18,730 --> 00:04:20,730
polimorfismo y eso en realidad es lo que

71
00:04:20,730 --> 00:04:21,790
le da a esto

72
00:04:21,790 --> 00:04:24,709
la fuerza de que nos dé

73
00:04:24,709 --> 00:04:25,769
aplicaciones más

74
00:04:25,769 --> 00:04:28,589
más manejables

75
00:04:28,589 --> 00:04:30,649
y que no sean unos

76
00:04:30,649 --> 00:04:32,670
códigos que luego a la hora de mantenerlos

77
00:04:32,670 --> 00:04:34,709
hay una cantidad de clases que tenemos que

78
00:04:34,709 --> 00:04:36,069
retocar por todos lados

79
00:04:36,069 --> 00:04:38,649
vale, pero la herencia tal y como la hemos visto

80
00:04:38,649 --> 00:04:40,670
pues tiene una pequeña

81
00:04:40,670 --> 00:04:42,990
pega, que la herencia

82
00:04:42,990 --> 00:04:44,410
Java es simple

83
00:04:44,410 --> 00:04:55,959
es decir, que la herencia sea simple

84
00:04:55,959 --> 00:04:58,339
significa que de una superclase

85
00:04:58,339 --> 00:05:04,399
bueno, mejor dicho, que lo estoy explicando

86
00:05:04,399 --> 00:05:06,740
que una clase

87
00:05:06,740 --> 00:05:10,980
solo puede heredar de otra

88
00:05:10,980 --> 00:05:14,500
el extens que acompaña a la subclase

89
00:05:14,500 --> 00:05:18,300
el extens este de aquí

90
00:05:18,300 --> 00:05:20,199
que acompaña a la subclase

91
00:05:20,199 --> 00:05:21,740
solo puede tener una

92
00:05:21,740 --> 00:05:24,199
es decir, una clase

93
00:05:24,199 --> 00:05:25,319
solo puede tener un padre

94
00:05:25,319 --> 00:05:26,620
solo, y ya está

95
00:05:26,620 --> 00:05:30,160
el que le paga que eres tú

96
00:05:30,160 --> 00:05:31,540
y el real, el biológico

97
00:05:31,540 --> 00:05:34,560
pues aquí en Java, solo una clase

98
00:05:34,560 --> 00:05:35,699
solo puede tener un padre

99
00:05:35,699 --> 00:05:36,819
¿vale?

100
00:05:38,040 --> 00:05:39,899
esto, de nuevo

101
00:05:39,899 --> 00:05:41,160
es una limitación

102
00:05:41,160 --> 00:05:44,000
porque a lo mejor habrá situaciones de la realidad

103
00:05:44,000 --> 00:05:45,000
que queremos modelar

104
00:05:45,000 --> 00:05:47,759
que yo soy a la vez una cosa

105
00:05:47,759 --> 00:05:48,839
y soy a la vez otra

106
00:05:48,839 --> 00:05:51,980
entonces querría heredar de las dos

107
00:05:51,980 --> 00:05:55,040
y diríamos, vale, pues esas dos cosas que eres

108
00:05:55,040 --> 00:05:56,920
ponlas juntas en una clase

109
00:05:56,920 --> 00:05:59,379
pero es que entonces a lo mejor ya se pierde el sentido

110
00:05:59,379 --> 00:06:02,220
porque estoy mezclando dos clases que no son

111
00:06:02,220 --> 00:06:06,480
entonces, podría haber situaciones que no se pudieran representar bien

112
00:06:06,480 --> 00:06:08,420
solamente con una estructura así

113
00:06:08,420 --> 00:06:13,560
esta es la estructura de Java

114
00:06:13,560 --> 00:06:16,899
de clases, uno puede hacer aquí un árbol hasta el infinito

115
00:06:16,899 --> 00:06:18,220
un árbol hasta el infinito

116
00:06:18,220 --> 00:06:20,620
pero al final cada una

117
00:06:20,620 --> 00:06:22,680
solo puede dar de una, luego el árbol

118
00:06:22,680 --> 00:06:24,839
hasta el infinito siempre va a ser

119
00:06:24,839 --> 00:06:27,060
así, donde la clase de arriba

120
00:06:27,060 --> 00:06:28,839
que esto es verdad que no lo he

121
00:06:28,839 --> 00:06:30,819
dicho hasta ahora, donde la clase

122
00:06:30,819 --> 00:06:32,699
de arriba es una clase que

123
00:06:32,699 --> 00:06:33,939
ya existe

124
00:06:33,939 --> 00:06:36,459
que es la clase object

125
00:06:36,459 --> 00:06:38,639
entonces hay una clase en Java que ya existe

126
00:06:38,639 --> 00:06:40,740
que ya está hecha, como la clase string, como la clase scanner

127
00:06:40,740 --> 00:06:42,279
como las dos mil millones de clases

128
00:06:42,279 --> 00:06:43,819
que está en la JRE

129
00:06:43,819 --> 00:06:45,660
que es la clase object

130
00:06:45,660 --> 00:06:48,300
la clase de object no tiene dentro

131
00:06:48,300 --> 00:06:49,300
prácticamente nada

132
00:06:49,300 --> 00:06:51,819
la podemos mirar ahora, no tiene dentro prácticamente nada

133
00:06:51,819 --> 00:06:54,899
y cuando uno hace

134
00:06:54,899 --> 00:06:56,240
cualquier clase

135
00:06:56,240 --> 00:06:57,139
cualquiera

136
00:06:57,139 --> 00:07:02,839
tiene dos opciones

137
00:07:02,839 --> 00:07:03,939
o la deja en blanco

138
00:07:03,939 --> 00:07:06,879
el extens y ya está, ya hace su clase

139
00:07:06,879 --> 00:07:08,980
o hereda de algo

140
00:07:08,980 --> 00:07:10,920
y entonces ya se mete en la jerarquía

141
00:07:10,920 --> 00:07:11,660
heredando lo que sea

142
00:07:11,660 --> 00:07:14,759
bueno, pues si nosotros aquí no ponemos nada

143
00:07:14,759 --> 00:07:16,360
lo dejamos en blanco completamente

144
00:07:16,360 --> 00:07:17,420
y no ponemos nada

145
00:07:17,420 --> 00:07:19,079
por defecto

146
00:07:19,079 --> 00:07:22,100
es como si hubiéramos puesto esto

147
00:07:22,100 --> 00:07:28,050
¿vale?

148
00:07:28,170 --> 00:07:29,350
luego, si no hay nada

149
00:07:29,350 --> 00:07:31,069
en realidad tenemos esto

150
00:07:31,069 --> 00:07:33,050
¿eso qué significa?

151
00:07:33,149 --> 00:07:34,689
que cuando nosotros hacemos una clase

152
00:07:34,689 --> 00:07:36,629
en realidad

153
00:07:36,629 --> 00:07:39,430
esa clase ya tiene algunas cositas dentro

154
00:07:39,430 --> 00:07:41,329
muy pocas, aunque nosotros no las veamos

155
00:07:41,329 --> 00:07:43,470
muy poquitas, que son las de odio

156
00:07:43,470 --> 00:07:45,850
y de hecho

157
00:07:45,850 --> 00:07:47,750
ya lo hemos usado a veces incluso sin saberlo

158
00:07:47,750 --> 00:07:49,370
porque nosotros

159
00:07:49,370 --> 00:07:50,930
Hacíamos a lo mejor

160
00:07:50,930 --> 00:07:51,410
A ver

161
00:07:51,410 --> 00:08:00,040
Me mejor en el eclipse

162
00:08:00,040 --> 00:08:27,259
Vale

163
00:08:27,259 --> 00:08:28,620
¿Qué os pasa?

164
00:08:30,060 --> 00:08:31,500
Lo meto aquí en ejemplo

165
00:08:31,500 --> 00:08:32,299
Herencia

166
00:08:32,299 --> 00:08:37,850
Vale, ¿se ve bien con la luz atrás?

167
00:08:39,629 --> 00:08:41,049
Porque no se ve una caca, ¿no?

168
00:08:41,389 --> 00:08:42,529
Ah, que está todavía arrancando

169
00:08:42,529 --> 00:08:45,110
Está como nosotros

170
00:08:45,110 --> 00:08:46,730
Que no acaba todavía de despertarse

171
00:08:46,730 --> 00:08:50,250
He dicho nosotros, no he dicho vosotros.

172
00:08:53,230 --> 00:09:03,509
Bueno, por ejemplo, voy a reutilizar este ejemplo herencia de cliente, cliente online, cliente tienda.

173
00:09:08,139 --> 00:09:16,700
Pues nosotros la primera clase que hicimos en esta aplicación era la clase cliente y esta clase no heredaba de ninguna.

174
00:09:16,700 --> 00:09:21,100
luego ya sí, cliente online hereda de esta

175
00:09:21,100 --> 00:09:25,100
con lo cual tenía todo lo de cliente, sobre escribía métodos si interesaba

176
00:09:25,100 --> 00:09:28,539
si no, no, cliente tienda también heredaba de cliente

177
00:09:28,539 --> 00:09:33,179
luego tenía todo lo de cliente, sobre escribía métodos si le interesaba o no

178
00:09:33,179 --> 00:09:37,120
y ya está, y con esto ya hicimos una aplicación con diferentes clientes

179
00:09:37,120 --> 00:09:41,139
que hacían diferentes cosas, vale, esta en concreto, esta en particular

180
00:09:41,139 --> 00:09:45,100
no hereda de nadie, con lo cual en realidad esto es como si hubiéramos puesto

181
00:09:45,100 --> 00:09:58,399
esto. Luego, poner esto y no poner nada es la misma cosa. Entonces, efectivamente, Java

182
00:09:58,399 --> 00:10:04,139
tiene una jerarquía de clases que es un arbolito, siempre, porque cualquier clase que yo haga,

183
00:10:06,779 --> 00:10:19,139
cualquier clase que hagamos, si yo no pongo nada, va a heredar de esta, que es object

184
00:10:19,139 --> 00:10:28,590
de aquí, vale

185
00:10:28,590 --> 00:10:30,490
de la clase object hereda cualquiera

186
00:10:30,490 --> 00:10:32,549
que yo hago más clases que no heredan de ninguna

187
00:10:32,549 --> 00:10:34,230
pues todas heredan de object

188
00:10:34,230 --> 00:10:35,330
todas heredan de object

189
00:10:35,330 --> 00:10:39,820
vale

190
00:10:39,820 --> 00:10:46,879
ahora, que hago

191
00:10:46,879 --> 00:10:49,080
en alguna clase un stance de alguna otra

192
00:10:49,080 --> 00:10:51,100
bueno, pues entonces se heredará de la que sea

193
00:10:51,100 --> 00:10:54,899
que luego hago otra que en lugar

194
00:10:54,899 --> 00:10:56,820
de heredar de object directamente hereda

195
00:10:56,820 --> 00:10:58,799
de otra, pues bueno, esa estará metida ahí

196
00:10:58,799 --> 00:10:59,879
donde sea, entonces

197
00:10:59,879 --> 00:11:01,620
en

198
00:11:01,620 --> 00:11:04,279
java

199
00:11:04,279 --> 00:11:06,320
cualquier aplicación

200
00:11:06,320 --> 00:11:08,019
es un arbolito de clases

201
00:11:08,019 --> 00:11:09,740
donde la de object es la de arriba

202
00:11:09,740 --> 00:11:12,519
si no hay herencia pues todas las demás

203
00:11:12,519 --> 00:11:13,340
están todas abajo

204
00:11:13,340 --> 00:11:16,039
que además estoy haciendo

205
00:11:16,039 --> 00:11:17,759
extens de alguna de las que ya hay

206
00:11:17,759 --> 00:11:19,299
pues estaría haciendo un nivel inferior

207
00:11:19,299 --> 00:11:20,840
todo es un árbol así

208
00:11:20,840 --> 00:11:23,399
entonces esto

209
00:11:23,399 --> 00:11:26,139
a veces puede representar algunas situaciones

210
00:11:26,139 --> 00:11:27,860
pero hay veces

211
00:11:27,860 --> 00:11:28,899
que no lo representa

212
00:11:28,899 --> 00:11:31,600
porque hay veces que alguna de estas clases de aquí

213
00:11:31,600 --> 00:11:34,580
pues efectivamente tiene todo lo de esta

214
00:11:34,580 --> 00:11:36,620
y todo lo de sus abuelos y bisabuelos

215
00:11:36,620 --> 00:11:38,620
pero a lo mejor también querría

216
00:11:38,620 --> 00:11:39,659
yo que tuviera lo de esta

217
00:11:39,659 --> 00:11:42,820
y que heredara el comportamiento

218
00:11:42,820 --> 00:11:43,879
heredara de las dos

219
00:11:43,879 --> 00:11:46,500
pues en Java no se puede, solo puedes

220
00:11:46,500 --> 00:11:47,279
heredar de alguna

221
00:11:47,279 --> 00:11:50,159
entonces hay un parche

222
00:11:50,159 --> 00:11:52,740
pero es un parche fundamental

223
00:11:52,740 --> 00:11:54,320
para

224
00:11:54,320 --> 00:11:57,139
salvar esto

225
00:11:57,139 --> 00:11:58,440
salvar esta restricción

226
00:11:58,440 --> 00:12:00,080
que son las interfaces

227
00:12:00,080 --> 00:12:01,759
¿Vale? Son las interfaces

228
00:12:01,759 --> 00:12:03,539
Es una cosa muy sencilla

229
00:12:03,539 --> 00:12:05,000
Que vamos a ver simplemente ahora

230
00:12:05,000 --> 00:12:07,340
Que es lo que tiene de fondo

231
00:12:07,340 --> 00:12:09,600
Pero antes de eso vamos a ver un pelín y más

232
00:12:09,600 --> 00:12:11,320
Ya que hemos sacado esto de la clase object

233
00:12:11,320 --> 00:12:13,220
Que es la raíz de la jerarquía siempre

234
00:12:13,220 --> 00:12:15,340
De cualquier conjunto de clases en Java

235
00:12:15,340 --> 00:12:17,460
Vamos a ver por curiosidad que tiene

236
00:12:17,460 --> 00:12:18,440
Esta clase object

237
00:12:18,440 --> 00:12:21,360
Entonces recordad, esto estar o no estar

238
00:12:21,360 --> 00:12:23,399
Es lo mismo, vale, vamos a ver que tiene object

239
00:12:23,399 --> 00:12:31,529
Bueno, es que object hasta que la abre

240
00:12:31,529 --> 00:12:32,070
Este

241
00:12:32,070 --> 00:12:35,269
Uf, se está mil horas

242
00:12:35,269 --> 00:12:42,240
Debería haberla buscado a mano

243
00:12:42,240 --> 00:12:50,200
Igual si la busco a mano

244
00:12:50,200 --> 00:12:51,039
Porque está en

245
00:12:51,039 --> 00:12:51,899
Avalanche

246
00:12:51,899 --> 00:13:03,259
Así es más rápido

247
00:13:03,259 --> 00:13:05,500
Vale, esta es la clase object

248
00:13:05,500 --> 00:13:07,840
Esta sí que no hereda de nadie

249
00:13:07,840 --> 00:13:09,940
Que ya está dada

250
00:13:09,940 --> 00:13:11,279
Y todo eso, y no tiene nada

251
00:13:11,279 --> 00:13:12,580
Tiene un constructor

252
00:13:12,580 --> 00:13:14,019
Sin parámetros

253
00:13:14,019 --> 00:13:17,399
Vale, luego cuando una clase

254
00:13:17,399 --> 00:13:19,659
cualquiera que hacemos que no era de nadie

255
00:13:19,659 --> 00:13:21,779
nos pone automáticamente

256
00:13:21,779 --> 00:13:23,559
el eclipse, un super sin parámetros

257
00:13:23,559 --> 00:13:24,879
está llamando a este, que no hace nada

258
00:13:24,879 --> 00:13:27,419
bueno, por eso decíamos cuando nos aparecía

259
00:13:27,419 --> 00:13:29,139
loquito y ya está, porque es que no hace nada

260
00:13:29,139 --> 00:13:31,700
claro, el super siempre es

261
00:13:31,700 --> 00:13:33,259
constructor de la superclase

262
00:13:33,259 --> 00:13:35,679
cuando la superclase es

263
00:13:35,679 --> 00:13:37,460
object, pues

264
00:13:37,460 --> 00:13:39,559
poner el super y no ponerlo es lo mismo, porque es que no me está

265
00:13:39,559 --> 00:13:41,320
haciendo nada el constructor de la superclase

266
00:13:41,320 --> 00:13:42,460
¿vale?

267
00:13:43,779 --> 00:13:45,519
¿y qué tiene? pues tiene algunos

268
00:13:45,519 --> 00:13:47,080
métodos muy chorras que hasta ahora

269
00:13:47,080 --> 00:13:50,220
algunos los hemos usado

270
00:13:50,220 --> 00:13:52,419
sin saber exactamente que hacían

271
00:13:52,419 --> 00:13:54,559
getClass

272
00:13:54,559 --> 00:13:56,320
te devuelve el nombre de la clase

273
00:13:56,320 --> 00:13:57,679
al que pertenece ese objeto

274
00:13:57,679 --> 00:14:00,340
este te genera

275
00:14:00,340 --> 00:14:02,519
un código hash para ese objeto

276
00:14:02,519 --> 00:14:04,279
que todavía no lo necesitamos pero lo necesitaremos

277
00:14:04,279 --> 00:14:04,919
más adelante

278
00:14:04,919 --> 00:14:07,320
y sí que hemos usado uno

279
00:14:07,320 --> 00:14:09,620
este, ¿verdad?

280
00:14:09,940 --> 00:14:11,960
este método lo hemos usado para objetos

281
00:14:11,960 --> 00:14:13,779
a veces, ¿vale?

282
00:14:13,779 --> 00:14:14,759
el método id

283
00:14:14,759 --> 00:14:16,419
pues este método

284
00:14:16,419 --> 00:14:18,799
Está heredado de object

285
00:14:18,799 --> 00:14:20,159
Entonces, por ejemplo

286
00:14:20,159 --> 00:14:22,559
Mi cliente que hereda de object

287
00:14:22,559 --> 00:14:24,700
Da igual que yo lo ponga o no, porque hereda de object

288
00:14:24,700 --> 00:14:26,519
Si yo

289
00:14:26,519 --> 00:14:27,679
Ahora en mi main

290
00:14:27,679 --> 00:14:34,789
En mi main de pruebas, este de aquí cualquiera

291
00:14:34,789 --> 00:14:40,159
Pues tengo mi objeto cliente

292
00:14:40,159 --> 00:14:40,720
Que es c

293
00:14:40,720 --> 00:14:45,799
Vale, vamos a hacer un específico

294
00:14:45,799 --> 00:14:46,360
Cliente

295
00:14:46,360 --> 00:14:57,009
Vale, pues este objeto cliente

296
00:14:57,009 --> 00:14:59,110
Tiene un método equals

297
00:14:59,110 --> 00:15:00,809
Al que puede llamar

298
00:15:00,809 --> 00:15:02,169
Vale

299
00:15:02,169 --> 00:15:04,570
tiene un método equals al que puede llamar

300
00:15:04,570 --> 00:15:07,070
y a este método equals al que puede

301
00:15:07,070 --> 00:15:08,750
llamar, este método ¿cuál será?

302
00:15:09,509 --> 00:15:11,029
en cliente no está declarado

303
00:15:11,029 --> 00:15:13,110
entonces este método equals

304
00:15:13,110 --> 00:15:15,009
será el que hereda automáticamente de

305
00:15:15,009 --> 00:15:17,049
object y el que hereda de object

306
00:15:17,049 --> 00:15:18,990
es este, el que hereda

307
00:15:18,990 --> 00:15:20,850
de object se le puede pasar cualquier

308
00:15:20,850 --> 00:15:22,990
objeto, el que a mí me dé la gana

309
00:15:22,990 --> 00:15:24,909
cualquiera y me devuelve

310
00:15:24,909 --> 00:15:26,470
un true, ¿y qué hace este equals?

311
00:15:26,690 --> 00:15:28,129
es un equals muy básico

312
00:15:28,129 --> 00:15:31,009
compara si la

313
00:15:31,009 --> 00:15:32,850
dirección de memoria del objeto

314
00:15:32,850 --> 00:15:35,269
que yo paso, es idéntica

315
00:15:35,269 --> 00:15:37,049
a la dirección de memoria del objeto

316
00:15:37,049 --> 00:15:37,570
que lo llamo.

317
00:15:38,769 --> 00:15:40,009
Ya alguna vez lo hemos mencionado.

318
00:15:41,029 --> 00:15:42,870
Si yo hago un equals entre un

319
00:15:42,870 --> 00:15:44,529
objeto y otro objeto,

320
00:15:45,490 --> 00:15:46,529
lo que hace el equals,

321
00:15:47,009 --> 00:15:48,929
a menos que yo lo tenga sobrescrito en la

322
00:15:48,929 --> 00:15:50,649
clase cliente, claro, a menos que lo tenga

323
00:15:50,649 --> 00:15:52,529
sobrescrito. Si yo no lo tengo sobrescrito,

324
00:15:53,509 --> 00:15:54,090
el equals,

325
00:15:54,710 --> 00:15:56,529
la versión que usa es la heredada.

326
00:15:57,029 --> 00:15:58,850
¿La heredada de quién? Pues de

327
00:15:58,850 --> 00:16:00,809
object, porque cliente

328
00:16:00,809 --> 00:16:07,129
heredada de object la heredada y la versión heredada de equals que hace pues si no se va

329
00:16:07,129 --> 00:16:13,169
a igual a lo que hace es ver si son exactamente iguales exactamente iguales esta dirección de

330
00:16:13,169 --> 00:16:19,389
memoria y la dirección de memoria del objeto es decir si un objeto y otro en memoria ram son el

331
00:16:19,389 --> 00:16:24,549
mismo están uno encima del otro no sé su contenido es igual porque yo puedo tener un objeto en esta

332
00:16:24,549 --> 00:16:29,509
dirección de memoria otro objeto en esta dirección de memoria tenerlas los mismos valores en las

333
00:16:29,509 --> 00:16:31,490
propiedades, pero este

334
00:16:31,490 --> 00:16:32,549
equals me daría false

335
00:16:32,549 --> 00:16:35,370
porque uno y otro no están

336
00:16:35,370 --> 00:16:37,090
en la misma dirección de memoria

337
00:16:37,090 --> 00:16:39,730
bueno, pues el método equals de object

338
00:16:39,730 --> 00:16:41,549
lo que te ofrece es eso

339
00:16:41,549 --> 00:16:43,029
que es muy sencillo, te dice

340
00:16:43,029 --> 00:16:45,110
oye, yo te digo que son iguales

341
00:16:45,110 --> 00:16:46,809
si uno y otro están en la misma dirección

342
00:16:46,809 --> 00:16:49,389
si tú quieres que la igualdad

343
00:16:49,389 --> 00:16:50,509
sea por otras cosas

344
00:16:50,509 --> 00:16:53,350
sea dos objetos son iguales

345
00:16:53,350 --> 00:16:54,509
si el nombre es el mismo

346
00:16:54,509 --> 00:16:57,450
que eso tiene más sentido, dos clientes en mi aplicación

347
00:16:57,450 --> 00:16:59,049
son iguales

348
00:16:59,049 --> 00:17:00,629
Si su nombre es igual

349
00:17:00,629 --> 00:17:02,009
Eso tiene mucho más sentido

350
00:17:02,009 --> 00:17:05,970
Este sentido no es un sentido real

351
00:17:05,970 --> 00:17:08,950
Yo puedo tener en mi aplicación

352
00:17:08,950 --> 00:17:09,970
Dos personas

353
00:17:09,970 --> 00:17:11,769
Con el mismo DNI

354
00:17:11,769 --> 00:17:14,630
Porque una la he cargado de la base de datos

355
00:17:14,630 --> 00:17:15,230
En un momento

356
00:17:15,230 --> 00:17:18,490
Y otra la he cargado después de otra base de datos

357
00:17:18,490 --> 00:17:20,569
Tengo dos objetos distintos

358
00:17:20,569 --> 00:17:22,549
Pero el DNI es igual

359
00:17:22,549 --> 00:17:25,269
Entonces si yo llamo a este equals

360
00:17:25,269 --> 00:17:26,430
Para ver si uno es otro

361
00:17:26,430 --> 00:17:28,049
Me va a decir no, no, son dos personas distintas

362
00:17:28,049 --> 00:17:30,269
la aplicación funcionaría mal

363
00:17:30,269 --> 00:17:32,930
porque aunque esté cargada en objetos distintos

364
00:17:32,930 --> 00:17:34,369
se refiere a la misma

365
00:17:34,369 --> 00:17:36,630
se refiere a la misma persona, mismo DNI

366
00:17:36,630 --> 00:17:37,789
aunque estén objetos diferentes

367
00:17:37,789 --> 00:17:40,490
luego, en casos así

368
00:17:40,490 --> 00:17:42,750
cuando yo ya estoy haciendo la aplicación bien, la estoy diseñando

369
00:17:42,750 --> 00:17:44,230
bien, tendría que ver, oye, ojo

370
00:17:44,230 --> 00:17:45,970
que el método equals

371
00:17:45,970 --> 00:17:48,750
que heredo de object es que no me interesa

372
00:17:48,750 --> 00:17:50,549
porque cuando yo quiera ver

373
00:17:50,549 --> 00:17:52,950
si un cliente es igual que otro cliente

374
00:17:52,950 --> 00:17:54,269
me va a decir false

375
00:17:54,269 --> 00:17:56,230
aunque tenga el mismo DNI, me va a decir false

376
00:17:56,230 --> 00:17:57,650
entonces esta versión no me interesa

377
00:17:57,650 --> 00:18:00,269
vale, pues por eso, ¿qué hacemos a veces?

378
00:18:01,089 --> 00:18:02,089
en la clase

379
00:18:02,089 --> 00:18:04,349
que le dé de object, sobreescribir

380
00:18:04,349 --> 00:18:04,990
este método

381
00:18:04,990 --> 00:18:07,190
sobreescribir el equals

382
00:18:07,190 --> 00:18:09,849
este de aquí, sobreescribir este

383
00:18:09,849 --> 00:18:11,190
¿vale?

384
00:18:11,730 --> 00:18:14,009
entonces aquí en mi aplicación, si yo quiero

385
00:18:14,009 --> 00:18:15,769
incluir que

386
00:18:15,769 --> 00:18:17,529
cuando tenga dos objetos

387
00:18:17,529 --> 00:18:19,450
que vete a saber de dónde han salido

388
00:18:19,450 --> 00:18:21,170
de dónde se han leído, de dónde se han pasado

389
00:18:21,170 --> 00:18:23,809
si son el mismo DNI, entonces quiero

390
00:18:23,809 --> 00:18:25,910
que la aplicación entienda que es el mismo cliente

391
00:18:25,910 --> 00:18:27,589
porque son el mismo DNI y el mismo cliente

392
00:18:27,589 --> 00:18:29,509
Aunque esté cargado en varios objetos distintos

393
00:18:29,509 --> 00:18:31,369
Pues si quiero que entienda eso

394
00:18:31,369 --> 00:18:34,410
Tengo que sobreescribir el método equals

395
00:18:34,410 --> 00:18:35,549
¿Vale?

396
00:18:35,670 --> 00:18:37,349
Pues sobreescribo el método equals

397
00:18:37,349 --> 00:18:39,309
Que tiene exactamente esta cabecera

398
00:18:39,309 --> 00:18:45,279
Sobreescribo el método equals

399
00:18:45,279 --> 00:18:46,680
¿Veis? Me aparece aquí el verdecito

400
00:18:46,680 --> 00:18:48,700
Y aquí ya digo

401
00:18:48,700 --> 00:18:50,799
Oye, ¿qué quiero yo?

402
00:18:51,440 --> 00:18:52,720
¿Cuándo quiero que me devuelva true?

403
00:18:52,759 --> 00:18:53,740
¿Y cuándo quiero que me devuelva false?

404
00:18:53,819 --> 00:18:54,759
¿Quiero que me devuelva true?

405
00:18:55,279 --> 00:18:56,960
Si los dos de ne son iguales

406
00:18:56,960 --> 00:18:58,880
Y quiero que me devuelva false si no

407
00:18:58,880 --> 00:19:01,099
pues entonces yo aquí ya podría poner

408
00:19:01,099 --> 00:19:02,359
return

409
00:19:02,359 --> 00:19:04,339
dis.dni

410
00:19:04,339 --> 00:19:06,640
igual a

411
00:19:06,640 --> 00:19:08,339
bueno el objeto obj

412
00:19:08,339 --> 00:19:11,039
tendría que hacer un casting

413
00:19:11,039 --> 00:19:12,359
a cliente

414
00:19:12,359 --> 00:19:15,019
porque yo aquí puedo mandar

415
00:19:15,019 --> 00:19:16,759
un objeto genérico

416
00:19:16,759 --> 00:19:19,079
pero se supone que yo quiero comparar cuando un objeto

417
00:19:19,079 --> 00:19:20,980
sea igual a otro, luego le pasaría un cliente

418
00:19:20,980 --> 00:19:23,240
como aquí le paso un cliente

419
00:19:23,240 --> 00:19:24,960
este cliente de aquí

420
00:19:24,960 --> 00:19:27,319
para ver si este es igual que este

421
00:19:27,319 --> 00:19:57,180
Vale, entonces, me hago el casting a cliente de este objeto y ahora ya devuelvo esta igualdad, vj.dn.

422
00:19:57,180 --> 00:20:00,259
vale, entonces

423
00:20:00,259 --> 00:20:02,799
esto es un string y esto es un string

424
00:20:02,799 --> 00:20:05,660
vj, no, perdón

425
00:20:05,660 --> 00:20:09,730
esto es un string

426
00:20:09,730 --> 00:20:11,349
que es el dni del objeto en el que estoy

427
00:20:11,349 --> 00:20:12,190
que llama al método

428
00:20:12,190 --> 00:20:15,250
y este es otro string, que es el dni del pasado

429
00:20:15,250 --> 00:20:17,230
como parámetro, que lo he hecho el casting

430
00:20:17,230 --> 00:20:19,450
para poder hacer la propia dni, porque si no hago el casting

431
00:20:19,450 --> 00:20:20,630
no puedo hacer la propia dni

432
00:20:20,630 --> 00:20:23,049
vale, de nuevo string

433
00:20:23,049 --> 00:20:24,730
son objetos

434
00:20:24,730 --> 00:20:26,910
esto ya sí que de toda la vida hacemos

435
00:20:26,910 --> 00:20:29,029
cuando quiero ver si un string es igual que otro

436
00:20:29,029 --> 00:20:30,890
llamamos a equals

437
00:20:30,890 --> 00:20:32,809
y ahora ya podemos entender

438
00:20:32,809 --> 00:20:34,609
porque en la clase string llamamos a equals

439
00:20:34,609 --> 00:20:35,450
sino el doble igual

440
00:20:35,450 --> 00:20:38,589
porque cuando yo quiero comparar dos cadenas

441
00:20:38,589 --> 00:20:40,829
quiero comparar si tienen el mismo texto

442
00:20:40,829 --> 00:20:42,690
quiero comparar si una cadena es

443
00:20:42,690 --> 00:20:44,809
hola Pepito y hola Pepito

444
00:20:44,809 --> 00:20:46,809
pero no quiero, me da igual

445
00:20:46,809 --> 00:20:48,529
que estén en la misma posición de memoria

446
00:20:48,529 --> 00:20:50,009
o que estén en distinta, me da igual

447
00:20:50,009 --> 00:20:52,589
lo que yo quiero es comparar si

448
00:20:52,589 --> 00:20:54,869
aquí pone hola Pepito y aquí pone hola Pepito

449
00:20:54,869 --> 00:20:56,950
Entonces, la clase string

450
00:20:56,950 --> 00:20:58,809
Como hereda de object

451
00:20:58,809 --> 00:21:00,650
La clase string

452
00:21:00,650 --> 00:21:03,369
Ha implementado su propia versión de equals

453
00:21:03,369 --> 00:21:04,069
¿Vale?

454
00:21:04,569 --> 00:21:05,970
Entonces, la clase string

455
00:21:05,970 --> 00:21:08,269
Si uno la abriera por aquí

456
00:21:08,269 --> 00:21:17,240
La clase string

457
00:21:17,240 --> 00:21:18,160
Que está aquí abajo

458
00:21:18,160 --> 00:21:22,759
¿Vale? Hereda de object

459
00:21:22,759 --> 00:21:24,079
Como todas las clases del mundo

460
00:21:24,079 --> 00:21:27,259
¿Vale? Y aparte implementa cosas

461
00:21:27,259 --> 00:21:28,359
Pero eso ahora lo entenderemos

462
00:21:28,359 --> 00:21:30,000
Hereda de object como todas las del mundo

463
00:21:30,000 --> 00:21:32,339
No tiene ningún stance de nadie, pues hereda de object

464
00:21:32,339 --> 00:21:34,980
vale, y entonces

465
00:21:34,980 --> 00:21:36,940
su equals sería

466
00:21:36,940 --> 00:21:38,940
el feo, el equals de

467
00:21:38,940 --> 00:21:40,720
string sería el que te dice que

468
00:21:40,720 --> 00:21:43,039
este string está en la misma posición de memoria

469
00:21:43,039 --> 00:21:44,380
que el otro, el mismo, no encima de otro

470
00:21:44,380 --> 00:21:46,519
no es el string que queremos

471
00:21:46,519 --> 00:21:49,019
no es el equals que queremos, el equals de string

472
00:21:49,019 --> 00:21:51,079
es, oye, quiero saber si este texto

473
00:21:51,079 --> 00:21:52,819
es igual que este texto

474
00:21:52,819 --> 00:21:54,680
me da igual que estén en posiciones de memoria distintas

475
00:21:54,680 --> 00:21:56,400
pues por eso la clase string

476
00:21:56,400 --> 00:21:58,619
tiene su propia versión de

477
00:21:58,619 --> 00:22:01,180
equals, que estará por ahí

478
00:22:01,180 --> 00:22:09,119
que es esta

479
00:22:09,119 --> 00:22:10,339
¿Vale?

480
00:22:11,779 --> 00:22:13,079
¿Ves? Sobrescribe

481
00:22:13,079 --> 00:22:14,799
Sobrescribe

482
00:22:14,799 --> 00:22:17,339
el equals de object

483
00:22:17,339 --> 00:22:19,500
y lo sobrescribe diciendo

484
00:22:19,500 --> 00:22:21,339
oye, no, yo quiero ver si todos

485
00:22:21,339 --> 00:22:23,359
los caracteres, bueno, se hace

486
00:22:23,359 --> 00:22:24,480
todas estas cosas raras

487
00:22:24,480 --> 00:22:27,500
si el objeto que me pasas aquí

488
00:22:27,500 --> 00:22:28,680
es un string

489
00:22:28,680 --> 00:22:30,759
pues entonces haces todo esto

490
00:22:30,759 --> 00:22:32,099
patatín, patatán y ya

491
00:22:32,099 --> 00:22:34,539
es una versión propia suya

492
00:22:34,539 --> 00:22:35,480
para la clase string

493
00:22:35,480 --> 00:22:36,920
la versión suya de stream

494
00:22:36,920 --> 00:22:39,200
vale, pues entonces

495
00:22:39,200 --> 00:22:41,579
estábamos ahora haciéndonos nuestra

496
00:22:41,579 --> 00:22:43,519
versión propia de equals

497
00:22:43,519 --> 00:22:45,539
para cliente, para no tener la heredera de

498
00:22:45,539 --> 00:22:47,539
object, bueno pues nuestra versión

499
00:22:47,539 --> 00:22:49,519
es, oye devuélveme true

500
00:22:49,519 --> 00:22:51,400
si el dni

501
00:22:51,400 --> 00:22:53,279
del objeto que llama al método

502
00:22:53,279 --> 00:22:55,319
es igual que

503
00:22:55,319 --> 00:22:56,440
el parámetro

504
00:22:56,440 --> 00:22:59,440
ya tengo mi versión de equals, luego otro ejemplo

505
00:22:59,440 --> 00:23:01,440
más de por qué necesitamos

506
00:23:01,440 --> 00:23:01,940
la herencia

507
00:23:01,940 --> 00:23:05,400
vale, entonces el método equals

508
00:23:05,400 --> 00:23:07,599
este es el método más usado

509
00:23:07,599 --> 00:23:09,480
y más polimórfico del mundo, cuando tú llamas

510
00:23:09,480 --> 00:23:11,380
a equals de un string, estás llamando a la versión de

511
00:23:11,380 --> 00:23:13,480
la clase string, cuando llamas a

512
00:23:13,480 --> 00:23:15,440
equals de cliente, estás llamando a este, cuando llamas

513
00:23:15,440 --> 00:23:16,279
a equals de no sé qué

514
00:23:16,279 --> 00:23:19,279
pero si no hubiera un equals

515
00:23:19,279 --> 00:23:21,259
propio, pues estaríamos llamando

516
00:23:21,259 --> 00:23:22,839
al equals este, de object

517
00:23:22,839 --> 00:23:24,920
que compara direcciones de memoria sin más

518
00:23:24,920 --> 00:23:27,779
entonces aquí en nuestro main de pruebas

519
00:23:27,779 --> 00:23:33,220
¿vale? en nuestro main de pruebas

520
00:23:33,220 --> 00:23:34,660
por ejemplo, vamos a poner

521
00:23:34,660 --> 00:23:37,640
aquí el DNI de este cliente

522
00:23:37,640 --> 00:23:38,579
te estás durmiendo, ¿verdad?

523
00:23:39,099 --> 00:23:40,440
no, no, me estoy durmiendo

524
00:23:40,440 --> 00:23:42,299
sí, te estás durmiendo

525
00:23:42,299 --> 00:23:45,039
¿estás qué?

526
00:23:45,259 --> 00:23:46,220
se me está quemando el cerebro

527
00:23:46,220 --> 00:23:52,160
vale, por ejemplo

528
00:23:52,160 --> 00:23:54,500
íbamos a comparar este cliente

529
00:23:54,500 --> 00:23:55,980
con el DNI1, con este C

530
00:23:55,980 --> 00:23:57,039
que estaba aquí arriba

531
00:23:57,039 --> 00:23:58,859
que este C

532
00:23:58,859 --> 00:24:01,900
o lo habíamos puesto a null, vamos a ponerle

533
00:24:01,900 --> 00:24:04,599
no, el mismo

534
00:24:04,599 --> 00:24:06,660
para ver que, vale, entonces

535
00:24:06,660 --> 00:24:08,839
este c

536
00:24:08,839 --> 00:24:10,059
es un objeto que está por ahí

537
00:24:10,059 --> 00:24:11,400
con sus propiedades

538
00:24:11,400 --> 00:24:14,759
¿vale? y este otro

539
00:24:14,759 --> 00:24:16,940
cli es otro objeto que está por ahí con sus propiedades

540
00:24:16,940 --> 00:24:18,700
pero los dos tienen el mismo dna

541
00:24:18,700 --> 00:24:20,339
luego cuando yo

542
00:24:20,339 --> 00:24:22,359
mire a ver si uno es igual que otro porque lo

543
00:24:22,359 --> 00:24:24,500
necesita para, porque mi aplicación

544
00:24:24,500 --> 00:24:26,559
quiere hacer la comprobación que sea lo que sea

545
00:24:26,559 --> 00:24:28,400
porque quiero ver si hay duplicados para

546
00:24:28,400 --> 00:24:30,359
quitar uno, si no estar, vale

547
00:24:30,359 --> 00:24:32,559
para lo que sea, si quiere ver que uno es igual que otro

548
00:24:32,559 --> 00:24:34,539
pues hará esto, y como tenemos

549
00:24:34,539 --> 00:24:36,759
sobrescrito equals, pues

550
00:24:36,759 --> 00:24:38,759
ahora aquí nos dice true.

551
00:24:38,880 --> 00:24:40,019
Son iguales. ¿Vale?

552
00:24:40,559 --> 00:24:42,720
Pero si no hubiéramos sobrescrito

553
00:24:42,720 --> 00:24:44,579
el método equals aquí,

554
00:24:44,900 --> 00:24:46,200
si no lo hubiéramos sobrescrito,

555
00:24:46,779 --> 00:24:51,690
porque no nos hubiéramos acordado

556
00:24:51,690 --> 00:24:53,230
de sobrescribirlo

557
00:24:53,230 --> 00:24:55,529
y nuestra aplicación va a necesitar a veces

558
00:24:55,529 --> 00:24:57,049
ver si un cliente es igual a otro.

559
00:24:57,529 --> 00:24:59,210
O sea, si la aplicación no lo necesita, no es grave.

560
00:24:59,710 --> 00:25:01,369
Pero si mi aplicación va a necesitar a veces

561
00:25:01,369 --> 00:25:03,670
ver si un cliente es igual a otro y a mí se me ha olvidado

562
00:25:03,670 --> 00:25:05,410
sobrescribir mi propia versión

563
00:25:05,410 --> 00:25:06,549
de equals, la buena,

564
00:25:07,130 --> 00:25:10,210
la que yo decida por DNI, por nombre, si se me ha olvidado,

565
00:25:10,750 --> 00:25:15,390
ahora mi aplicación va a funcionar igual, pero me dice, no, no son iguales.

566
00:25:15,509 --> 00:25:19,410
Vale, y yo sigo procediendo, sigo haciendo cosas sobre un supuesto falso.

567
00:25:19,829 --> 00:25:23,250
Porque este cliente y este sí que son, son iguales.

568
00:25:23,630 --> 00:25:27,470
Pero sin haber sobrescrito el equals me dice que son distintos, me dice falso,

569
00:25:27,890 --> 00:25:30,950
porque este es un objeto en una dirección de memoria

570
00:25:30,950 --> 00:25:34,190
y este es otro en otra dirección de memoria.

571
00:25:36,029 --> 00:25:36,730
¿Está claro?

572
00:25:37,130 --> 00:25:49,470
Vale, pues ahora entonces, gracias a la herencia, entendemos un poco más el equals de dónde sale y la importancia de sobrescribirlo en nuestras clases si vamos a necesitar ver si un objeto es igual a otro según un criterio propio.

573
00:25:50,650 --> 00:25:54,089
Vale, string ya lo tiene sobrescrito, por eso lo usamos siempre sin más, etc.

574
00:25:55,890 --> 00:26:06,130
Vale, todo esto venía a cuenta del object, que aunque nosotros no lo veamos y no lo sepamos, cualquier clase hereda de object y tiene todo lo de object.

575
00:26:06,130 --> 00:26:13,230
Y si hereda de otra, también lo va a tener, porque recordad que el árbol este de herencia, si esta hereda de esta, tiene todo lo de esta.

576
00:26:13,710 --> 00:26:18,250
Ahora, esta de aquí hereda de esta, pues tiene todo lo de esta, que a su vez tenía todo lo de la de arriba.

577
00:26:18,769 --> 00:26:21,930
Luego cada uno tiene todo lo de su padre, abuelo, bisabuelo, etcétera, etcétera.

578
00:26:23,450 --> 00:26:30,769
Bueno, pues todo esto venía a cuento de la clase object, que es la base de toda la jerarquía de clases,

579
00:26:30,769 --> 00:26:33,349
que se nos quedaba

580
00:26:33,349 --> 00:26:35,470
corto, porque puede haber clases

581
00:26:35,470 --> 00:26:37,329
que interese

582
00:26:37,329 --> 00:26:38,950
que adopten

583
00:26:38,950 --> 00:26:43,230
funcionalidades de dos clases

584
00:26:43,230 --> 00:26:43,970
distintas

585
00:26:43,970 --> 00:26:46,789
y yo no puedo fusionarlas

586
00:26:46,789 --> 00:26:50,970
porque por ejemplo, hay situaciones en las que sí

587
00:26:50,970 --> 00:26:52,430
uno podría

588
00:26:52,430 --> 00:26:55,349
a ver, que se nos ocurre

589
00:26:55,349 --> 00:26:57,410
vale, pues imaginaos

590
00:26:57,410 --> 00:27:00,390
un zoológico

591
00:27:00,390 --> 00:27:02,089
en el tiempo de los robots

592
00:27:02,089 --> 00:27:03,690
dentro de 300 años

593
00:27:03,690 --> 00:27:06,230
entonces, claro, los robots

594
00:27:06,230 --> 00:27:07,970
dominan el mundo y tienen su zoológico

595
00:27:07,970 --> 00:27:10,410
donde tenemos humanos y animales

596
00:27:10,410 --> 00:27:11,930
o sea, animales en general

597
00:27:11,930 --> 00:27:12,529
¿vale?

598
00:27:13,170 --> 00:27:13,809
entonces

599
00:27:13,809 --> 00:27:18,410
los humanos y los animales no humanos

600
00:27:18,410 --> 00:27:20,710
pues en principio

601
00:27:20,710 --> 00:27:24,089
tienen características distintas

602
00:27:24,089 --> 00:27:25,109
podría decir

603
00:27:25,109 --> 00:27:26,130
entonces

604
00:27:26,130 --> 00:27:28,210
se podría hacer

605
00:27:28,210 --> 00:27:30,349
una clase, humanos

606
00:27:30,349 --> 00:27:32,210
hay, pues yo que sé

607
00:27:32,210 --> 00:27:33,730
humanos

608
00:27:33,730 --> 00:27:36,309
no lo sé, españoles

609
00:27:36,309 --> 00:27:38,710
franceses, alemanes, entonces para eso es una clase

610
00:27:38,710 --> 00:27:40,549
se puede hacer una super clase

611
00:27:40,549 --> 00:27:42,569
humano general, con todo lo que tenga

612
00:27:42,569 --> 00:27:44,130
humano, y luego ya cada uno pues

613
00:27:44,130 --> 00:27:45,809
mujeres, hombres, lo que sea

614
00:27:45,809 --> 00:27:47,990
con animales igual

615
00:27:47,990 --> 00:27:50,230
gatos, perros, caballos, una super clase

616
00:27:50,230 --> 00:27:51,930
animal, pero a su vez

617
00:27:51,930 --> 00:27:54,470
si dejamos la jerarquía

618
00:27:54,470 --> 00:27:56,029
por separado pues habrá cosas

619
00:27:56,029 --> 00:27:58,170
que comparten los dos

620
00:27:58,170 --> 00:27:59,750
los humanos y los animales

621
00:27:59,750 --> 00:28:00,970
pues todos tienen

622
00:28:00,970 --> 00:28:06,250
todos comen y todos cagan

623
00:28:06,250 --> 00:28:08,210
bueno vale pues comer

624
00:28:08,210 --> 00:28:09,630
vale pues entonces

625
00:28:09,630 --> 00:28:11,849
ahí

626
00:28:11,849 --> 00:28:14,069
se podría solucionar haciendo una

627
00:28:14,069 --> 00:28:16,369
super clase de estas dos por separadas

628
00:28:16,369 --> 00:28:17,430
de humano y de animal

629
00:28:17,430 --> 00:28:20,009
pues se hace una super clase que es

630
00:28:20,009 --> 00:28:21,789
miembro del zoo por ejemplo

631
00:28:21,789 --> 00:28:23,250
entonces se pueden solucionar

632
00:28:23,250 --> 00:28:24,950
pero claro

633
00:28:24,950 --> 00:28:28,450
y todos hacen todo lo que haya en miembro del zoo

634
00:28:28,450 --> 00:28:30,730
pero podría haber situaciones que no sean fáciles

635
00:28:30,730 --> 00:28:31,650
de solucionar así, por ejemplo

636
00:28:31,650 --> 00:28:33,309
los robots

637
00:28:33,309 --> 00:28:36,690
como son peores personajes

638
00:28:36,690 --> 00:28:38,450
que nosotros, pues también meten

639
00:28:38,450 --> 00:28:40,609
en su propio zoológico a robots

640
00:28:40,609 --> 00:28:41,569
por ejemplo

641
00:28:41,569 --> 00:28:44,869
entonces el zoológico de los robots del futuro

642
00:28:44,869 --> 00:28:46,450
tiene robots

643
00:28:46,450 --> 00:28:48,130
humanos y animales

644
00:28:48,130 --> 00:28:50,769
¿vale? a ver que no me pierda

645
00:28:50,769 --> 00:28:51,029
yo

646
00:28:51,029 --> 00:29:01,410
Entonces, esto es para que entiendas una situación, como puede haber tantas, en las cuales necesitas herencia múltiple, ¿vale?

647
00:29:01,650 --> 00:29:09,710
Entonces, ¿qué ocurre aquí? Que los humanos y los robots hablan, los animales no.

648
00:29:09,710 --> 00:29:13,150
¿Tú no sabes que los animales hablan también, no?

649
00:29:13,269 --> 00:29:15,869
No, los del zoológico y los robots no hablan.

650
00:29:15,869 --> 00:29:16,089
¿Los zoológicos?

651
00:29:16,809 --> 00:29:17,849
No, esos no hablan.

652
00:29:17,890 --> 00:29:19,670
Yo te juro que te pongo hasta los robots, sí.

653
00:29:19,670 --> 00:29:31,430
bueno pero le ponemos directamente la parte de animalitos dóciles vale entonces qué ocurre que

654
00:29:31,430 --> 00:29:39,710
ahí pone hacer la jerarquía con una superclase miembro del zoo pues hombre no se adapta porque

655
00:29:39,710 --> 00:29:47,509
el método hablar vale el método de hablar pues solamente lo tienen los humanos y los robots pero

656
00:29:47,509 --> 00:29:49,869
Sin embargo, no queremos que lo tengan los animales,

657
00:29:50,089 --> 00:29:51,490
pero si hay cosas que tienen compartida.

658
00:29:52,130 --> 00:29:54,470
Entonces, a lo mejor podríamos hacer una superclase

659
00:29:54,470 --> 00:29:59,309
habladores, con todas las cosas relacionadas con hablar,

660
00:29:59,410 --> 00:30:00,549
porque se trata de forma distinta.

661
00:30:01,190 --> 00:30:03,490
Entonces, humanos y robots queremos que hereden de

662
00:30:03,490 --> 00:30:05,269
habladores, pero animales no queremos que hereden de

663
00:30:05,269 --> 00:30:07,710
habladores, porque todo relacionado con habladores es

664
00:30:07,710 --> 00:30:09,730
mucho y no queremos que lo hereden porque es meter ahí un

665
00:30:09,730 --> 00:30:13,930
montón de cosas que podemos luego a lo mejor usarlas por no

666
00:30:13,930 --> 00:30:16,150
ser cuidadosos y la hemos cagado con la aplicación.

667
00:30:17,509 --> 00:30:20,430
Entonces, esto se le dan de animal, sin más.

668
00:30:21,049 --> 00:30:23,910
Pero a su vez queremos que todos hereden de la superclase

669
00:30:23,910 --> 00:30:26,029
que tiene todo relacionado con comer, con cagar, etc.

670
00:30:26,670 --> 00:30:28,009
Entonces, ¿cómo resolvemos eso?

671
00:30:28,390 --> 00:30:29,509
Pues se queda muy complicado.

672
00:30:30,329 --> 00:30:31,450
Entonces, ¿cómo lo resolveríamos?

673
00:30:31,569 --> 00:30:35,789
Pues hacemos una superclase, que eso ahora lo vemos después,

674
00:30:35,789 --> 00:30:41,130
por ejemplo, pensada en todo lo que comparten todos

675
00:30:41,130 --> 00:30:42,230
de cara a su descripción.

676
00:30:42,750 --> 00:30:44,549
Propiedades que todos comparten, etc.

677
00:30:44,549 --> 00:31:11,250
Y luego ya, si alguna de esas entidades que hay abajo tienen características diferenciadas, las metemos en una interfaz, lo que se llama una interfaz, y ahora de esas subclases, las que tengan esa característica diferencial, que además, en nuestro caso, que sería hablar, todo lo de animales, pero además hablar, pues esas que implementen esta interfaz que acabo de hacer.

678
00:31:11,250 --> 00:31:33,509
Entonces, tendría animales que heredan de, perdón, sí, gatos, perros, no sé qué, que heredan de animal, ¿vale? Luego, además, tendría humanos que heredan de animal, ¿vale? Robot no puede heredar de animal, ¿vale? Y luego tendría robot y humano que implementa habladores, ¿vale?

679
00:31:33,509 --> 00:31:39,849
Entonces puedo flexibilizar muchísimo mi jerarquía gracias a esto de las interfaces.

680
00:31:40,329 --> 00:31:43,109
Y decido, vale, tú le das de aquí, pero además implementas esto,

681
00:31:43,190 --> 00:31:45,710
con lo cual tienes esto de aquí, pero te comportas de esta manera,

682
00:31:45,829 --> 00:31:48,470
que el otro no se puede comportar así, el animal no puede hablar,

683
00:31:48,589 --> 00:31:51,250
luego no puedo implementar esto, pero tú sí tienes lo suyo,

684
00:31:51,349 --> 00:31:52,609
luego le das de su superclase.

685
00:31:53,390 --> 00:31:55,349
Bueno, más o menos.

686
00:31:55,650 --> 00:31:58,349
Yo a ti lo dibujo como si fuese un arbolito porque...

687
00:31:59,049 --> 00:32:03,289
Sí, pero no se nota, ¿no? O sí se nota.

688
00:32:03,509 --> 00:32:05,390
Sí, se nota un poco que me estoy perdiendo, ¿no?

689
00:32:05,829 --> 00:32:09,410
Por eso, si quieres, dibújalo ahí con palitos y cuadraditos.

690
00:32:09,809 --> 00:32:14,509
Sí, más que dibujarlo, vamos a poner un ejemplo ahora de cómo son las interfaces,

691
00:32:14,750 --> 00:32:18,809
cómo se, bueno, ahora o después, cómo se programa una interfaz,

692
00:32:18,950 --> 00:32:20,950
cómo se implementa una interfaz y cómo se usa.

693
00:32:21,109 --> 00:32:22,150
Ya está, un ejemplito.

694
00:32:23,690 --> 00:32:28,170
Y luego ya, sobre todo a nosotros, lo que nos importa sobre todo,

695
00:32:28,170 --> 00:32:32,829
es que este concepto

696
00:32:32,829 --> 00:32:35,049
de interfaces, clases y clases abstractas

697
00:32:35,049 --> 00:32:35,950
que ya vimos el otro día

698
00:32:35,950 --> 00:32:38,210
es sobre el que se diseña todo

699
00:32:38,210 --> 00:32:39,869
entonces nosotros a partir de ahora

700
00:32:39,869 --> 00:32:41,210
¿qué vamos a usar?

701
00:32:41,809 --> 00:32:43,430
vamos a usar un montón de paquetes

702
00:32:43,430 --> 00:32:46,710
por ejemplo, todo el que gestiona las excepciones

703
00:32:46,710 --> 00:32:49,269
todo el que gestiona las colecciones

704
00:32:49,269 --> 00:32:51,789
todo el que gestiona las interfaces gráficas

705
00:32:51,789 --> 00:32:52,630
vamos a usarlo

706
00:32:52,630 --> 00:32:54,849
pues todos esos paquetes están todos

707
00:32:54,849 --> 00:32:56,690
metidos en una jerarquía

708
00:32:56,690 --> 00:32:58,589
de interfaces y clases abstractas y clases

709
00:32:58,589 --> 00:33:00,190
normales. Ahí es un sumo bollón.

710
00:33:00,630 --> 00:33:01,650
Entonces tenemos que entender

711
00:33:01,650 --> 00:33:04,549
cómo se usa un montón de

712
00:33:04,549 --> 00:33:06,549
clases que tienen jerarquías entre ellas.

713
00:33:07,170 --> 00:33:08,609
Nos interesa eso más

714
00:33:08,609 --> 00:33:10,450
que hacer la parte

715
00:33:10,450 --> 00:33:12,650
de diseño, que es tengo una situación

716
00:33:12,650 --> 00:33:14,390
que diseño me

717
00:33:14,390 --> 00:33:16,490
queda bien, que no sé qué, más que eso.

718
00:33:16,809 --> 00:33:18,150
Sobre todo lo que nos interesa es entender

719
00:33:18,150 --> 00:33:20,710
cómo poder usar un montón de clases

720
00:33:20,710 --> 00:33:22,569
que están relacionadas de esa manera, como las

721
00:33:22,569 --> 00:33:23,950
excepciones, colecciones, etc.

722
00:33:25,890 --> 00:33:26,369
¿Entendido?

723
00:33:26,690 --> 00:33:31,410
Pues hala, idos a comer que es lo que más os gusta hacer