1
00:00:00,370 --> 00:00:06,530
Sigo grabando, si decís algo es porque queréis y por lo tanto me autorizáis

2
00:00:06,530 --> 00:00:12,890
Vale, hemos hecho este ejercicio rápidamente, vamos a ver más

3
00:00:12,890 --> 00:00:17,929
Primero, existe una jerarquía de herencia en Java

4
00:00:17,929 --> 00:00:23,030
Que quiere decir que como cada clase puede heredar de otra

5
00:00:23,030 --> 00:00:26,750
Se crea una jerarquía, un árbol

6
00:00:26,750 --> 00:00:29,269
Donde una persona hereda

7
00:00:29,269 --> 00:00:31,870
Que sea un alumno

8
00:00:31,870 --> 00:00:33,109
Hereda de persona

9
00:00:33,109 --> 00:00:34,270
Que hereda de no se que

10
00:00:34,270 --> 00:00:35,350
Que hereda de no se cuanto

11
00:00:35,350 --> 00:00:39,149
Todos los objetos en Java

12
00:00:39,149 --> 00:00:41,310
Por defecto

13
00:00:41,310 --> 00:00:43,030
Sin que vosotros lo escribáis

14
00:00:43,030 --> 00:00:45,429
Heredan de la clase

15
00:00:45,429 --> 00:00:46,770
Object

16
00:00:46,770 --> 00:00:48,549
Entonces

17
00:00:48,549 --> 00:00:50,030
Todos los objetos

18
00:00:50,030 --> 00:00:52,789
Que vosotros creéis en vuestra vida

19
00:00:52,789 --> 00:00:54,350
Esa

20
00:00:54,350 --> 00:00:56,689
Es un object

21
00:00:56,689 --> 00:01:03,649
Existe esta clase super padre

22
00:01:03,649 --> 00:01:07,129
Que todos los objetos, todas las clases derivan de aquí

23
00:01:07,129 --> 00:01:12,790
Y por lo tanto todos los objetos en Java comparten algunas características

24
00:01:12,790 --> 00:01:18,329
Algunos métodos, algunas partes de información

25
00:01:18,329 --> 00:01:22,450
Porque todos importan desde el objeto

26
00:01:22,450 --> 00:01:24,489
hasta si yo no escribo nada

27
00:01:24,489 --> 00:01:25,969
pues en automático

28
00:01:25,969 --> 00:01:28,629
extiende objeto

29
00:01:28,629 --> 00:01:30,329
¿vale? si yo extiendo

30
00:01:30,329 --> 00:01:32,329
desde alumno extiendo persona y persona

31
00:01:32,329 --> 00:01:34,209
no extiende nada, persona extiende objeto

32
00:01:34,209 --> 00:01:36,030
y por lo tanto estoy extendiendo también

33
00:01:36,030 --> 00:01:36,689
objeto

34
00:01:36,689 --> 00:01:40,510
por lo tanto cualquier clase

35
00:01:40,510 --> 00:01:42,049
está extendiendo objeto

36
00:01:42,049 --> 00:01:42,689
¿sí?

37
00:01:44,510 --> 00:01:45,930
una clase puede o heredar

38
00:01:45,930 --> 00:01:47,909
explícitamente de otra clase como

39
00:01:47,909 --> 00:01:48,790
si yo ahora de

40
00:01:48,790 --> 00:01:51,590
alumno extiende

41
00:01:51,590 --> 00:01:58,670
persona o heredar implícitamente de la clase object. Si no escribo nada, en automático estoy

42
00:01:58,670 --> 00:02:10,889
utilizando el evento. Y por lo tanto se me crea toda una estructura de todo lo que hemos visto nosotros. Por ejemplo, string puede ser de no sé quién que heredará de object.

43
00:02:10,889 --> 00:02:15,030
A este punto

44
00:02:15,030 --> 00:02:17,430
Vamos a mirar una cosa

45
00:02:17,430 --> 00:02:21,490
Que va a ser de interés

46
00:02:21,490 --> 00:02:22,990
Vuestro desde ahora

47
00:02:22,990 --> 00:02:24,330
Para el resto de vuestra vida

48
00:02:24,330 --> 00:02:26,250
Que se llama la API de Java

49
00:02:26,250 --> 00:02:29,289
La API de Java es

50
00:02:29,289 --> 00:02:31,229
Sostancialmente, nosotros hemos visto

51
00:02:31,229 --> 00:02:32,810
Un par de clases o tres como

52
00:02:32,810 --> 00:02:34,909
Scanner, String

53
00:02:34,909 --> 00:02:36,330
Etcétera, etcétera

54
00:02:36,330 --> 00:02:39,069
Que son clases que nosotros utilizamos

55
00:02:39,069 --> 00:02:41,689
¿Vale? Pero no lo hemos hecho nosotros

56
00:02:41,689 --> 00:02:44,789
En ningún momento vosotros habéis hecho public class scanner

57
00:02:44,789 --> 00:02:46,330
Y os habéis puesto a programar

58
00:02:46,330 --> 00:02:49,250
O public class string y os habéis puesto a programar

59
00:02:49,250 --> 00:02:51,129
Pero la habéis podido utilizar

60
00:02:51,129 --> 00:02:55,870
Esto porque Java, en su paquete, digamos, de desarrollo

61
00:02:55,870 --> 00:03:00,189
Os incluye un mogollón de clases ya hechas

62
00:03:00,189 --> 00:03:01,969
Y que vosotros podéis utilizar

63
00:03:01,969 --> 00:03:04,789
Pero, ¿y estas clases cómo están hechas?

64
00:03:04,930 --> 00:03:06,949
¿Qué métodos tienen? ¿Qué parámetros tienen?

65
00:03:07,490 --> 00:03:08,150
No lo sé

66
00:03:08,150 --> 00:03:18,830
Y entonces me voy a Internet, busco Java API y el nombre de la clase que quiero mirar

67
00:03:18,830 --> 00:03:21,270
Por ejemplo en este caso queremos ver Object

68
00:03:21,270 --> 00:03:24,969
Al darle Intro me salen cosas así

69
00:03:24,969 --> 00:03:30,509
Y aquí por ejemplo tengo el API de Object

70
00:03:30,509 --> 00:03:34,650
Si me voy al API de Object obtengo una página parecida a esta

71
00:03:34,650 --> 00:03:39,310
Donde me dice, soy la clase object

72
00:03:39,310 --> 00:03:42,969
Pertenezco al paquete java.lang

73
00:03:42,969 --> 00:03:47,930
Mi nombre completo es java.lang.object

74
00:03:47,930 --> 00:03:50,110
Y soy el objeto

75
00:03:50,110 --> 00:03:54,189
La root of the class hierarchy

76
00:03:54,189 --> 00:03:58,310
La raíz de la jerarquía de clases

77
00:03:58,310 --> 00:04:02,770
Y aquí yo me puedo poner a mirar que tiene que ofrecer

78
00:04:02,770 --> 00:04:08,849
Por ejemplo, me ofrece el object sin parámetros, como constructor, ¿vale?

79
00:04:08,990 --> 00:04:14,409
Que es el constructor que siempre se llama cuando no hago un super, ¿vale?

80
00:04:14,909 --> 00:04:17,769
Porque por defecto estoy llamando a...

81
00:04:17,769 --> 00:04:20,930
Yo soy la clase, qué sé yo, ¿qué hemos hecho ahora?

82
00:04:20,990 --> 00:04:22,389
La clase dispositivo.

83
00:04:22,750 --> 00:04:25,290
Pues la clase dispositivo is a object.

84
00:04:25,790 --> 00:04:28,209
Porque hereda, extiende.

85
00:04:28,490 --> 00:04:31,889
Y por lo tanto, la primera cosa que se hace es llamar el constructor de object.

86
00:04:31,889 --> 00:04:33,149
Este constructor de aquí

87
00:04:33,149 --> 00:04:38,230
Que creará las cosas básicas para que tú puedas ser un objeto

88
00:04:38,230 --> 00:04:41,610
A partir de allí, pondrás todas las cosas que te interese a ti

89
00:04:41,610 --> 00:04:44,829
Pero esta es, digamos, una cosa escondida en nosotros

90
00:04:44,829 --> 00:04:48,790
Que se hace por defecto para crear un objeto

91
00:04:48,790 --> 00:04:52,189
Aquí se hará, aquí dentro, las cosas básicas

92
00:04:52,189 --> 00:04:54,589
Que tiene que hacer la Java Vector Machine

93
00:04:54,589 --> 00:04:57,589
Para poder crear un espacio de memoria donde crear un objeto

94
00:04:57,589 --> 00:05:03,490
Y también tiene un montón de

95
00:05:03,490 --> 00:05:05,490
Metoditos

96
00:05:05,490 --> 00:05:08,810
Y algunos de estos metoditos

97
00:05:08,810 --> 00:05:11,110
Los hemos visto

98
00:05:11,110 --> 00:05:12,389
En algún momento

99
00:05:12,389 --> 00:05:16,170
¿Os suena de algo?

100
00:05:17,170 --> 00:05:19,569
¿Os suena de algo?

101
00:05:24,699 --> 00:05:28,120
Estos métodos de aquí

102
00:05:28,120 --> 00:05:29,779
En particular el equals

103
00:05:29,779 --> 00:05:31,740
Y el toString

104
00:05:31,740 --> 00:05:33,600
Son métodos interesantes

105
00:05:33,600 --> 00:05:35,339
Porque los vamos a utilizar

106
00:05:35,339 --> 00:05:37,560
Sobrescribiéndolos

107
00:05:37,560 --> 00:05:39,779
En cuanto sepamos que es

108
00:05:39,779 --> 00:05:40,660
Sobrescribir

109
00:05:40,660 --> 00:05:42,699
Para que nuestros objetos

110
00:05:42,699 --> 00:05:44,420
Se comporten

111
00:05:44,420 --> 00:05:46,259
De alguna forma

112
00:05:46,259 --> 00:05:48,740
Por ejemplo, el método toString

113
00:05:48,740 --> 00:05:51,660
Devuelve una representación

114
00:05:51,660 --> 00:05:53,579
En formato de string del objeto

115
00:05:53,579 --> 00:05:58,160
Por defecto

116
00:05:58,160 --> 00:06:00,180
Si yo hago el toString

117
00:06:00,180 --> 00:06:02,620
Sobre cualquier objeto del mundo

118
00:06:02,620 --> 00:06:04,699
Sin haber dicho nada

119
00:06:04,699 --> 00:06:05,939
Me llama

120
00:06:05,939 --> 00:06:08,259
El método toString de object

121
00:06:08,259 --> 00:06:10,600
Yo tengo un dispositivo

122
00:06:10,600 --> 00:06:11,819
El dispositivo es un objeto

123
00:06:11,819 --> 00:06:13,939
Y por lo tanto cuando llamo el toString

124
00:06:13,939 --> 00:06:15,699
Sobre el dispositivo me pillará

125
00:06:15,699 --> 00:06:18,379
El de su padre que es object

126
00:06:18,379 --> 00:06:19,259
¿Vale?

127
00:06:20,180 --> 00:06:22,519
La, no sé si la habéis hecho alguna vez

128
00:06:22,519 --> 00:06:23,160
En vuestra vida

129
00:06:23,160 --> 00:06:25,600
Pero si vosotros pilláis un objeto

130
00:06:25,600 --> 00:06:27,180
El objeto

131
00:06:27,180 --> 00:06:28,579
De uno

132
00:06:28,579 --> 00:06:33,540
Y le decís, oye, me imprimes de uno en pantalla

133
00:06:33,540 --> 00:06:36,279
De uno, así

134
00:06:36,279 --> 00:06:38,740
¿Qué hace?

135
00:06:42,470 --> 00:06:43,069
Esto

136
00:06:43,069 --> 00:06:54,959
En realidad, Java no debería hacer nada

137
00:06:54,959 --> 00:06:59,399
Porque System.Auto.Println, ¿qué recibe aquí?

138
00:07:02,480 --> 00:07:03,399
Un dispositivo

139
00:07:03,399 --> 00:07:08,009
¿Qué ponemos normalmente aquí nosotros?

140
00:07:08,009 --> 00:07:11,009
¿Qué tipo de datos ponemos aquí?

141
00:07:11,470 --> 00:07:12,110
Un string

142
00:07:12,110 --> 00:07:14,290
Este señor

143
00:07:14,290 --> 00:07:15,550
Quiere aquí un string

144
00:07:15,550 --> 00:07:18,170
Sin embargo le estoy dando un dispositivo

145
00:07:18,170 --> 00:07:19,149
¿Y por qué no se queja?

146
00:07:21,149 --> 00:07:22,310
Porque en realidad

147
00:07:22,310 --> 00:07:25,670
Está haciendo esto

148
00:07:25,670 --> 00:07:30,139
Oye, cuidado, pero

149
00:07:30,139 --> 00:07:33,040
Esto yo no lo he declarado

150
00:07:33,040 --> 00:07:35,120
No está escrito en dispositivo

151
00:07:35,120 --> 00:07:36,939
En ningún lado el método toString

152
00:07:36,939 --> 00:07:39,980
¿De dónde saco este toString?

153
00:07:40,540 --> 00:07:46,439
De objeto, del objeto object

154
00:07:46,439 --> 00:07:50,759
Es este tu string de aquí

155
00:07:50,759 --> 00:07:54,709
¿Vale?

156
00:07:55,410 --> 00:07:57,129
Entonces, si yo no le digo nada

157
00:07:57,129 --> 00:07:59,490
Cualquier objeto tiene una forma

158
00:07:59,490 --> 00:08:02,029
Para transformarse en un string

159
00:08:02,029 --> 00:08:03,050
¿Vale?

160
00:08:03,509 --> 00:08:04,949
Como es el caso aquí

161
00:08:04,949 --> 00:08:07,790
Cuando Java dice

162
00:08:07,790 --> 00:08:09,829
Mira, aquí necesitaría un string

163
00:08:09,829 --> 00:08:11,389
Y tú me has puesto un objeto

164
00:08:11,389 --> 00:08:13,310
Como yo necesito un string

165
00:08:13,310 --> 00:08:15,529
Te lo voy a traducir a string

166
00:08:15,529 --> 00:08:18,110
Utilizando el método toString

167
00:08:18,110 --> 00:08:23,129
Que transforma tu objeto en una representación en formato string de tu objeto

168
00:08:23,129 --> 00:08:25,310
Y como tú no me has dicho

169
00:08:25,310 --> 00:08:30,189
Cómo se representa de forma string tu objeto

170
00:08:30,189 --> 00:08:31,649
Un objeto dispositivo

171
00:08:31,649 --> 00:08:36,330
Yo tiro de la representación genérica de un objeto

172
00:08:36,330 --> 00:08:39,769
Que es la representación en formato string que me da object

173
00:08:39,769 --> 00:08:41,250
El toString de object

174
00:08:41,250 --> 00:08:43,490
¿Queda claro?

175
00:08:43,490 --> 00:08:51,830
¿Y cómo podría hacer yo que mi dispositivo en vez de este código absurdo aquí

176
00:08:51,830 --> 00:08:53,169
¿Dónde está? No

177
00:08:53,169 --> 00:08:56,809
En vez de este código absurdo aquí

178
00:08:56,809 --> 00:09:03,929
Me dijera algo como soy un dispositivo con número serial no sé qué

179
00:09:03,929 --> 00:09:12,759
La forma sería irse al dispositivo y decir

180
00:09:12,759 --> 00:09:15,580
Oye mira el dispositivo por algún lado aquí

181
00:09:15,580 --> 00:09:19,360
Tú tienes un public string

182
00:09:19,360 --> 00:09:20,860
Porque tienes que devolver un string

183
00:09:20,860 --> 00:09:22,000
ToString

184
00:09:22,000 --> 00:09:25,799
Este método de aquí

185
00:09:25,799 --> 00:09:28,120
Espera que se han parado

186
00:09:28,120 --> 00:09:29,460
Ah, sí, no

187
00:09:29,460 --> 00:09:30,519
Tienes que devolver algo

188
00:09:30,519 --> 00:09:35,399
Entonces string s es igual a esto

189
00:09:35,399 --> 00:09:37,200
Return s

190
00:09:37,200 --> 00:09:41,110
Este método de aquí

191
00:09:41,110 --> 00:09:42,309
¿Es nuevo?

192
00:09:43,309 --> 00:09:47,139
No, existía ya

193
00:09:47,139 --> 00:09:48,120
¿Vale?

194
00:09:48,259 --> 00:09:49,980
Existía como object

195
00:09:49,980 --> 00:09:52,059
Y yo como este señor

196
00:09:52,059 --> 00:09:53,320
No importando nada

197
00:09:53,320 --> 00:09:54,460
Es como si estuviera

198
00:09:54,460 --> 00:09:56,679
StandsObject

199
00:09:56,679 --> 00:10:01,529
Por lo tanto ya lo tenía

200
00:10:01,529 --> 00:10:03,649
Este método, de hecho ya he podido llamarlo

201
00:10:03,649 --> 00:10:05,490
Sin codificarlo

202
00:10:05,490 --> 00:10:07,809
Pero como ahora lo he vuelto a escribir

203
00:10:07,809 --> 00:10:09,250
En un cierto sentido

204
00:10:09,250 --> 00:10:10,769
Esto borra

205
00:10:10,769 --> 00:10:13,230
Lo que es el toString

206
00:10:13,230 --> 00:10:14,570
Del object

207
00:10:14,570 --> 00:10:16,889
Y me pone este de aquí

208
00:10:16,889 --> 00:10:18,769
De hecho si yo ahora vuelvo

209
00:10:18,769 --> 00:10:20,730
¿Os acordáis que antes escribía esta cosa rara?

210
00:10:20,730 --> 00:10:22,509
Vale, si yo ahora vuelvo

211
00:10:22,509 --> 00:10:24,090
A lanzar esto, ¿qué me escribe?

212
00:10:26,860 --> 00:10:27,419
Nada

213
00:10:27,419 --> 00:10:31,750
Porque ahora cuando llama

214
00:10:31,750 --> 00:10:33,769
El toString, llama este

215
00:10:33,769 --> 00:10:35,570
ToString, y como este toString

216
00:10:35,570 --> 00:10:37,769
Dice nada, pues me devuelve

217
00:10:37,769 --> 00:10:38,049
Nada

218
00:10:38,049 --> 00:10:40,970
Pero yo lo puedo cambiar como

219
00:10:40,970 --> 00:10:43,769
Dispositivo

220
00:10:43,769 --> 00:10:44,409
Num

221
00:10:44,409 --> 00:10:47,029
Más numSerial

222
00:10:47,029 --> 00:10:48,850
NumSerial

223
00:10:48,850 --> 00:10:50,470
Número serial

224
00:10:50,470 --> 00:10:52,730
Número serial

225
00:10:52,730 --> 00:10:56,250
Y ahora cuando lanzo la prueba

226
00:10:56,250 --> 00:11:00,029
Él me usa el toString

227
00:11:00,029 --> 00:11:01,970
Del dispositivo

228
00:11:01,970 --> 00:11:05,269
Está claro que si yo en vez de utilizarlo aquí

229
00:11:05,269 --> 00:11:07,269
Lo utilizo sobre un móvil que pasa

230
00:11:07,269 --> 00:11:14,990
Que pasará aquí al fondo

231
00:11:14,990 --> 00:11:17,190
Si yo pongo M1

232
00:11:17,190 --> 00:11:30,740
Me lo trata como si fuera

233
00:11:30,740 --> 00:11:32,960
Un dispositivo

234
00:11:32,960 --> 00:11:33,639
¿Vale?

235
00:11:33,639 --> 00:11:35,440
Porque el móvil

236
00:11:35,440 --> 00:11:36,899
Esto no aparece

237
00:11:36,899 --> 00:11:44,059
Entonces va, digamos que el más cercano de móvil es la definición que está en su padre

238
00:11:44,059 --> 00:11:45,220
Que es el toString

239
00:11:45,220 --> 00:11:50,580
Entonces no necesita llegar hasta el object para trobar un toString

240
00:11:50,580 --> 00:11:54,320
El móvil busca en su padre que es dispositivo

241
00:11:54,320 --> 00:11:57,399
Aquí encuentra una definición de toString y usa esta

242
00:11:57,399 --> 00:11:59,620
Y entonces hace esta cosa aquí

243
00:11:59,620 --> 00:12:04,659
Si yo quisiera hacerlo una cosa distinta en el móvil

244
00:12:04,659 --> 00:12:06,580
Copiaría esto aquí

245
00:12:06,580 --> 00:12:09,919
En vez de dispositivo

246
00:12:09,919 --> 00:12:10,960
Poner móvil

247
00:12:10,960 --> 00:12:13,419
Y ahora

248
00:12:13,419 --> 00:12:17,779
Cuando lo lanzo

249
00:12:17,779 --> 00:12:20,639
Esto me dice dispositivo

250
00:12:20,639 --> 00:12:22,080
Porque he llamado sobre un dispositivo

251
00:12:22,080 --> 00:12:24,220
Y esto me dice móvil porque he llamado sobre un móvil

252
00:12:24,220 --> 00:12:29,460
Sería buena

253
00:12:29,460 --> 00:12:31,259
Praxis

254
00:12:31,259 --> 00:12:32,019
Entre comillas

255
00:12:32,019 --> 00:12:33,799
Que vuestros objetos

256
00:12:33,799 --> 00:12:35,120
Cuando creáis objetos

257
00:12:35,120 --> 00:12:38,500
Pues pongáis el toString

258
00:12:38,500 --> 00:12:40,519
Para que en el momento en que

259
00:12:40,519 --> 00:12:42,240
se imprime en pantalla

260
00:12:42,240 --> 00:12:44,379
el toString se dé una representación

261
00:12:44,379 --> 00:12:45,860
con sentido

262
00:12:45,860 --> 00:12:47,980
de los objetos que estáis creando

263
00:12:47,980 --> 00:12:50,679
si no, sale el codicilo

264
00:12:50,679 --> 00:12:52,440
de antes, vamos a ver

265
00:12:52,440 --> 00:12:54,320
que es el código de antes, fijaos

266
00:12:54,320 --> 00:12:56,399
que pasa si yo borro esto

267
00:12:56,399 --> 00:12:57,740
el de dispositivo

268
00:12:57,740 --> 00:12:59,700
pero dejo el de móvil

269
00:12:59,700 --> 00:13:03,679
¿qué pasará ahora?

270
00:13:03,679 --> 00:13:05,360
que el móvil si te lo marca

271
00:13:05,360 --> 00:13:06,159
pero el dispositivo

272
00:13:06,159 --> 00:13:09,120
el móvil usa el de móvil

273
00:13:09,120 --> 00:13:10,639
y el dispositivo

274
00:13:10,639 --> 00:13:13,120
Usa el de su padre

275
00:13:13,120 --> 00:13:14,039
El de object

276
00:13:14,039 --> 00:13:16,080
¿Lo veis?

277
00:13:16,159 --> 00:13:17,879
Como está hecho esto de object

278
00:13:17,879 --> 00:13:19,539
Dice, ¿qué es esto?

279
00:13:23,139 --> 00:13:23,779
Es la clase

280
00:13:23,779 --> 00:13:24,340
¿Vale?

281
00:13:24,419 --> 00:13:26,379
Entonces, por defecto

282
00:13:26,379 --> 00:13:28,279
El toString de object

283
00:13:28,279 --> 00:13:30,259
Crea un string que es

284
00:13:30,259 --> 00:13:32,299
La clase del objeto

285
00:13:32,299 --> 00:13:33,279
¿Vale?

286
00:13:33,279 --> 00:13:36,059
De qué instancia es

287
00:13:36,059 --> 00:13:37,679
Es una instancia de dispositivo

288
00:13:37,679 --> 00:13:38,980
Et

289
00:13:38,980 --> 00:13:40,279
En posición

290
00:13:40,279 --> 00:13:42,100
Un código raro

291
00:13:42,100 --> 00:13:48,440
Esto, que no es verdad, pero lo podríamos pensar como una zona de memoria

292
00:13:48,440 --> 00:13:50,659
Donde está guardado este objeto

293
00:13:50,659 --> 00:13:55,980
En realidad esto es un código hash raro que hace cosas raras y cosas por el estilo

294
00:13:55,980 --> 00:14:00,580
Pero la idea es que esto me representa en un cierto sentido

295
00:14:00,580 --> 00:14:06,659
Donde está guardado mi ordenador, mi objeto

296
00:14:06,659 --> 00:14:10,240
Es, en un cierto sentido, pensarlo así

297
00:14:10,240 --> 00:14:14,340
Podría ser lo que está escrito en una referencia

298
00:14:14,340 --> 00:14:19,360
¿Sabéis? Cuando yo digo esta variable es una referencia que apunta a un objeto

299
00:14:19,360 --> 00:14:25,559
Pues esto es el código que representa dónde está este objeto

300
00:14:25,559 --> 00:14:29,600
¿Sí?

301
00:14:30,279 --> 00:14:31,779
No es exactamente así, ¿eh?

302
00:14:31,779 --> 00:14:34,440
Por favor, tú que estás mirando el vídeo

303
00:14:34,440 --> 00:14:36,500
No te enfades conmigo

304
00:14:36,500 --> 00:14:37,659
¿Vale?

305
00:14:37,659 --> 00:14:40,639
Pero una simplificación suficiente

306
00:14:40,639 --> 00:14:41,700
Para entenderlo un poquito

307
00:14:41,700 --> 00:14:42,440
¿Sí?

308
00:14:43,500 --> 00:14:44,100
Vale

309
00:14:44,100 --> 00:14:46,059
Sigamos

310
00:14:46,059 --> 00:14:48,220
Entonces, acordaos que cualquier

311
00:14:48,220 --> 00:14:50,860
¿Cómo se llama esto?

312
00:14:51,440 --> 00:14:53,860
Cualquier clase que vosotros creéis

313
00:14:53,860 --> 00:14:56,059
Directamente tira de este señor de aquí

314
00:14:56,059 --> 00:14:58,019
Tened en cuenta también que si queréis

315
00:14:58,019 --> 00:15:00,340
Tener más información sobre el ToString

316
00:15:00,340 --> 00:15:01,279
Pincháis aquí

317
00:15:01,279 --> 00:15:02,639
Y aquí viene

318
00:15:02,639 --> 00:15:04,659
No, este es Notify, pero está por el lado

319
00:15:04,659 --> 00:15:08,519
y os explica

320
00:15:08,519 --> 00:15:10,299
que es, como funciona

321
00:15:10,299 --> 00:15:12,620
para que sirve, bla bla bla

322
00:15:12,620 --> 00:15:14,399
de hecho aquí

323
00:15:14,399 --> 00:15:16,539
os dice

324
00:15:16,539 --> 00:15:20,679
que es lo que viene después de la arroba

325
00:15:20,679 --> 00:15:21,759
que es una

326
00:15:21,759 --> 00:15:24,419
unsigned hexadecimal representation of the

327
00:15:24,419 --> 00:15:25,639
hash code of the object

328
00:15:25,639 --> 00:15:28,700
entonces no es exactamente donde se pone

329
00:15:28,700 --> 00:15:29,299
pero bueno

330
00:15:29,299 --> 00:15:31,279
si

331
00:15:31,279 --> 00:15:34,399
entonces aquí lo podéis mirar

332
00:15:34,399 --> 00:15:35,779
Pero es más que esto

333
00:15:35,779 --> 00:15:39,220
Vosotros aquí, en este mundo maravilloso del API

334
00:15:39,220 --> 00:15:45,600
Podéis ir a miraros todas las clases que nosotros hemos visto

335
00:15:45,600 --> 00:15:48,879
Como por ejemplo, puedo irme a mirar string

336
00:15:48,879 --> 00:15:52,940
Y ver todos los constructores de string

337
00:15:52,940 --> 00:15:53,740
¿Vale?

338
00:15:54,480 --> 00:15:55,399
Que son estos

339
00:15:55,399 --> 00:16:00,299
String, string a través de un byte de bytes

340
00:16:00,299 --> 00:16:03,500
String a través de un bar de...

341
00:16:03,500 --> 00:16:10,139
¿Os acordáis el otro día cuando hicimos el ejercicio dado un array de char, sácame un string?

342
00:16:10,820 --> 00:16:22,620
Si yo sé que existe esto, que hay un constructor de string que pilla un array de char,

343
00:16:23,259 --> 00:16:26,799
eso se hace con new string del array de char.

344
00:16:29,100 --> 00:16:35,419
Y aquí hay todos los posibles constructores de string.

345
00:16:35,419 --> 00:16:38,299
Y luego empiezan todos los métodos de string

346
00:16:38,299 --> 00:16:40,080
A lo mejor

347
00:16:40,080 --> 00:16:42,440
Reconoceréis este método de aquí

348
00:16:42,440 --> 00:16:44,440
Que lo hemos usado alguna vez

349
00:16:44,440 --> 00:16:45,460
El charat

350
00:16:45,460 --> 00:16:48,120
Pero hay un montón

351
00:16:48,120 --> 00:16:50,659
Hay el compare to, hay el concat

352
00:16:50,659 --> 00:16:51,600
El contains

353
00:16:51,600 --> 00:16:52,860
¿Os acordáis eso de

354
00:16:52,860 --> 00:16:55,679
Dada una secuencia de caracteres

355
00:16:55,679 --> 00:16:57,580
Buscarla dentro de un string

356
00:16:57,580 --> 00:16:59,580
Aquí la tenéis

357
00:16:59,580 --> 00:17:01,279
Ya implementada

358
00:17:01,279 --> 00:17:03,779
Y probablemente más eficiente

359
00:17:03,779 --> 00:17:04,859
De lo que hacéis vosotros

360
00:17:04,859 --> 00:17:06,160
¿Vale?

361
00:17:06,900 --> 00:17:10,220
Copy, value, ends, width, equals

362
00:17:10,220 --> 00:17:11,599
¿Esto suena de algo?

363
00:17:13,119 --> 00:17:14,420
¿Dónde lo hemos visto?

364
00:17:15,319 --> 00:17:20,650
Sí, pero ¿dónde lo hemos visto hace un minuto?

365
00:17:28,880 --> 00:17:29,940
Este es object, ¿eh?

366
00:17:32,049 --> 00:17:34,710
Este método de aquí no es un método de string

367
00:17:34,710 --> 00:17:39,789
Es una sobrescritura del método de object

368
00:17:39,789 --> 00:17:42,349
Que en vez de comparar dos objetos entre ellos

369
00:17:42,349 --> 00:17:44,170
Compara dos strings entre ellos

370
00:17:44,170 --> 00:17:50,589
Fijaos que recibe un objeto, no un string

371
00:17:50,589 --> 00:17:52,369
¿Por qué?

372
00:17:52,849 --> 00:17:58,470
Porque el que está en object trabaja con objetos, no con string

373
00:17:58,470 --> 00:18:02,349
Entonces estoy forzado a reutilizar esto

374
00:18:02,349 --> 00:18:05,609
Pero bueno, estas cosas con más calma en un futuro

375
00:18:05,609 --> 00:18:14,710
Lo único es que a veces podéis echarle un vistazo a las nuevas clases que nosotros vamos a ver.

376
00:18:15,650 --> 00:18:23,549
Dedicad un poco de tiempo para ir a la API de esa clase y mirar qué se puede hacer con esa clase.

377
00:18:24,230 --> 00:18:32,609
El 70% de los ejercicios sobre string que hemos hecho son sustancialmente lo mismo.

378
00:18:32,609 --> 00:18:38,990
mismo que ya están implementados en la clase string no necesitaba implementarlo vosotros

379
00:18:41,069 --> 00:18:48,750
cuando yo soy un programador y sé programar no vuelvo a rehacer el búscame una cadena dentro

380
00:18:48,750 --> 00:18:54,329
de otra cadena porque ya está implementado ya me han implementado y no vuelvo a implementar

381
00:18:54,329 --> 00:18:56,150
Yo cada vez que lo uso, uso el contains

382
00:18:56,150 --> 00:18:57,990
¿Vale? O uso

383
00:18:57,990 --> 00:19:00,349
Todo lo que me da aquí, start to string

384
00:19:00,349 --> 00:19:01,950
To lowercase

385
00:19:01,950 --> 00:19:04,130
¿Vale? Dame una frase

386
00:19:04,130 --> 00:19:06,789
Una secuencia en mayúsculas

387
00:19:06,789 --> 00:19:08,109
Y te la pone en minúsculas

388
00:19:08,109 --> 00:19:09,410
Pues aquí lo tenéis

389
00:19:09,410 --> 00:19:11,430
Esto

390
00:19:11,430 --> 00:19:16,049
¿Sí? Entonces

391
00:19:16,049 --> 00:19:17,009
Acordaos

392
00:19:17,009 --> 00:19:20,130
Y esto con todas las clases

393
00:19:20,130 --> 00:19:22,529
De multiverso ya creadas

394
00:19:22,529 --> 00:19:24,029
De Java

395
00:19:24,029 --> 00:19:32,529
vale si vosotros buscáis cárner y tenemos nuestro escáner

396
00:19:32,529 --> 00:19:39,329
vale con todos sus métodos incluidos eso de nex

397
00:19:39,329 --> 00:19:47,529
next in the next double etcétera o sea que aquí están todos lo que podéis

398
00:19:47,529 --> 00:19:50,069
utilizar

399
00:19:50,069 --> 00:19:52,970
Entonces acordaos

400
00:19:52,970 --> 00:19:54,390
Porque esta es una herramienta muy potente

401
00:19:54,390 --> 00:19:55,269
El API

402
00:19:55,269 --> 00:19:58,250
Vosotros podéis buscar allí un montón de información

403
00:19:58,250 --> 00:20:00,470
Cuando encontréis a partir de ahora

404
00:20:00,470 --> 00:20:01,670
Una clase nueva

405
00:20:01,670 --> 00:20:03,450
Echadle un vistazo en el API

406
00:20:03,450 --> 00:20:05,029
Para ver que puede hacer esa clase

407
00:20:05,029 --> 00:20:06,950
Que os proporciona

408
00:20:06,950 --> 00:20:10,410
Sigamos con nuestra herencia

409
00:20:10,410 --> 00:20:11,190
Entonces

410
00:20:11,190 --> 00:20:14,569
Hemos ya creado constructores con herencia

411
00:20:14,569 --> 00:20:17,130
Fijamos algunos puntos

412
00:20:17,130 --> 00:20:21,089
Cuando yo creo un objeto nuevo

413
00:20:21,089 --> 00:20:23,309
Paso siempre por dos puntos

414
00:20:23,309 --> 00:20:24,650
¿Vale? Por dos partes

415
00:20:24,650 --> 00:20:27,589
La primera parte es que creo su parte base

416
00:20:27,589 --> 00:20:29,650
Su parte que hereda

417
00:20:29,650 --> 00:20:32,410
¿Vale? Creo mi padre, sustancialmente

418
00:20:32,410 --> 00:20:37,450
Y después añado la parte propia de esta clase

419
00:20:37,450 --> 00:20:38,670
Esto pasa siempre

420
00:20:38,670 --> 00:20:40,789
Hasta una clase que no extiende nada

421
00:20:40,789 --> 00:20:43,210
Porque siempre crearé en el punto uno

422
00:20:43,210 --> 00:20:45,369
Llamo al objeto, a object

423
00:20:45,369 --> 00:20:51,509
Creo todo lo que está en el constructor de object

424
00:20:51,509 --> 00:20:54,210
Y una vez que he creado el objeto

425
00:20:54,210 --> 00:20:55,789
Que es la parte base

426
00:20:55,789 --> 00:20:57,730
Creo todo lo que yo creo

427
00:20:57,730 --> 00:20:59,130
Que he dicho que existe

428
00:20:59,130 --> 00:21:00,869
En mi clase dispositivo

429
00:21:00,869 --> 00:21:01,990
En mi clase persona

430
00:21:01,990 --> 00:21:03,490
En mi clase lo que sea

431
00:21:03,490 --> 00:21:05,470
Pero es siempre así

432
00:21:05,470 --> 00:21:12,210
Si yo soy una clase que extiende otra clase

433
00:21:12,210 --> 00:21:14,150
Pues este paso

434
00:21:14,150 --> 00:21:16,690
Se vuelve, el paso uno se vuelve a rehacer

435
00:21:16,690 --> 00:21:18,890
Por cada extensión que he hecho

436
00:21:18,890 --> 00:21:21,549
O sea, alumno que extiende persona

437
00:21:21,549 --> 00:21:24,369
Hará el primer paso con

438
00:21:24,369 --> 00:21:26,509
Persona extiende object

439
00:21:26,509 --> 00:21:28,029
Por lo tanto, creo object

440
00:21:28,029 --> 00:21:29,809
Le añado lo que es persona

441
00:21:29,809 --> 00:21:31,470
Y por lo tanto, he creado una persona

442
00:21:31,470 --> 00:21:33,130
Y a este punto le añado lo que es

443
00:21:33,130 --> 00:21:36,009
Alumno

444
00:21:36,009 --> 00:21:36,630
¿Vale?

445
00:21:36,990 --> 00:21:38,509
Una cosa de ese estilo aquí abajo

446
00:21:38,509 --> 00:21:43,690
Si yo tengo alumno que hereda de persona

447
00:21:43,690 --> 00:21:46,609
El paso uno de crear

448
00:21:46,609 --> 00:21:49,869
El paso uno de crear alumno es

449
00:21:49,869 --> 00:21:52,349
Crear la parte correspondiente a persona

450
00:21:52,349 --> 00:21:54,230
Creo lo que yo extendo

451
00:21:54,230 --> 00:21:56,690
Y para crear la persona

452
00:21:56,690 --> 00:21:58,789
Tengo que crear object

453
00:21:58,789 --> 00:22:02,089
Y después de haber creado object

454
00:22:02,089 --> 00:22:04,130
Añadir las cosas de persona

455
00:22:04,130 --> 00:22:07,670
Y entonces he creado la persona

456
00:22:07,670 --> 00:22:08,970
Y paso al punto 2

457
00:22:08,970 --> 00:22:11,769
Donde añado las cosas de alumno

458
00:22:11,769 --> 00:22:17,710
Entonces siempre creo lo más general

459
00:22:17,710 --> 00:22:21,730
Y luego voy añadiendo la parte más concreta

460
00:22:21,730 --> 00:22:24,009
Y más específica de esta clase en concreto

461
00:22:24,009 --> 00:22:30,150
Constructores y herencia

462
00:22:30,150 --> 00:22:33,109
En el constructor de la clase de base

463
00:22:33,109 --> 00:22:35,410
Se realiza siempre una llamada a constructor de la clase de base

464
00:22:35,410 --> 00:22:39,690
Una llamada a constructor super se hace siempre

465
00:22:39,690 --> 00:22:42,990
Solo que puede ser implícita o explícita

466
00:22:42,990 --> 00:22:43,609
¿Vale?

467
00:22:43,970 --> 00:22:45,490
Explícitamente lo puedo escribir yo

468
00:22:45,490 --> 00:22:47,569
O implícitamente si no pongo nada

469
00:22:47,569 --> 00:22:48,869
En automático lo hace él

470
00:22:48,869 --> 00:22:49,529
¿Vale?

471
00:22:51,029 --> 00:22:54,130
La llamada al constructor de la clase base

472
00:22:54,130 --> 00:22:55,670
De la superclase

473
00:22:55,670 --> 00:22:58,390
Es la primera acción que tiene que hacer el constructor

474
00:22:58,390 --> 00:22:59,650
No puedo llamarla super

475
00:22:59,650 --> 00:23:01,849
Hacer una suma y luego llamar super

476
00:23:01,849 --> 00:23:02,750
¿Vale?

477
00:23:02,809 --> 00:23:04,130
Lo tengo que llamar en la primera línea

478
00:23:04,130 --> 00:23:07,730
Porque antes creo, digamos, el entorno donde me estoy moviendo

479
00:23:07,730 --> 00:23:08,890
Mi superclase

480
00:23:08,890 --> 00:23:11,250
Y lo haga para que ya haga otras cosas

481
00:23:11,250 --> 00:23:12,009
¿Vale?

482
00:23:13,309 --> 00:23:15,730
Y puede ser que esta llamada

483
00:23:15,730 --> 00:23:17,569
Al super constructor

484
00:23:17,569 --> 00:23:18,910
¿Vale? Constructor de super

485
00:23:18,910 --> 00:23:21,329
Es o no lo indico específicamente

486
00:23:21,329 --> 00:23:23,170
O lo indico específicamente

487
00:23:23,170 --> 00:23:24,970
Que entonces es en la prima línea

488
00:23:24,970 --> 00:23:26,349
¿Vale? Ejemplo

489
00:23:26,349 --> 00:23:28,470
Si no lo indico específicamente

490
00:23:28,470 --> 00:23:29,829
Fijaos aquí

491
00:23:29,829 --> 00:23:32,349
Es donde él

492
00:23:32,349 --> 00:23:34,529
A escondida

493
00:23:34,529 --> 00:23:37,170
Invisiblemente hace una llamada

494
00:23:37,170 --> 00:23:38,450
A super

495
00:23:38,450 --> 00:23:41,089
Esto

496
00:23:41,089 --> 00:23:44,109
El constructor por defecto

497
00:23:44,109 --> 00:23:45,130
De mi padre

498
00:23:45,130 --> 00:23:47,910
Cuidado, si yo el constructor por defecto

499
00:23:47,910 --> 00:23:49,509
De mi padre se lo he quitado

500
00:23:49,509 --> 00:23:51,269
Esto es flojo

501
00:23:51,269 --> 00:23:54,750
Porque intenta llamar esto

502
00:23:54,750 --> 00:23:56,150
Y esto no está

503
00:23:56,150 --> 00:23:57,769
Y da un error

504
00:23:57,769 --> 00:23:59,990
Probémoslo

505
00:23:59,990 --> 00:24:06,259
Entonces, en el ejemplo que hemos hecho nosotros

506
00:24:06,259 --> 00:24:08,500
Por ejemplo, pillamos móvil

507
00:24:08,500 --> 00:24:09,099
¿Vale?

508
00:24:09,640 --> 00:24:10,319
Móvil

509
00:24:10,319 --> 00:24:15,559
Imaginémonos

510
00:24:15,559 --> 00:24:17,339
A ver, el dispositivo

511
00:24:17,339 --> 00:24:19,799
Tiene solo esto, ¿vale?

512
00:24:19,980 --> 00:24:22,339
El dispositivo no tiene un

513
00:24:22,339 --> 00:24:26,000
Un método así, un constructor así

514
00:24:26,000 --> 00:24:31,319
Esto sería el constructor por defecto

515
00:24:31,319 --> 00:24:32,359
¿Vale?

516
00:24:33,440 --> 00:24:36,079
Si yo creo un constructor cualquiera

517
00:24:36,079 --> 00:24:37,119
Como este de aquí

518
00:24:37,119 --> 00:24:40,299
Pues el constructor sin parámetros desaparece

519
00:24:40,299 --> 00:24:42,920
A menos que yo no lo vuelva a implementar

520
00:24:42,920 --> 00:24:44,119
Explícitamente así

521
00:24:44,119 --> 00:24:46,759
Y poniendo aquí lo que tiene que hacer

522
00:24:46,759 --> 00:24:48,960
En el caso en que no me ponga los parámetros

523
00:24:48,960 --> 00:24:49,559
¿Vale?

524
00:24:50,180 --> 00:24:51,359
Imaginémonos que no está

525
00:24:51,359 --> 00:24:54,019
Y que yo desde móvil

526
00:24:54,019 --> 00:24:56,359
Intente hacer esto

527
00:24:56,359 --> 00:24:58,259
Esto explota

528
00:24:58,259 --> 00:25:01,740
¿Vale?

529
00:25:01,740 --> 00:25:02,980
Porque no existe

530
00:25:02,980 --> 00:25:05,920
Un constructor de dispositivos

531
00:25:05,920 --> 00:25:06,740
Sin parámetros

532
00:25:06,740 --> 00:25:08,519
Realmente

533
00:25:08,519 --> 00:25:10,539
Esto también se enfada

534
00:25:10,539 --> 00:25:14,259
Porque como aquí no estoy llamando nada

535
00:25:14,259 --> 00:25:16,339
En este punto de aquí

536
00:25:16,339 --> 00:25:18,140
Me está llamando él solo

537
00:25:18,140 --> 00:25:18,640
Esta

538
00:25:18,640 --> 00:25:22,339
Y como no está definida aquí

539
00:25:22,339 --> 00:25:24,039
Pues entonces no lo tiene

540
00:25:24,039 --> 00:25:25,380
Dice, no lo puede hacer

541
00:25:25,380 --> 00:25:27,940
No se puede construir un móvil

542
00:25:27,940 --> 00:25:30,279
Con este

543
00:25:30,279 --> 00:25:31,299
Super constructor

544
00:25:31,299 --> 00:25:34,299
Y como no puedo construir tu padre

545
00:25:34,299 --> 00:25:35,740
No te puedo construir a ti

546
00:25:35,740 --> 00:25:37,460
¿Se entiende?

547
00:25:40,269 --> 00:25:40,950
¿Tienes dudas?

548
00:25:40,950 --> 00:25:48,000
Entonces, y si yo quisiera utilizarlo, pues debería ir aquí

549
00:25:48,000 --> 00:25:56,079
Y decirle, oye mira el dispositivo, tendrás también un constructor sin parámetros

550
00:25:56,079 --> 00:25:59,819
Que dará como número serial un número vacío

551
00:25:59,819 --> 00:26:04,440
Ahora ya tiene el constructor sin parámetros

552
00:26:04,440 --> 00:26:07,299
Entonces esto puede llamar super sin parámetros

553
00:26:07,299 --> 00:26:09,720
Así como puede llamar nada

554
00:26:09,720 --> 00:26:11,559
¿Veis que ahora no me da error?

555
00:26:11,559 --> 00:26:14,579
Porque lo que hará es por defecto

556
00:26:14,579 --> 00:26:16,039
Llamar super sin parámetros

557
00:26:16,039 --> 00:26:20,130
Tú das

558
00:26:20,130 --> 00:26:22,880
¿Vale?

559
00:26:23,339 --> 00:26:25,700
Esto es, si no indico explícitamente

560
00:26:25,700 --> 00:26:28,140
Si no digo nada dentro de un constructor

561
00:26:28,140 --> 00:26:29,940
Y hago cosas

562
00:26:29,940 --> 00:26:32,599
Nosotros hemos hecho constructores

563
00:26:32,599 --> 00:26:33,200
Hasta ahora

564
00:26:33,200 --> 00:26:36,559
¿Sí? En las clases que hemos hecho nosotros

565
00:26:36,559 --> 00:26:38,579
¿Habéis alguna vez utilizado super

566
00:26:38,579 --> 00:26:39,819
Paréntesis, paréntesis?

567
00:26:41,039 --> 00:26:41,720
No

568
00:26:41,720 --> 00:26:44,000
Sin embargo, todas vuestras clases

569
00:26:44,000 --> 00:26:46,359
Heredan de Object

570
00:26:46,359 --> 00:26:48,519
Habrían tenido que hacerlo

571
00:26:48,519 --> 00:26:50,299
¿Vale?

572
00:26:50,380 --> 00:26:52,759
Pero él lo ha hecho por defecto

573
00:26:55,680 --> 00:26:56,259
¿Está claro?

574
00:26:57,380 --> 00:26:57,579
¿Sí?

575
00:26:57,660 --> 00:27:00,380
Y como Object tiene un constructor

576
00:27:00,380 --> 00:27:02,440
Sin parámetros, pues entonces funciona

577
00:27:02,440 --> 00:27:04,319
Y si no

578
00:27:04,319 --> 00:27:05,799
La segunda opción es

579
00:27:05,799 --> 00:27:07,500
Ponerlo explícitamente

580
00:27:07,500 --> 00:27:09,440
Llamo a este

581
00:27:09,440 --> 00:27:11,960
Constructor

582
00:27:11,960 --> 00:27:13,559
Y le puedo poner los parámetros

583
00:27:13,559 --> 00:27:15,519
Para decirle de los constructores

584
00:27:15,519 --> 00:27:16,559
Que pueda tener mi padre

585
00:27:16,559 --> 00:27:18,099
Que puede tener, habéis visto string

586
00:27:18,099 --> 00:27:20,500
Que tiene como 10, 15 constructores distintos

587
00:27:20,500 --> 00:27:22,799
Voy a utilizar el que recibe

588
00:27:22,799 --> 00:27:24,200
Un string, otro string

589
00:27:24,200 --> 00:27:25,039
Y un número

590
00:27:25,039 --> 00:27:34,660
Entonces

591
00:27:34,660 --> 00:27:37,819
Constructores o no lo pongo

592
00:27:37,819 --> 00:27:39,539
Entonces llamo por defecto super

593
00:27:39,539 --> 00:27:41,700
Sin parámetros o si no indico

594
00:27:41,700 --> 00:27:43,900
Especialmente en la primera línea

595
00:27:43,900 --> 00:27:44,839
Del constructor

596
00:27:44,839 --> 00:27:47,539
Que super constructor

597
00:27:47,539 --> 00:27:48,380
Pido

598
00:27:48,380 --> 00:27:50,559
Vale, uso

599
00:27:50,559 --> 00:27:56,710
Hasta aquí, dudas

600
00:27:56,710 --> 00:28:02,259
Esto de la herencia

601
00:28:02,259 --> 00:28:04,299
Conlleva también

602
00:28:04,299 --> 00:28:05,240
Dos

603
00:28:05,240 --> 00:28:07,759
Conceptos más, dos cosillas

604
00:28:07,759 --> 00:28:09,519
Que se puede hacer con la herencia

605
00:28:09,519 --> 00:28:10,980
Que son los shadowing

606
00:28:10,980 --> 00:28:12,359
Y el overriding

607
00:28:12,359 --> 00:28:15,140
Esto es como

608
00:28:15,140 --> 00:28:17,559
Se relacionan

609
00:28:17,559 --> 00:28:19,660
Entre dos clases

610
00:28:19,660 --> 00:28:20,799
Que una extiende a la otra

611
00:28:20,799 --> 00:28:22,359
Entonces clase padre, clase hijo

612
00:28:22,359 --> 00:28:24,440
La relación entre

613
00:28:24,440 --> 00:28:26,119
Atributos

614
00:28:26,119 --> 00:28:27,799
Y entremétodos

615
00:28:27,799 --> 00:28:28,940
¿Vale?

616
00:28:30,200 --> 00:28:31,539
Vamos a ver

617
00:28:31,539 --> 00:28:32,759
¿Qué se puede hacer?

618
00:28:32,859 --> 00:28:35,259
Un atributo, ¿vale?

619
00:28:35,440 --> 00:28:36,900
En la clase hijo

620
00:28:36,900 --> 00:28:39,359
Puede tener el mismo nombre

621
00:28:39,359 --> 00:28:41,440
De la clase base

622
00:28:41,440 --> 00:28:43,519
De la clase superclase

623
00:28:43,519 --> 00:28:44,359
¿Vale?

624
00:28:44,599 --> 00:28:46,140
Y hasta distinto tipo

625
00:28:46,140 --> 00:28:47,420
¿Vale?

626
00:28:47,900 --> 00:28:50,500
Mismo nombre, pero el tipo que te da la gana

627
00:28:50,500 --> 00:28:51,720
O el mismo, o otro

628
00:28:51,720 --> 00:28:53,559
Si tú haces así

629
00:28:53,559 --> 00:28:55,480
Estás ocultando

630
00:28:55,480 --> 00:28:57,259
Haciendo sombra

631
00:28:57,259 --> 00:28:58,299
¿Vale? Shadowing

632
00:28:58,299 --> 00:28:59,160
Al

633
00:28:59,160 --> 00:29:03,599
Al atributo del padre

634
00:29:03,599 --> 00:29:06,019
¿En qué sentido?

635
00:29:07,380 --> 00:29:09,700
Pensad por ejemplo dispositivo

636
00:29:09,700 --> 00:29:11,480
¿Vale? Dispositivo tiene

637
00:29:11,480 --> 00:29:15,519
Esto por ejemplo, boolean encendido

638
00:29:15,519 --> 00:29:17,839
¿Vale? Entonces cuando yo voy

639
00:29:17,839 --> 00:29:19,420
A móvil, aquí

640
00:29:19,420 --> 00:29:21,079
Está pensado que existe

641
00:29:21,079 --> 00:29:22,660
Encendido como boolean

642
00:29:22,660 --> 00:29:45,950
¿Y qué pasa si yo hago int encendido? Que el encendido del dispositivo como booleano sigue allí para los dispositivos, pero para los móviles encendido es un int.

643
00:29:45,950 --> 00:29:48,549
Entonces ahora

644
00:29:48,549 --> 00:29:49,569
Si yo tengo un móvil

645
00:29:49,569 --> 00:29:51,950
Acceder al booleano

646
00:29:51,950 --> 00:29:53,230
Es complejo

647
00:29:53,230 --> 00:29:55,490
Lo estoy bloqueando

648
00:29:55,490 --> 00:29:56,509
Lo estoy ocultando

649
00:29:56,509 --> 00:29:57,809
Si yo soy un dispositivo

650
00:29:57,809 --> 00:29:58,990
Seguiré

651
00:29:58,990 --> 00:30:02,150
No, si yo soy un dispositivo

652
00:30:02,150 --> 00:30:03,150
Y le digo

653
00:30:03,150 --> 00:30:05,670
Donde está

654
00:30:05,670 --> 00:30:07,509
Aquí de uno punto

655
00:30:07,509 --> 00:30:09,410
Que era esto encendido

656
00:30:09,410 --> 00:30:11,990
No puedo

657
00:30:11,990 --> 00:30:29,759
Que no me

658
00:30:29,759 --> 00:30:32,240
Ah, encendido

659
00:30:32,240 --> 00:30:33,559
Ahora sí

660
00:30:33,559 --> 00:30:36,880
Y punto encendido

661
00:30:36,880 --> 00:30:42,019
Ten en cuenta que aquí

662
00:30:42,019 --> 00:30:44,039
Le pasaré

663
00:30:44,039 --> 00:30:46,240
Vale, vamos a ver

664
00:30:46,240 --> 00:30:48,859
Y entonces cuando yo creo un móvil

665
00:30:48,859 --> 00:30:49,799
Por ejemplo

666
00:30:49,799 --> 00:30:51,539
A encendido

667
00:30:51,539 --> 00:30:53,640
Le pongo cero

668
00:30:53,640 --> 00:30:54,660
Vale

669
00:30:54,660 --> 00:30:58,059
Entonces, ¿qué me escribirá esta cosa aquí?

670
00:30:59,400 --> 00:31:00,660
Esta cosa aquí

671
00:31:00,660 --> 00:31:01,359
¿Y qué me escribirá?

672
00:31:04,349 --> 00:31:04,950
False

673
00:31:04,950 --> 00:31:06,750
¿Y esta?

674
00:31:08,789 --> 00:31:09,589
Cero

675
00:31:09,589 --> 00:31:16,880
False y cero

676
00:31:16,880 --> 00:31:19,160
¿Sí?

677
00:31:20,400 --> 00:31:22,599
Entonces, esta cosa de aquí

678
00:31:22,599 --> 00:31:24,680
De poder cambiar un

679
00:31:24,680 --> 00:31:26,900
Un atributo

680
00:31:26,900 --> 00:31:29,099
¿Vale? A otro atributo

681
00:31:29,099 --> 00:31:30,900
Que sea hasta

682
00:31:30,900 --> 00:31:31,980
De tipo distinto

683
00:31:31,980 --> 00:31:33,759
Se llama Shadowing

684
00:31:33,759 --> 00:31:36,960
Esencialmente lo que estoy haciendo es que desde un hijo

685
00:31:36,960 --> 00:31:39,819
Impido a objetos de este hijo

686
00:31:39,819 --> 00:31:42,859
O de los que están por debajo de este hijo

687
00:31:42,859 --> 00:31:43,319
¿Vale?

688
00:31:43,759 --> 00:31:45,519
Acceder al mismo

689
00:31:45,519 --> 00:31:49,039
Atributo de un padre

690
00:31:49,039 --> 00:31:49,660
¿Vale?

691
00:31:49,700 --> 00:31:51,579
Porque le estoy haciendo sombra

692
00:31:51,579 --> 00:31:52,700
¿Vale? Literalmente

693
00:31:52,700 --> 00:31:53,039
Shadow

694
00:31:53,039 --> 00:31:54,980
¿Para qué sirve?

695
00:31:55,359 --> 00:31:57,019
Porque a lo mejor en determinados casos

696
00:31:57,019 --> 00:31:59,440
Un valor que en general

697
00:31:59,440 --> 00:32:00,980
Tiene un cierto sentido

698
00:32:00,980 --> 00:32:03,740
Cuando paso a algo extendido

699
00:32:03,740 --> 00:32:05,640
No lo quiero poder utilizar

700
00:32:05,640 --> 00:32:07,119
Porque en la versión más

701
00:32:07,119 --> 00:32:09,359
¿Cómo se dice esto?

702
00:32:09,420 --> 00:32:10,640
Más específica

703
00:32:10,640 --> 00:32:13,339
No tiene el mismo significado que la versión

704
00:32:13,339 --> 00:32:15,039
Generalizada

705
00:32:15,039 --> 00:32:17,339
¿Vale? Y entonces allí de alguna forma

706
00:32:17,339 --> 00:32:18,279
Quiero bloquearlo

707
00:32:18,279 --> 00:32:21,400
¿Vale? No es una cosa que yo haya visto

708
00:32:21,400 --> 00:32:23,380
Muchas veces en mi carrera

709
00:32:23,380 --> 00:32:24,700
¿Vale? Pero

710
00:32:24,700 --> 00:32:26,240
Existe y se puede hacer

711
00:32:26,240 --> 00:32:27,640
¿Sí?

712
00:32:29,420 --> 00:32:31,240
Entonces este es shadowing

713
00:32:31,240 --> 00:32:33,640
Que si no me equivoco aquí hay un ejemplo

714
00:32:33,640 --> 00:32:34,039
¿Vale?

715
00:32:34,039 --> 00:32:36,180
este de aquí por ejemplo

716
00:32:36,180 --> 00:32:38,539
yo tengo la clase persona

717
00:32:38,539 --> 00:32:40,599
la clase alumno que extiende persona

718
00:32:40,599 --> 00:32:42,539
hay un nombre que

719
00:32:42,539 --> 00:32:44,480
cuando es una persona el nombre

720
00:32:44,480 --> 00:32:46,720
es un string y cuando

721
00:32:46,720 --> 00:32:48,599
es un alumno el nombre es

722
00:32:48,599 --> 00:32:50,220
su identificador

723
00:32:50,220 --> 00:32:51,700
como alumno

724
00:32:51,700 --> 00:32:54,980
cuando luego llego aquí en el main

725
00:32:54,980 --> 00:32:56,539
y le digo que

726
00:32:56,539 --> 00:32:57,200
escriba

727
00:32:57,200 --> 00:33:00,559
el nombre de una persona me escribirá

728
00:33:00,559 --> 00:33:02,380
el nombre de la persona cuando le digo

729
00:33:02,380 --> 00:33:04,500
escríbeme el nombre del alumno

730
00:33:04,500 --> 00:33:05,400
me escribirá el número

731
00:33:05,400 --> 00:33:08,200
lo mismo que hemos hecho ahora

732
00:33:08,200 --> 00:33:09,940
con dispositivo y cosas parecidas

733
00:33:09,940 --> 00:33:16,180
entonces no se puede hacer con el super

734
00:33:16,180 --> 00:33:19,789
de acceder a esa

735
00:33:19,789 --> 00:33:21,430
variable

736
00:33:21,430 --> 00:33:24,450
al booleano

737
00:33:24,450 --> 00:33:25,730
al booleano

738
00:33:25,730 --> 00:33:27,049
con el super a prior

739
00:33:27,049 --> 00:33:29,630
no deberías acceder al del padre

740
00:33:29,630 --> 00:33:31,069
vamos a ver

741
00:33:31,069 --> 00:33:34,269
porque creo que después lo digo

742
00:33:34,269 --> 00:33:35,970
podemos acceder a variables de la subclase

743
00:33:35,970 --> 00:33:37,630
o de la superclase utilizando this o super

744
00:33:37,630 --> 00:33:39,309
O sea que yo

745
00:33:39,309 --> 00:33:41,369
Si desde el móvil

746
00:33:41,369 --> 00:33:43,910
No uso encendido

747
00:33:43,910 --> 00:33:45,569
Dis.encendido

748
00:33:45,569 --> 00:33:48,430
Si no uso super.encendido

749
00:33:48,430 --> 00:33:49,930
Entonces estoy accediendo

750
00:33:49,930 --> 00:33:50,970
Al encendido de mi padre

751
00:33:50,970 --> 00:33:52,789
Entonces ahí volverá a ser bueno

752
00:33:52,789 --> 00:34:00,579
Es esto

753
00:34:00,579 --> 00:34:02,859
Con calma

754
00:34:02,859 --> 00:34:03,799
Llegamos

755
00:34:03,799 --> 00:34:06,299
Es que si no complicamos la cosa

756
00:34:06,299 --> 00:34:08,599
Entonces hay esta posibilidad

757
00:34:08,599 --> 00:34:09,400
Lo shadowing

758
00:34:09,400 --> 00:34:18,500
De ocultar a nivel de hijo un parámetro, un atributo que está en mi padre

759
00:34:18,500 --> 00:34:22,460
Entonces la idea es, una vez ocultado no puedo acceder a ello

760
00:34:22,460 --> 00:34:24,679
Pues sí, hay formas de hacerlo

761
00:34:24,679 --> 00:34:31,820
Entonces, si definimos en una subclase un atributo del mismo nombre

762
00:34:31,820 --> 00:34:35,579
El mismo tipo o tipo distinto que la superclase

763
00:34:35,579 --> 00:34:37,599
La de la superclase queda oculta

764
00:34:37,599 --> 00:34:38,559
Hasta aquí hemos llegado

765
00:34:38,559 --> 00:34:42,360
Para acceder a la subclase o la superclase

766
00:34:42,360 --> 00:34:44,239
Puedo utilizar dice super

767
00:34:44,239 --> 00:34:45,820
¿Qué quiere decir esto?

768
00:34:46,920 --> 00:34:51,940
Si yo desde aquí uso encendido

769
00:34:51,940 --> 00:34:54,139
En cualquier lado, como aquí por ejemplo

770
00:34:54,139 --> 00:34:58,480
Pues claramente estoy escribiendo mi encendido

771
00:34:58,480 --> 00:35:00,739
Si en algún lado

772
00:35:00,739 --> 00:35:02,900
Esto ahora ya no es un booleano, ¿vale?

773
00:35:03,119 --> 00:35:05,440
Entonces le tengo que poner así por ejemplo

774
00:35:05,440 --> 00:35:12,179
Si yo aquí quisiera en algún lado escribir mi padre

775
00:35:12,179 --> 00:35:14,219
Por ejemplo, podría crear un método

776
00:35:14,219 --> 00:35:23,369
¿Vale?

777
00:35:23,949 --> 00:35:27,389
Donde quiero escribir los dos valores

778
00:35:27,389 --> 00:35:27,789
¿Vale?

779
00:35:30,510 --> 00:35:31,090
Entonces

780
00:35:31,090 --> 00:35:33,489
Mi encendido

781
00:35:33,489 --> 00:35:35,190
No, encendido móvil

782
00:35:35,190 --> 00:35:36,369
Móvil encendido

783
00:35:36,369 --> 00:35:40,960
Y aquí escribiría

784
00:35:40,960 --> 00:35:43,400
This.encendido

785
00:35:43,400 --> 00:35:45,039
¿Vale?

786
00:35:45,619 --> 00:35:47,360
Y si en vez quiero

787
00:35:47,360 --> 00:35:49,940
acceder al de mi padre

788
00:35:49,940 --> 00:35:55,210
puedo acceder a él

789
00:35:55,210 --> 00:35:56,829
como supe

790
00:35:56,829 --> 00:35:59,269
punto excelido

791
00:35:59,269 --> 00:36:04,920
entonces si desde aquí

792
00:36:04,920 --> 00:36:05,980
en algún lado

793
00:36:05,980 --> 00:36:08,519
llamo a

794
00:36:08,519 --> 00:36:10,639
m1.test al final

795
00:36:10,639 --> 00:36:12,500
m1.test

796
00:36:12,500 --> 00:36:19,400
veis que

797
00:36:19,400 --> 00:36:21,300
para el móvil

798
00:36:21,300 --> 00:36:22,800
encendido es un cero

799
00:36:22,800 --> 00:36:26,039
pero para dispositivo encendido es falso

800
00:36:26,039 --> 00:36:27,980
tened en cuenta que lo estoy

801
00:36:27,980 --> 00:36:36,619
llamando desde los dos desde móvil es este método de aquí a tener en cuenta

802
00:36:36,619 --> 00:36:40,800
que son dos variables distintas no es que 0 corresponde a falsa

803
00:36:40,800 --> 00:36:45,619
si yo cambio 0 a 35 pues el de mi padre se queda falsa son dos variables

804
00:36:45,619 --> 00:36:51,530
distintas guardadas en sitios distintos

805
00:36:51,530 --> 00:36:54,690
Pero es más, ¿vale?

806
00:36:54,710 --> 00:36:58,530
Porque esto yo lo puedo hacer desde el móvil

807
00:36:58,530 --> 00:37:00,630
Pero si estuviera aquí

808
00:37:00,630 --> 00:37:03,989
No tengo súper

809
00:37:03,989 --> 00:37:08,269
En esta prueba no tengo súper para acceder al padre del móvil

810
00:37:08,269 --> 00:37:15,510
Entonces, o el móvil me proporciona un método para que yo pueda acceder al súper

811
00:37:15,510 --> 00:37:16,909
¿Vale?

812
00:37:16,909 --> 00:37:19,030
O si no, no lo puedo acceder

813
00:37:19,030 --> 00:37:21,130
O sí

814
00:37:21,130 --> 00:37:24,150
Está esta otra cosa de aquí

815
00:37:24,150 --> 00:37:25,289
¿Vale?

816
00:37:26,869 --> 00:37:27,550
Imaginémonos

817
00:37:27,550 --> 00:37:29,909
Una situación como esta

818
00:37:29,909 --> 00:37:32,590
Tengo transporte

819
00:37:32,590 --> 00:37:34,289
Transporte puede ser tren

820
00:37:34,289 --> 00:37:35,250
O un vehículo

821
00:37:35,250 --> 00:37:38,070
Y vehículo puede ser la moto o un coche

822
00:37:38,070 --> 00:37:38,670
¿Vale?

823
00:37:39,190 --> 00:37:41,769
Y yo tengo, estoy en coche

824
00:37:41,769 --> 00:37:42,630
Creo, ¿vale?

825
00:37:42,630 --> 00:37:44,429
Que es la clase hija

826
00:37:44,429 --> 00:37:45,429
Fijaos que

827
00:37:45,429 --> 00:37:48,909
Este

828
00:37:48,909 --> 00:37:51,050
¿Cómo se llama?

829
00:37:51,050 --> 00:37:52,530
A estos niveles

830
00:37:52,530 --> 00:37:53,570
El mismo

831
00:37:53,570 --> 00:37:56,349
La misma

832
00:37:56,349 --> 00:37:57,269
¿Cómo se llama?

833
00:37:57,449 --> 00:37:59,409
El mismo atributo se sobrescribe

834
00:37:59,409 --> 00:38:00,710
Se está haciendo shadowing

835
00:38:00,710 --> 00:38:03,869
Sin cambiarle de tipo

836
00:38:03,869 --> 00:38:05,250
Pero se está haciendo

837
00:38:05,250 --> 00:38:08,329
Para que a nivel de esto

838
00:38:08,329 --> 00:38:09,550
Ponga ferraria

839
00:38:09,550 --> 00:38:10,949
A nivel de esto ponga turismo

840
00:38:10,949 --> 00:38:12,670
A nivel de esto ponga terrestre

841
00:38:12,670 --> 00:38:13,949
Cuando yo pongo el nombre

842
00:38:13,949 --> 00:38:16,909
Pues entonces

843
00:38:16,909 --> 00:38:18,909
Si yo estoy en el coche

844
00:38:18,909 --> 00:38:21,769
Y pongo nombre a secas

845
00:38:21,769 --> 00:38:24,070
Estoy hablando de este nombre de aquí

846
00:38:24,070 --> 00:38:25,809
Nombre a nivel de pollo

847
00:38:25,809 --> 00:38:29,809
Si yo pongo dis.nombre

848
00:38:29,809 --> 00:38:31,469
Sigo hablando de esto

849
00:38:31,469 --> 00:38:33,429
De este objeto

850
00:38:33,429 --> 00:38:38,170
Si yo pongo super.nombre

851
00:38:38,170 --> 00:38:39,389
Estoy hablando

852
00:38:39,389 --> 00:38:41,150
De mi padre

853
00:38:41,150 --> 00:38:43,510
Nombre, por lo tanto esto

854
00:38:43,510 --> 00:38:46,739
¿Si?

855
00:38:47,699 --> 00:38:49,079
Y vosotros podéis, ah bueno

856
00:38:49,079 --> 00:38:50,679
Antes de otro paso

857
00:38:50,679 --> 00:38:54,000
Puedo hacer un casting explícito

858
00:38:54,000 --> 00:38:56,159
Decir, pilla this

859
00:38:56,159 --> 00:38:58,360
Soy yo, soy un coche

860
00:38:58,360 --> 00:39:01,699
Considérame un vehículo

861
00:39:01,699 --> 00:39:05,519
Y una vez que me has considerado un vehículo

862
00:39:05,519 --> 00:39:06,659
Haces a mi nombre

863
00:39:06,659 --> 00:39:08,960
Entonces si a mí me considero un vehículo

864
00:39:08,960 --> 00:39:10,920
Yo soy un vehículo, un coche es un vehículo

865
00:39:10,920 --> 00:39:12,519
Pero ahora estaré aquí

866
00:39:12,519 --> 00:39:14,639
Y entonces me escribí esto

867
00:39:14,639 --> 00:39:21,179
Lo que no se hace bajo ningún concepto es esto

868
00:39:21,179 --> 00:39:23,739
Super super no

869
00:39:23,739 --> 00:39:25,880
Tampoco ultra

870
00:39:25,880 --> 00:39:29,239
No se puede llamar dos veces super

871
00:39:29,239 --> 00:39:30,079
Esto está mal

872
00:39:30,079 --> 00:39:31,780
Y como hago esto

873
00:39:31,780 --> 00:39:33,619
Pues con esta misma forma aquí

874
00:39:33,619 --> 00:39:35,539
En vez de hacerme un casting

875
00:39:35,539 --> 00:39:36,940
A vehículo

876
00:39:36,940 --> 00:39:40,320
Hago un cast a transporte

877
00:39:40,320 --> 00:39:41,159
Digo

878
00:39:41,159 --> 00:39:42,639
Este es un objeto coche

879
00:39:42,639 --> 00:39:44,539
Que es un vehículo que es un transporte

880
00:39:44,539 --> 00:39:46,300
Por lo tanto yo también soy un transporte

881
00:39:46,300 --> 00:39:48,880
Ahora considerame como si fuera un transporte

882
00:39:48,880 --> 00:39:50,059
Y accede al nombre

883
00:39:50,059 --> 00:39:51,460
Pues entonces es este

884
00:39:51,460 --> 00:39:54,739
¿Los paréntesis sí o sí hay que ponerlos?

885
00:39:58,119 --> 00:40:00,820
No valdría solo tres paréntesis de transporte

886
00:40:00,820 --> 00:40:01,780
Transporte tipo

887
00:40:01,780 --> 00:40:03,260
Yo lo pondría por claridad

888
00:40:03,260 --> 00:40:05,559
Porque si tú no los pones

889
00:40:05,559 --> 00:40:08,559
Esto de transporte podría ser que dis.nombre

890
00:40:08,559 --> 00:40:09,539
Lo que sea

891
00:40:09,539 --> 00:40:11,760
Lo que sea el resultado de dis.nombre

892
00:40:11,760 --> 00:40:13,440
Tráctamelo como un transporte

893
00:40:13,440 --> 00:40:14,840
Dis.nombre es un string

894
00:40:14,840 --> 00:40:17,659
Entonces no te puede hacer un casting de un string a un transporte

895
00:40:17,659 --> 00:40:18,539
Entonces sería cual

896
00:40:18,539 --> 00:40:23,019
Esto es por preferencia de operadores

897
00:40:23,019 --> 00:40:25,059
Para que sea claro que este transporte

898
00:40:25,059 --> 00:40:26,360
Se aplica a TIS

899
00:40:26,360 --> 00:40:29,480
Pues entonces tú pones que pilla lo que tú dices

900
00:40:29,480 --> 00:40:31,000
Considera un transporte

901
00:40:31,000 --> 00:40:32,280
Y ahora cede a su punto

902
00:40:32,280 --> 00:40:36,739
¿Cómo sería en nuestro caso?

903
00:40:36,860 --> 00:40:37,760
Vamos a probarlo

904
00:40:37,760 --> 00:40:42,449
Entonces nosotros

905
00:40:42,449 --> 00:40:44,409
Borro un poco de esto

906
00:40:44,409 --> 00:40:49,309
Dejo los móviles

907
00:40:49,309 --> 00:40:50,809
Entonces

908
00:40:50,809 --> 00:41:06,079
ahora nosotros estamos así hemos creado un dispositivo y un móvil si yo hago no

909
00:41:06,079 --> 00:41:23,820
me quiere escribir si yo ahora digo a nivel de móvil vale y le digo m1 punto encendido

910
00:41:23,820 --> 00:41:42,809
él me escribe móvil y si ahora le digo oye sí pero escríbeme esto pero a m1 considera

911
00:41:42,809 --> 00:41:57,989
melo un dispositivo y m1 trátalo como un dispositivo asume que es un dispositivo

912
00:41:57,989 --> 00:41:59,289
Y acceda a encendido

913
00:41:59,289 --> 00:42:00,349
¿Qué me pone?

914
00:42:08,969 --> 00:42:09,590
¿Make sense?

915
00:42:12,940 --> 00:42:13,340
Entonces

916
00:42:13,340 --> 00:42:17,239
La idea es que puedo acceder

917
00:42:17,239 --> 00:42:19,219
A varios, puedo hacer lo que me da la gana

918
00:42:19,219 --> 00:42:20,940
Con estas cosas, ¿vale?

919
00:42:21,260 --> 00:42:23,280
La idea es que existe

920
00:42:23,280 --> 00:42:25,119
Este mecanismo, que es el

921
00:42:25,119 --> 00:42:27,480
Shadowing, donde sostancialmente

922
00:42:27,480 --> 00:42:29,280
Puedo un atributo

923
00:42:29,280 --> 00:42:30,460
De otro

924
00:42:30,460 --> 00:42:33,179
De mi clase padre

925
00:42:33,179 --> 00:42:34,820
Ocultarlo de alguna forma

926
00:42:34,820 --> 00:42:36,659
Impedir que se acceda directamente

927
00:42:36,659 --> 00:42:40,800
Esto no quiere decir que no puedo luego recuperar esa cosa

928
00:42:40,800 --> 00:42:45,780
Pero puede ser que este mismo valor, este mismo encendido

929
00:42:45,780 --> 00:42:50,000
Para un móvil tenga un valor y para un dispositivo tenga un valor

930
00:42:50,000 --> 00:42:54,039
Y yo normalmente cuando uso móvil, si lo uso encendido lo utilizo como móvil

931
00:42:54,039 --> 00:43:00,340
En un particular caso en el que ahora necesito utilizarlo como si fuera un dispositivo

932
00:43:00,340 --> 00:43:03,940
Pues siempre puedo acceder a él a través de un casting explícito

933
00:43:03,940 --> 00:43:05,760
Diciéndole, oye, mira, esta cosa aquí

934
00:43:05,760 --> 00:43:08,679
No me la trates como móvil, me la trato como dispositivo

935
00:43:08,679 --> 00:43:10,539
Como existe

936
00:43:10,539 --> 00:43:12,559
Una herencia y una relación

937
00:43:12,559 --> 00:43:13,519
De es un

938
00:43:13,519 --> 00:43:15,119
Pues entonces me funciona

939
00:43:15,119 --> 00:43:20,579
Vale

940
00:43:20,579 --> 00:43:21,840
Y

941
00:43:21,840 --> 00:43:24,079
Última cosa

942
00:43:24,079 --> 00:43:28,820
Lo mismo en un cierto sentido

943
00:43:28,820 --> 00:43:31,119
Pero con los métodos

944
00:43:31,119 --> 00:43:31,739
¿Vale?

945
00:43:32,019 --> 00:43:34,000
Esto es lo que hemos hecho antes

946
00:43:34,000 --> 00:43:35,260
Cuando hemos puesto

947
00:43:35,260 --> 00:43:38,000
El toString

948
00:43:38,000 --> 00:43:39,739
O cuando hemos puesto el

949
00:43:39,739 --> 00:43:42,119
Como me acuerdo me se llama

950
00:43:42,119 --> 00:43:44,139
Describe, en vez de describe móvil

951
00:43:44,139 --> 00:43:45,039
Con describe son

952
00:43:45,039 --> 00:43:48,599
Es decir, que yo puedo reescribir

953
00:43:48,599 --> 00:43:50,539
Métodos

954
00:43:50,539 --> 00:43:51,019
¿Vale?

955
00:43:52,340 --> 00:43:54,460
Esto es más importante que el otro

956
00:43:54,460 --> 00:43:55,559
Es más interesante

957
00:43:55,559 --> 00:43:57,920
La idea es que yo puedo tener

958
00:43:57,920 --> 00:43:59,039
Subclases

959
00:43:59,039 --> 00:44:01,480
Que cuando hacen un método

960
00:44:01,480 --> 00:44:04,800
Que normalmente tiene también la superclase

961
00:44:04,800 --> 00:44:06,280
Pues hagan

962
00:44:06,280 --> 00:44:07,460
Algo más

963
00:44:07,460 --> 00:44:09,559
de lo que hace la clase genérica

964
00:44:09,559 --> 00:44:11,340
¿vale? por ejemplo

965
00:44:11,340 --> 00:44:13,699
un dispositivo no tiene un número de teléfono

966
00:44:13,699 --> 00:44:15,840
si yo te digo, descríbete

967
00:44:15,840 --> 00:44:17,139
a un dispositivo

968
00:44:17,139 --> 00:44:19,780
él no me puede decir que número de teléfono tiene

969
00:44:19,780 --> 00:44:21,780
porque un ordenador no tiene un número de teléfono

970
00:44:21,780 --> 00:44:24,000
por ejemplo, ahora un móvil

971
00:44:24,000 --> 00:44:25,579
cuando le digo descríbete

972
00:44:25,579 --> 00:44:27,480
sí que tiene el número

973
00:44:27,480 --> 00:44:29,699
de teléfono, entonces estaría bien

974
00:44:29,699 --> 00:44:32,059
que dijera, oye, este es mi número de teléfono

975
00:44:32,059 --> 00:44:34,139
¿vale? para hacer eso

976
00:44:34,139 --> 00:44:35,900
nosotros

977
00:44:35,900 --> 00:44:37,619
en el ejemplo que habíamos hecho

978
00:44:37,619 --> 00:44:39,099
habíamos creado

979
00:44:39,099 --> 00:44:41,039
dos métodos distintos

980
00:44:41,039 --> 00:44:43,440
habíamos creado el método estado

981
00:44:43,440 --> 00:44:46,079
y había creado el método

982
00:44:46,079 --> 00:44:47,079
estado móvil

983
00:44:47,079 --> 00:44:50,260
¿vale? entonces no me puedo equivocar

984
00:44:50,260 --> 00:44:51,320
¿sí?

985
00:44:51,619 --> 00:44:53,599
pero el problema de esto es que para saber

986
00:44:53,599 --> 00:44:56,099
que método utilizar tengo que saber en que clase

987
00:44:56,099 --> 00:44:56,500
estoy

988
00:44:56,500 --> 00:44:59,880
si es un móvil que hemos estado móvil, si es un dispositivo

989
00:44:59,880 --> 00:45:00,360
que hemos estado

990
00:45:00,360 --> 00:45:02,239
¿vale? y esto

991
00:45:02,239 --> 00:45:04,739
Es un problema

992
00:45:04,739 --> 00:45:05,900
¿Cuándo es un problema?

993
00:45:06,260 --> 00:45:07,599
Vamos a hacer un ejemplo

994
00:45:07,599 --> 00:45:11,139
Creamos un array de dispositivos

995
00:45:11,139 --> 00:45:12,760
Dispositivo

996
00:45:12,760 --> 00:45:18,849
Es igual a

997
00:45:18,849 --> 00:45:19,170
New

998
00:45:19,170 --> 00:45:22,150
Dispositivo

999
00:45:22,150 --> 00:45:25,449
De 3

1000
00:45:25,449 --> 00:45:28,070
¿Vale?

1001
00:45:28,710 --> 00:45:29,829
Array de dispositivos

1002
00:45:29,829 --> 00:45:32,130
En dispositivo

1003
00:45:32,130 --> 00:45:34,630
De 0

1004
00:45:34,630 --> 00:45:37,369
Pongo un nuevo dispositivo

1005
00:45:37,369 --> 00:45:50,210
En dispositivo de uno

1006
00:45:50,210 --> 00:45:52,630
Pongo un nuevo móvil

1007
00:45:52,630 --> 00:46:06,210
Me da error

1008
00:46:06,210 --> 00:46:07,809
No

1009
00:46:07,809 --> 00:46:09,510
¿Por qué?

1010
00:46:09,710 --> 00:46:11,230
Porque un móvil es un dispositivo

1011
00:46:11,230 --> 00:46:13,329
Entonces puede estar en una red de dispositivos

1012
00:46:13,329 --> 00:46:16,510
Y finalmente

1013
00:46:16,510 --> 00:46:19,449
Esto no me sirve

1014
00:46:19,449 --> 00:46:20,630
Dejo dos

1015
00:46:20,630 --> 00:46:21,469
Vale

1016
00:46:21,469 --> 00:46:24,969
La cosa interesante aquí es que

1017
00:46:24,969 --> 00:46:26,469
Yo tengo una red de dispositivos

1018
00:46:26,469 --> 00:46:29,289
Vale, ahora quiero que los dispositivos se presenten

1019
00:46:29,289 --> 00:46:31,070
Entonces hago for

1020
00:46:31,070 --> 00:46:33,449
Int i es igual a cero

1021
00:46:33,449 --> 00:46:35,710
i es menor que

1022
00:46:35,710 --> 00:46:38,789
Disp.length

1023
00:46:38,789 --> 00:46:40,969
i más más

1024
00:46:40,969 --> 00:46:46,760
Disp de i

1025
00:46:46,760 --> 00:46:51,659
Punto

1026
00:46:51,659 --> 00:46:54,280
Queda esto

1027
00:46:54,280 --> 00:46:56,019
Estado

1028
00:46:56,019 --> 00:47:01,059
Esto funciona

1029
00:47:01,059 --> 00:47:13,980
Aparte que aquí me he cargado algo

1030
00:47:13,980 --> 00:47:18,340
Veamos un momento

1031
00:47:18,340 --> 00:47:19,039
El

1032
00:47:19,039 --> 00:47:20,420
Esto

1033
00:47:20,420 --> 00:47:24,320
Desnúmero

1034
00:47:24,320 --> 00:47:24,980
NS

1035
00:47:24,980 --> 00:47:26,159
Super

1036
00:47:26,159 --> 00:47:28,500
NS

1037
00:47:28,500 --> 00:47:31,340
Aquí

1038
00:47:31,340 --> 00:47:32,380
Vale

1039
00:47:32,380 --> 00:47:34,980
Entonces, aquí

1040
00:47:34,980 --> 00:47:36,380
Ahora, dispositivo

1041
00:47:36,380 --> 00:47:39,219
Si os fijáis, esto está funcionando

1042
00:47:39,219 --> 00:47:41,199
Pero me trata el móvil

1043
00:47:41,199 --> 00:47:44,159
Como si fuera un dispositivo

1044
00:47:44,159 --> 00:47:46,079
No como si fuera un móvil

1045
00:47:46,079 --> 00:47:47,320
¿Vale?

1046
00:47:47,639 --> 00:47:49,139
Lo que no puede hacer

1047
00:47:49,139 --> 00:47:52,099
A ver, ¿dónde está?

1048
00:47:52,579 --> 00:47:53,460
Es decirle

1049
00:47:53,460 --> 00:47:54,760
Usa estado móvil

1050
00:47:54,760 --> 00:47:56,900
Esto se enfada

1051
00:47:56,900 --> 00:47:58,579
¿Vale?

1052
00:47:58,820 --> 00:48:00,719
Porque lo que me está diciendo es

1053
00:48:00,719 --> 00:48:02,199
En

1054
00:48:02,199 --> 00:48:06,960
Estado móvil no está definido

1055
00:48:06,960 --> 00:48:08,440
En dispositivo

1056
00:48:08,440 --> 00:48:10,340
Porque eso está definido en móvil

1057
00:48:10,340 --> 00:48:13,239
¿Vale? Podría entonces decirle

1058
00:48:13,239 --> 00:48:14,900
Vale, pero tú tráctamelo como móvil

1059
00:48:14,900 --> 00:48:24,630
Claro

1060
00:48:24,630 --> 00:48:27,349
Pilla este elemento de aquí

1061
00:48:27,349 --> 00:48:29,510
El objeto que te da en esta posición

1062
00:48:29,510 --> 00:48:31,329
Tráctamelo como móvil

1063
00:48:31,329 --> 00:48:32,869
Y ahora llama estado móvil

1064
00:48:32,869 --> 00:48:34,170
Vale, fenomenal

1065
00:48:34,170 --> 00:48:36,610
Boom

1066
00:48:36,610 --> 00:48:38,730
¿Vale?

1067
00:48:38,730 --> 00:48:42,650
Class dispositivos

1068
00:48:42,650 --> 00:48:45,190
Cannot be cast to class móvil

1069
00:48:45,190 --> 00:48:47,429
Dispositivo no se puede

1070
00:48:47,429 --> 00:48:48,789
Tratar como móvil

1071
00:48:48,789 --> 00:48:51,210
Es un móvil que se puede tratar como un dispositivo

1072
00:48:51,210 --> 00:48:53,449
Si

1073
00:48:53,449 --> 00:48:56,690
Entonces como puede hacer

1074
00:48:56,690 --> 00:48:57,989
Para que

1075
00:48:57,989 --> 00:49:00,769
Este señor de aquí

1076
00:49:00,769 --> 00:49:01,789
Me funcione

1077
00:49:01,789 --> 00:49:04,409
En el sentido que

1078
00:49:04,409 --> 00:49:06,590
Yo tengo una red de dispositivos

1079
00:49:06,590 --> 00:49:08,550
Pero que si tengo

1080
00:49:08,550 --> 00:49:09,989
Un dispositivo

1081
00:49:09,989 --> 00:49:11,670
me use el estado

1082
00:49:11,670 --> 00:49:13,550
del dispositivo

1083
00:49:13,550 --> 00:49:15,570
y si en vez es un móvil, me use

1084
00:49:15,570 --> 00:49:16,590
el móvil

1085
00:49:16,590 --> 00:49:19,170
y esto se logra

1086
00:49:19,170 --> 00:49:21,750
diciendo, vale, aquí en vez de

1087
00:49:21,750 --> 00:49:23,670
crearme un método propio

1088
00:49:23,670 --> 00:49:25,849
del móvil

1089
00:49:25,849 --> 00:49:27,949
sobre escribo

1090
00:49:27,949 --> 00:49:31,150
el

1091
00:49:31,150 --> 00:49:32,849
método de mi padre

1092
00:49:32,849 --> 00:49:35,809
entonces, ahora no hay estado

1093
00:49:35,809 --> 00:49:38,010
estado móvil, estado ordenador, estado no sé qué

1094
00:49:38,010 --> 00:49:39,250
hay estado

1095
00:49:39,250 --> 00:49:41,429
Cada hijo

1096
00:49:41,429 --> 00:49:43,230
Sobrascriberá

1097
00:49:43,230 --> 00:49:45,449
El funcionamiento del padre

1098
00:49:45,449 --> 00:49:47,769
Pero poniendo las cosas

1099
00:49:47,769 --> 00:49:50,130
Importantes de esta nueva clase

1100
00:49:50,130 --> 00:49:51,489
Como por ejemplo aquí ahora te digo

1101
00:49:51,489 --> 00:49:52,349
Que soy un móvil

1102
00:49:52,349 --> 00:49:55,690
En automático

1103
00:49:55,690 --> 00:49:56,730
Java

1104
00:49:56,730 --> 00:50:02,219
Cuando se llama

1105
00:50:02,219 --> 00:50:04,800
Sobre un determinado objeto

1106
00:50:04,800 --> 00:50:06,760
Utilizará el estado

1107
00:50:06,760 --> 00:50:09,260
Del objeto

1108
00:50:09,260 --> 00:50:11,340
De la instancia que es el objeto

1109
00:50:11,340 --> 00:50:16,599
Si el objeto que he metido allí es un dispositivo, usará el estado del dispositivo

1110
00:50:16,599 --> 00:50:22,219
Y si el objeto que he puesto allí es un móvil, usará el debo

1111
00:50:22,219 --> 00:50:33,869
Esto ha usado dispositivo porque disuno es un dispositivo

1112
00:50:33,869 --> 00:50:37,750
Y esto ha llamado móvil porque es un móvil

1113
00:50:37,750 --> 00:50:42,590
Y esto me abre un mundo

1114
00:50:42,590 --> 00:50:47,829
Simplemente lo he sobre escrito

1115
00:50:47,829 --> 00:50:54,690
A mí en este momento me interesa el concepto de sobreescribir el método

1116
00:50:54,690 --> 00:50:58,550
No tanto esta cosa de aquí

1117
00:50:58,550 --> 00:51:02,869
Esto se llama polimorfismo, lo veremos con más detalle un poquito más adelante

1118
00:51:02,869 --> 00:51:05,530
Es un ejemplo de por qué esto me puede servir

1119
00:51:05,530 --> 00:51:11,429
A mí lo que me interesa por ahora es la parte de sobreescribir

1120
00:51:12,210 --> 00:51:14,750
Yo puedo pillar un método de mi padre

1121
00:51:14,750 --> 00:51:16,190
Veis que es el mismo método

1122
00:51:16,190 --> 00:51:17,889
Idéntico a este de aquí

1123
00:51:17,889 --> 00:51:19,570
Mismo método

1124
00:51:19,570 --> 00:51:21,829
Y decirle, ahora

1125
00:51:21,829 --> 00:51:24,230
Este método de aquí no hace

1126
00:51:24,230 --> 00:51:25,510
Esto

1127
00:51:25,510 --> 00:51:27,909
Pero hace otra cosa

1128
00:51:27,909 --> 00:51:31,519
Se tiene que llamar igual

1129
00:51:31,519 --> 00:51:32,880
Porque lo estoy sobre escribiendo

1130
00:51:32,880 --> 00:51:35,760
Es como el método toString

1131
00:51:35,760 --> 00:51:37,679
El método toString representa

1132
00:51:37,679 --> 00:51:38,840
Una versión

1133
00:51:38,840 --> 00:51:41,780
Textual de mi objeto

1134
00:51:41,780 --> 00:51:43,760
Tú tienes el método toString

1135
00:51:43,760 --> 00:51:45,880
En object, que te da ese código raro

1136
00:51:45,880 --> 00:51:47,400
Si yo en vez de ese código raro

1137
00:51:47,400 --> 00:51:49,360
Cuando quieres imprimir mi objeto

1138
00:51:49,360 --> 00:51:51,579
Quiero algo que sea más parecido a mi objeto

1139
00:51:51,579 --> 00:51:52,880
Con los datos de mi objeto

1140
00:51:52,880 --> 00:51:55,440
Pues de todo lo que hago es sobre escribir el toString

1141
00:51:55,440 --> 00:51:57,980
Entonces cada vez que se utilizará el toString

1142
00:51:57,980 --> 00:51:59,940
Pues utilizará el mío, no el de object

1143
00:51:59,940 --> 00:52:02,340
Lo mismo con el equals

1144
00:52:02,340 --> 00:52:03,719
String

1145
00:52:03,719 --> 00:52:06,079
Cuando hago string1

1146
00:52:06,079 --> 00:52:07,760
Cuando hago algo como

1147
00:52:07,760 --> 00:52:09,880
Esto.equals

1148
00:52:10,599 --> 00:52:14,400
A esto

1149
00:52:14,400 --> 00:52:20,969
Este equals de aquí

1150
00:52:20,969 --> 00:52:23,570
Es una sobrescriptura

1151
00:52:23,570 --> 00:52:25,170
Del equals

1152
00:52:25,170 --> 00:52:26,510
Que está en object

1153
00:52:26,510 --> 00:52:27,969
¿Vale?

1154
00:52:28,829 --> 00:52:30,530
El de object hace una cosa

1155
00:52:30,530 --> 00:52:32,750
El de string hace otra cosa

1156
00:52:32,750 --> 00:52:34,789
El de object compara entre ellos

1157
00:52:34,789 --> 00:52:36,730
Dos objetos, en particular

1158
00:52:36,730 --> 00:52:39,610
Compara ese código que hemos visto

1159
00:52:39,610 --> 00:52:41,010
Que sea el mismo código

1160
00:52:41,010 --> 00:52:41,969
¿Vale?

1161
00:52:42,309 --> 00:52:44,949
Sin embargo, equals lo que hace es

1162
00:52:44,949 --> 00:52:46,730
Comparar que esta

1163
00:52:46,730 --> 00:52:48,949
Esta secuencia de caracteres

1164
00:52:48,949 --> 00:52:51,269
Es igual a esta secuencia de caracteres

1165
00:52:51,269 --> 00:52:52,070
Dentro string

1166
00:52:52,070 --> 00:52:53,949
No sé si me entendéis lo que quiero decir

1167
00:52:53,949 --> 00:52:56,809
Yo puedo pillar dispositivos

1168
00:52:56,809 --> 00:53:00,940
Y sobre escribir equals

1169
00:53:00,940 --> 00:53:03,820
Para que yo pueda luego preguntarme

1170
00:53:03,820 --> 00:53:05,980
Si dos dispositivos son el mismo dispositivo

1171
00:53:05,980 --> 00:53:09,440
¿Sí?

1172
00:53:17,869 --> 00:53:19,429
Es una buenísima

1173
00:53:19,429 --> 00:53:19,969
Demanda

1174
00:53:19,969 --> 00:53:25,840
Imaginaos que yo tenga un dispositivo

1175
00:53:25,840 --> 00:53:27,119
¿Vale?

1176
00:53:27,219 --> 00:53:28,619
Que es el dispositivo A

1177
00:53:28,619 --> 00:53:31,760
Apagado

1178
00:53:31,760 --> 00:53:36,619
El equals

1179
00:53:36,619 --> 00:53:39,599
De object

1180
00:53:39,599 --> 00:53:41,699
Me da true

1181
00:53:41,699 --> 00:53:43,400
Solo si esto

1182
00:53:43,400 --> 00:53:44,599
Y esto

1183
00:53:44,599 --> 00:53:47,300
Son exactamente

1184
00:53:47,300 --> 00:53:48,400
El mismo objeto

1185
00:53:48,400 --> 00:53:52,519
Efectivamente

1186
00:53:52,519 --> 00:53:55,940
Si no se que punto equals

1187
00:53:55,940 --> 00:53:56,800
No se cuanto

1188
00:53:56,800 --> 00:53:58,460
No se que y no se cuanto

1189
00:53:58,460 --> 00:54:01,179
Apuntan al mismo objeto real

1190
00:54:01,179 --> 00:54:03,280
Pues para object

1191
00:54:03,280 --> 00:54:04,340
Estos son los mismos

1192
00:54:04,340 --> 00:54:09,500
Sin embargo, por ejemplo en string

1193
00:54:09,500 --> 00:54:11,980
Yo tengo string gato

1194
00:54:11,980 --> 00:54:14,980
Y otra variable

1195
00:54:14,980 --> 00:54:16,900
Que dice gato

1196
00:54:16,900 --> 00:54:20,119
Y cuando hago equals

1197
00:54:20,119 --> 00:54:22,920
No está usando el equals de object

1198
00:54:22,920 --> 00:54:24,360
Porque si no me daría true

1199
00:54:24,360 --> 00:54:27,280
Solo cuando yo lo uso sobre el mismo objeto

1200
00:54:27,280 --> 00:54:29,300
En vez de yo estoy poniendo

1201
00:54:29,300 --> 00:54:31,460
Aquí, este objeto de aquí

1202
00:54:31,460 --> 00:54:32,059
Por ejemplo

1203
00:54:32,059 --> 00:54:34,760
Y aquí, este otro objeto de aquí

1204
00:54:34,760 --> 00:54:36,460
Son dos objetos distintos

1205
00:54:36,460 --> 00:54:41,360
Entonces la implementación de Equals en String

1206
00:54:41,360 --> 00:54:44,440
No puede ser la misma que Equals en Object

1207
00:54:44,440 --> 00:54:55,940
Contain Equals

1208
00:54:55,940 --> 00:54:57,079
Contiene

1209
00:54:57,079 --> 00:55:01,000
No lo sé, había que ver

1210
00:55:01,000 --> 00:55:08,719
Entonces, ¿qué pasa si yo me quiero hacer un Equals en dispositivo?

1211
00:55:08,719 --> 00:55:10,719
O sea, que aquí yo tengo el dispositivo 1

1212
00:55:10,719 --> 00:55:13,679
Y aquí un dispositivo 2

1213
00:55:13,679 --> 00:55:16,440
¿Cómo se implementa

1214
00:55:16,440 --> 00:55:18,159
Equals entre dispositivos?

1215
00:55:18,719 --> 00:55:19,940
Pues lo tengo que

1216
00:55:19,940 --> 00:55:21,159
Decidir yo

1217
00:55:21,159 --> 00:55:24,280
¿Vale? Soy yo que implemento este equals

1218
00:55:24,280 --> 00:55:26,179
Y yo tengo que decir cuando dos

1219
00:55:26,179 --> 00:55:28,519
Objetos equals, cuando esto está aquí

1220
00:55:28,519 --> 00:55:29,940
Y esto está aquí

1221
00:55:29,940 --> 00:55:32,320
¿Cuándo este método me da true?

1222
00:55:32,639 --> 00:55:34,199
¿Y cuándo este método me da false?

1223
00:55:35,019 --> 00:55:36,260
Por ejemplo, como nosotros

1224
00:55:36,260 --> 00:55:38,320
Tenemos un número serial, el número serial

1225
00:55:38,320 --> 00:55:40,519
Debería ser único, podría decir

1226
00:55:40,519 --> 00:55:41,880
Que cuando el número serial

1227
00:55:41,880 --> 00:55:44,619
Es el mismo, entonces devuelve true

1228
00:55:44,619 --> 00:55:46,739
Y cuando el número serial es distinto

1229
00:55:46,739 --> 00:55:48,539
Devuelve false, independientemente

1230
00:55:48,539 --> 00:55:50,360
De si está encendido o no, independientemente

1231
00:55:50,360 --> 00:55:51,840
De donde está guardado en memoria

1232
00:55:51,840 --> 00:55:54,199
¿Sí?

1233
00:55:55,480 --> 00:55:56,619
Pero esto quizás

1234
00:55:56,619 --> 00:55:58,679
Un poquito más, más en futuro

1235
00:55:58,679 --> 00:55:59,519
¿Vale?

1236
00:56:00,579 --> 00:56:02,500
Yo creo que me faltan

1237
00:56:02,500 --> 00:56:04,739
No, falta más de lo que pensaba

1238
00:56:04,739 --> 00:56:05,219
¿Vale?

1239
00:56:06,420 --> 00:56:06,980
Entonces

1240
00:56:06,980 --> 00:56:29,880
Entonces, el concepto de overriding o sobreescriptura es esta cosa aquí, ¿vale? De una clase hija puede sobreescribir un método de una clase padre, ¿vale? Para que haga una cosa distinta, una cosa posiblemente más específica para la clase hija.

1241
00:56:29,880 --> 00:56:38,599
A lo mejor el método que usa el padre es demasiado genérico, el método que usa el hijo es mucho más específico para ese hijo.

1242
00:56:39,019 --> 00:56:42,019
Haremos ejemplos en los próximos días.

1243
00:56:44,239 --> 00:56:55,320
También, como pasaba antes, puedo utilizar mi método, el método de este objeto, o puedo utilizar el objeto de mi padre.

1244
00:56:55,320 --> 00:56:57,039
O sea, el método de mi padre

1245
00:56:57,039 --> 00:56:59,280
¿Vale? Utilizando thisEsSuper

1246
00:56:59,280 --> 00:57:02,320
Puedo seguir utilizando la versión mía

1247
00:57:02,320 --> 00:57:03,699
O la versión de mi padre

1248
00:57:03,699 --> 00:57:06,159
O puedo utilizar dentro de la versión mía

1249
00:57:06,159 --> 00:57:07,179
La versión de mi padre

1250
00:57:07,179 --> 00:57:09,599
¿Vale? Por ejemplo

1251
00:57:09,599 --> 00:57:11,260
Como esto

1252
00:57:11,260 --> 00:57:12,980
Bueno, bueno

1253
00:57:12,980 --> 00:57:16,239
¿Os acordáis que la versión del padre

1254
00:57:16,239 --> 00:57:18,099
Escribía o esto o esto?

1255
00:57:18,780 --> 00:57:20,139
Pues yo el mismo método

1256
00:57:20,139 --> 00:57:22,480
O muy parecido lo podría hacer así

1257
00:57:22,480 --> 00:57:32,340
Escribe sin el n

1258
00:57:32,340 --> 00:57:33,699
El móvil

1259
00:57:33,699 --> 00:57:37,239
Y luego después

1260
00:57:37,239 --> 00:57:39,260
Super punto estado

1261
00:57:39,260 --> 00:57:45,730
¿Vale?

1262
00:57:46,449 --> 00:57:49,210
Si os fijáis, aquí la cosa sería

1263
00:57:49,210 --> 00:57:51,449
Vale, escribe siempre el móvil delante

1264
00:57:51,449 --> 00:57:52,670
Y después

1265
00:57:52,670 --> 00:57:55,570
Vas a llamar el método de mi padre

1266
00:57:55,570 --> 00:57:56,829
El método de mi padre

1267
00:57:56,829 --> 00:57:58,250
Este de aquí

1268
00:57:58,250 --> 00:58:00,929
Si está encendido, me escribirá detrás

1269
00:58:00,929 --> 00:58:02,469
El móvil con número serial

1270
00:58:02,469 --> 00:58:04,869
Está encendido, o si no, el número serial

1271
00:58:04,869 --> 00:58:06,650
Está apagado, por lo tanto

1272
00:58:06,650 --> 00:58:07,329
Me hace lo mismo

1273
00:58:07,329 --> 00:58:09,889
Vamos a ver si es verdad

1274
00:58:09,889 --> 00:58:16,630
Lo único es que

1275
00:58:16,630 --> 00:58:18,110
Este código de aquí

1276
00:58:18,110 --> 00:58:21,510
No he tenido que volver a escribirlo

1277
00:58:21,510 --> 00:58:23,170
Lo he reutilizado

1278
00:58:23,170 --> 00:58:34,659
Entonces, esto es más

1279
00:58:34,659 --> 00:58:36,760
Haber entendido el Diesel Super

1280
00:58:36,760 --> 00:58:38,519
¿Vale? Cada vez que uso Super

1281
00:58:38,519 --> 00:58:40,840
estoy hablando de la clase padre

1282
00:58:40,840 --> 00:58:42,960
cada vez que uso this estoy hablando de la clase

1283
00:58:42,960 --> 00:58:43,559
en la que estoy

1284
00:58:43,559 --> 00:58:47,000
entonces el super se puede utilizar

1285
00:58:47,000 --> 00:58:48,960
tanto para llamar

1286
00:58:48,960 --> 00:58:50,079
métodos como aquí

1287
00:58:50,079 --> 00:58:52,820
como para llamar constructores

1288
00:58:52,820 --> 00:58:54,380
vale

1289
00:58:54,380 --> 00:58:55,800
entonces

1290
00:58:55,800 --> 00:58:58,980
esto es el que dice

1291
00:58:58,980 --> 00:59:00,639
este es un ejemplo de overriding

1292
00:59:00,639 --> 00:59:05,469
entonces la clase persona

1293
00:59:05,469 --> 00:59:07,030
cuando imprime dice persona

1294
00:59:07,030 --> 00:59:09,329
es un hombre, la clase alumno

1295
00:59:09,329 --> 00:59:11,530
Que está en de persona, dice que es un alumno

1296
00:59:11,530 --> 00:59:12,949
Y cuando lo teste

1297
00:59:12,949 --> 00:59:15,610
Los dos escriben imprimir

1298
00:59:15,610 --> 00:59:16,389
Pero

1299
00:59:16,389 --> 00:59:17,550
El

1300
00:59:17,550 --> 00:59:22,590
Espera, no, ambas

1301
00:59:22,590 --> 00:59:23,869
¿Por qué ambas?

1302
00:59:25,190 --> 00:59:26,510
Porque personaP es igual a

1303
00:59:26,510 --> 00:59:28,949
Ah, sí, vale, sí, sí

1304
00:59:28,949 --> 00:59:30,369
Porque aquí he hecho

1305
00:59:30,369 --> 00:59:33,070
Cuando he hecho personaP igual a

1306
00:59:33,070 --> 00:59:33,889
Vale

1307
00:59:33,889 --> 00:59:36,489
Sostancialmente estoy utilizando

1308
00:59:36,489 --> 00:59:38,769
Una variable persona, pero la instancia

1309
00:59:38,769 --> 00:59:40,570
Que tengo dentro no es una persona

1310
00:59:40,570 --> 00:59:43,769
Es un alumno, porque ha hecho new alumno

1311
00:59:43,769 --> 00:59:46,730
Entonces acordaos que

1312
00:59:46,730 --> 00:59:49,650
No me baso sobre el tipo

1313
00:59:49,650 --> 00:59:51,769
De la variable, sino sobre el tipo

1314
00:59:51,769 --> 00:59:53,230
De la instancia a la que apunta

1315
00:59:53,230 --> 01:00:01,789
Y más o menos este es el resumen

1316
01:00:01,789 --> 01:00:03,630
Mañana hacemos un resumen

1317
01:00:03,630 --> 01:00:04,630
De todo esto, vale

1318
01:00:04,630 --> 01:00:10,030
Y queda esta cosa de aquí

1319
01:00:10,030 --> 01:00:13,030
¿Qué es lo que me preguntaba alguien de vosotros?

1320
01:00:13,130 --> 01:00:14,230
Que es el instance of

1321
01:00:14,230 --> 01:00:14,710
¿Vale?

1322
01:00:14,829 --> 01:00:17,130
El instance of es un operador que me dice

1323
01:00:17,130 --> 01:00:22,889
Si un cierto objeto es una instancia de una cierta clase

1324
01:00:22,889 --> 01:00:24,849
Se usa, por ejemplo, así

1325
01:00:24,849 --> 01:00:26,590
¿Vale?

1326
01:00:27,329 --> 01:00:31,849
Entonces, pensad que yo he creado un gato

1327
01:00:31,849 --> 01:00:32,590
¿Vale?

1328
01:00:33,050 --> 01:00:35,190
Aquí están las clases

1329
01:00:35,190 --> 01:00:36,530
Hay la clase animal

1330
01:00:36,530 --> 01:00:38,809
La clase gato que está en animal

1331
01:00:38,809 --> 01:00:40,789
Y la clase perro que está en animal

1332
01:00:40,789 --> 01:00:41,449
¿Vale?

1333
01:00:41,949 --> 01:00:43,789
Entonces, si yo me pregunto

1334
01:00:43,789 --> 01:00:48,500
La variable gato, que es un gato

1335
01:00:48,500 --> 01:00:50,039
¿Es una instancia de animal?

1336
01:00:51,000 --> 01:00:52,920
Esto me devuelve true

1337
01:00:52,920 --> 01:00:54,480
¿Vale?

1338
01:00:54,659 --> 01:00:56,300
Gato es una instancia de animal

1339
01:00:56,300 --> 01:00:58,000
Porque gato es un animal

1340
01:00:58,000 --> 01:01:00,960
Gato es una instancia de gato

1341
01:01:00,960 --> 01:01:02,079
También true

1342
01:01:02,079 --> 01:01:03,340
¿Vale?

1343
01:01:04,139 --> 01:01:06,559
Ahora, si yo intento gato en instancia de perro

1344
01:01:06,559 --> 01:01:07,239
Se enfada

1345
01:01:07,239 --> 01:01:10,179
Porque perro y gato no tienen nada que ver entre ellos

1346
01:01:10,179 --> 01:01:12,900
Entonces no va a funcionar

1347
01:01:12,900 --> 01:01:14,780
Esto me puede servir

1348
01:01:14,780 --> 01:01:16,760
Para lo que estábamos viendo antes

1349
01:01:16,760 --> 01:01:19,039
De yo voy buscando

1350
01:01:19,039 --> 01:01:19,900
En mi array

1351
01:01:19,900 --> 01:01:22,119
Y cada elemento que pillo

1352
01:01:22,119 --> 01:01:24,380
Hago un if de si esto es

1353
01:01:24,380 --> 01:01:26,019
Una instancia de móvil

1354
01:01:26,019 --> 01:01:28,500
Entonces utiliza lo que es de móvil

1355
01:01:28,500 --> 01:01:29,739
O castea la móvil

1356
01:01:29,739 --> 01:01:32,579
Si en vez no es una instancia de móvil

1357
01:01:32,579 --> 01:01:33,599
Pues no lo hagas

1358
01:01:33,599 --> 01:01:43,559
Mañana lo intentamos más.