1
00:00:00,000 --> 00:00:05,259
Voy a grabar esta clase, por lo tanto, si habláis me autorizáis a grabar vuestra voz.

2
00:00:06,080 --> 00:00:11,880
Entonces, después de la introducción que hemos visto ayer de la herencia,

3
00:00:12,320 --> 00:00:17,620
pues vamos a ver algunas cosillas siempre relacionadas con herencias, pero nuevas.

4
00:00:19,300 --> 00:00:23,199
¿Qué es herencia? De estos ya hemos hablado, en el sentido que, claramente,

5
00:00:23,320 --> 00:00:27,500
mientras yo voy creando nuevas clases que estén en otras clases, etc.,

6
00:00:27,500 --> 00:00:34,179
etcétera, voy creando un árbol, ¿vale? Voy creando una estructura jerárquica de clases que heredan

7
00:00:34,179 --> 00:00:40,079
una de otra, ¿vale? Si no digo nada, las opciones que tengo es que no diga nada, no extenda nada,

8
00:00:40,240 --> 00:00:47,740
entonces implícitamente estoy heredando de la clase Object, ¿vale? Que será la raíz del árbol,

9
00:00:47,740 --> 00:00:54,979
¿vale? O sea, todas las clases que podemos crear en Java, pues heredarán al fin y al cabo de

10
00:00:54,979 --> 00:01:01,039
o puedo heredar específicamente de otra clase. En este caso, por ejemplo,

11
00:01:01,039 --> 00:01:06,200
alumno hereda de persona y persona hereda de object. Entonces, de alguna forma,

12
00:01:06,200 --> 00:01:12,379
en un modo u otro, yo de object tengo que heredar. Sea directamente porque no he dicho nada,

13
00:01:12,379 --> 00:01:18,299
o sea indirectamente porque heredo de otra clase que luego heredará de otra,

14
00:01:18,299 --> 00:01:22,819
que heredará de otra, que heredará al final de object, siempre estoy relacionado con object.

15
00:01:22,819 --> 00:01:34,900
Por eso tengo los métodos definidos en Object, lo que hemos visto aquí, pues estos métodos los tienen todos los objetos que vosotros tengáis.

16
00:01:35,060 --> 00:01:44,260
En particular a nosotros nos interesa el ToString porque es el que se utiliza para dar una descripción del objeto en el que estoy,

17
00:01:44,260 --> 00:01:55,299
coche tendrá su descripción, alumno tendrá su descripción, etcétera, etcétera, para que el ser humano cuando imprima en pantalla este objeto sepa qué objeto es y no un código que no se entiende de qué es.

18
00:01:56,299 --> 00:02:08,460
Y también, antes o después, nos interesará el equals, que me permitirá pillar dos objetos que he creado yo y decir si estos dos objetos son iguales o no.

19
00:02:08,460 --> 00:02:13,780
ser igual por defecto a nivel de objeto

20
00:02:13,780 --> 00:02:17,060
la implementación de este señor de aquí

21
00:02:17,060 --> 00:02:22,120
hace sustancialmente el igual igual

22
00:02:22,120 --> 00:02:42,500
sustancialmente está haciendo lo mismo

23
00:02:42,500 --> 00:02:46,300
la definición digamos básica del

24
00:02:46,300 --> 00:02:48,520
equals te está diciendo que

25
00:02:48,520 --> 00:02:50,439
dos objetos son iguales si

26
00:02:50,439 --> 00:02:51,719
solo si son el mismo objeto.

27
00:02:52,300 --> 00:02:54,719
La misma está. Esta es la definición

28
00:02:54,719 --> 00:02:56,560
que es tan básica. Es una definición

29
00:02:56,560 --> 00:02:58,680
verdadera

30
00:02:58,680 --> 00:03:00,479
para cualquier objeto del mundo. Si tú tienes

31
00:03:00,479 --> 00:03:02,099
dos objetos que son el mismo objeto, pues

32
00:03:02,099 --> 00:03:04,639
la referencia A es igual a la referencia

33
00:03:04,639 --> 00:03:06,659
B. Pues sí. Si ahora

34
00:03:06,659 --> 00:03:08,520
tú quieres modificar

35
00:03:08,520 --> 00:03:10,659
un poco estas cosas, como por ejemplo tú dices

36
00:03:10,659 --> 00:03:12,280
estoy gestionando coches

37
00:03:12,280 --> 00:03:14,560
y para mí si dos coches tienen el mismo

38
00:03:14,560 --> 00:03:22,900
color son iguales porque porque en tu sistema se es un que se yo son carreras y si tiene el

39
00:03:22,900 --> 00:03:27,560
mismo color que son el mismo equipo y a ti te interesa por equipo no tanto el coche por sí

40
00:03:27,560 --> 00:03:32,500
mismo como por los equipos por lo tanto si dos coches distintos dos instantes distintas tienen

41
00:03:32,500 --> 00:03:38,259
el mismo color pues entonces son el mismo objeto para ti porque parte del mismo team pues entonces

42
00:03:38,259 --> 00:03:45,240
Entonces puedes modificar este equals para que te devuelva true cuando el color de los dos objetos es igual,

43
00:03:45,419 --> 00:03:48,000
y false cuando el color de los objetos es distinto, ¿vale?

44
00:03:48,319 --> 00:03:52,039
Pero en esto llegaremos un poco más adelante, ¿vale?

45
00:03:52,120 --> 00:03:58,080
Sepáis simplemente que estas son dos cosas que existen en object y que vamos a utilizar.

46
00:03:58,080 --> 00:04:00,620
Hay otras cosillas que están por aquí, ¿vale?

47
00:04:00,620 --> 00:04:12,840
Esto Notify, NotifyAll y Wait y cosas por el estilo, si haréis el segundo de DAM en procesos y servicios,

48
00:04:12,979 --> 00:04:16,100
programación de procesos y servicios, vais a ver que son estas cosas.

49
00:04:16,519 --> 00:04:21,600
Que sustancialmente son mecanismos de sincronización para Multithreading.

50
00:04:22,120 --> 00:04:23,779
¿Vale? Bueno, están aquí.

51
00:04:26,199 --> 00:04:26,740
¿Qué más?

52
00:04:30,569 --> 00:04:33,569
Constructores y herencias. Esto lo hemos hablado antes, ¿vale?

53
00:04:33,569 --> 00:04:40,750
lo volvemos a decir porque así queda queda grabado pues nosotros cuando creamos un objeto primero se

54
00:04:40,750 --> 00:04:46,029
crea su parte base y luego se crea la parte derivada primero se crea la parte de la super

55
00:04:46,029 --> 00:04:54,550
clase y luego se crea la parte de la sub clase vale asumiendo que todas las clases heredan de

56
00:04:54,550 --> 00:05:00,790
object, pues antes o después tendré, o sea, el primer paso siempre será crear un

57
00:05:00,790 --> 00:05:08,290
object. La idea es que, si la clase B a base hereda de otra, etcétera, etcétera, se

58
00:05:08,290 --> 00:05:13,310
hace el paso uno de la superior, paso uno de la superior, paso uno de la superior, hasta

59
00:05:13,310 --> 00:05:18,189
llegar a, sustancialmente, object. Cuando llega object, no puedo ir por arriba de

60
00:05:18,189 --> 00:05:23,149
object, porque esa es la raíz, entonces empezaré creando el object. Entonces, por

61
00:05:23,149 --> 00:05:28,610
Por ejemplo, si creo un alumno que hereda de persona, los pasos serán estos dos pasos, uno y dos.

62
00:05:28,850 --> 00:05:35,610
El paso uno es crear la parte correspondiente a persona, porque tengo que crear la parte base de alumno.

63
00:05:35,930 --> 00:05:38,529
Y como alumno hereda de persona, pues creo persona.

64
00:05:38,810 --> 00:05:40,810
Pero para crear una persona, ¿qué tengo que hacer?

65
00:05:41,089 --> 00:05:45,990
Otra vez el paso uno, que será crear la parte base de persona.

66
00:05:46,410 --> 00:05:50,769
Y como persona hereda de object, pues lo que hago es crear la parte correspondiente al object.

67
00:05:50,769 --> 00:05:57,069
Una vez que he creado la parte del objeto, paso a la parte dos, que es añadir la parte derivada,

68
00:05:57,069 --> 00:06:01,269
la parte derivada de persona, porque aquí estoy construyendo una persona. Estoy en la parte uno

69
00:06:01,269 --> 00:06:07,870
de alumno en el que tengo que crear la persona. Entonces al objeto base le he añadido todo lo

70
00:06:07,870 --> 00:06:14,769
que sea relacionado con persona y a este punto paso a la parte dos del alumno. He creado la

71
00:06:14,769 --> 00:06:24,189
persona, añado los elementos de alumno. Quiero crear un alumno. Para crear un alumno tengo que

72
00:06:24,189 --> 00:06:29,050
crear una persona. Para crear una persona tengo que crear un objeto. La primera cosa que se crea

73
00:06:29,050 --> 00:06:36,730
es la parte relacionada al objeto. Esta es la parte núcleo. Todos tienen que empezar por allí,

74
00:06:36,730 --> 00:06:43,870
porque todos al fin y al cabo alrededor del objeto. Alrededor del objeto le crearé la parte

75
00:06:43,870 --> 00:06:54,889
más específica de persona, habiendo creado la superclase, la primera superclase de alumno.

76
00:06:54,889 --> 00:07:07,860
¿Vale? Entonces ahora crearé la parte relacionada al alumno. ¿Se entiende? Y al final tendré mi

77
00:07:07,860 --> 00:07:12,120
objeto alumno, que dentro tiene una persona, que dentro tiene un objeto. Por lo tanto,

78
00:07:12,120 --> 00:07:16,800
un alumno es una persona y una persona es un objeto. Cualquier cosa que pueda hacer un objeto

79
00:07:16,800 --> 00:07:18,519
lo puede hacer un alumno porque

80
00:07:18,519 --> 00:07:20,920
todo lo que sirve para hacer las cosas del objeto

81
00:07:20,920 --> 00:07:24,350
está aquí. Y cualquier

82
00:07:24,350 --> 00:07:26,209
cosa que pueda hacer un alumno o una persona

83
00:07:26,209 --> 00:07:28,310
lo puede hacer también un alumno porque cualquier cosa

84
00:07:28,310 --> 00:07:30,329
que se necesita para trabajar con personas

85
00:07:30,329 --> 00:07:32,470
está aquí. Y alumno lo tiene.

86
00:07:33,670 --> 00:07:33,790
¿Vale?

87
00:07:34,170 --> 00:07:36,149
Y alumno puede hacer todo lo que pueda hacer un alumno

88
00:07:36,149 --> 00:07:37,970
porque todo lo que sirve para alumno está aquí.

89
00:07:40,490 --> 00:07:41,910
Ahora, una persona no puede hacer

90
00:07:41,910 --> 00:07:43,930
lo que está alumno porque si yo tengo una persona

91
00:07:43,930 --> 00:07:46,129
cuando creo una persona crearé un object

92
00:07:46,129 --> 00:07:49,689
y luego alrededor del objeto

93
00:07:49,689 --> 00:07:56,180
les va a crear una persona, que tiene aquí sus datos, pero no tiene las cosas de alumno,

94
00:07:56,180 --> 00:08:10,149
entonces no puede hacer la programación. ¿Entendéis? ¿Recordáis esto? No, no sé dónde está.

95
00:08:10,149 --> 00:08:17,389
Esto. ¿Vale? Si creo un profesor, pues, si tengo que crear un profesor, que esta es su cosa,

96
00:08:17,389 --> 00:08:24,470
pues, ¿qué tendré que hacer? Pues, profesor tiene que crear empleado, empleado tiene que crear

97
00:08:24,470 --> 00:08:26,449
persona, persona tiene que crear object

98
00:08:26,449 --> 00:08:28,269
la primera cosa que se crea es object

99
00:08:28,269 --> 00:08:30,790
¿vale? alrededor de object se extenderá

100
00:08:30,790 --> 00:08:32,830
con las cosas relacionadas con persona

101
00:08:32,830 --> 00:08:34,350
esta cosa de aquí

102
00:08:34,350 --> 00:08:36,529
que le servía a empleado, pues ahora

103
00:08:36,529 --> 00:08:38,570
se extiende con las cosas del empleado

104
00:08:38,570 --> 00:08:40,750
y esta cosa de aquí que servía

105
00:08:40,750 --> 00:08:42,470
al profesor, ahora

106
00:08:42,470 --> 00:08:48,279
se extiende con las cosas del profesor

107
00:08:48,279 --> 00:08:49,600
¿entienden el mecanismo?

108
00:08:51,440 --> 00:08:52,000
dudas

109
00:08:52,000 --> 00:08:55,840
y difícil

110
00:08:55,840 --> 00:09:00,110
esto

111
00:09:00,110 --> 00:09:05,769
Constructor de herencia y constructor de la clase derivada

112
00:09:05,769 --> 00:09:08,450
Se realiza siempre una llamada al constructor de la clase base

113
00:09:08,450 --> 00:09:09,710
Siempre, ¿vale?

114
00:09:10,230 --> 00:09:11,450
Siempre hay un super

115
00:09:11,450 --> 00:09:14,830
Que sea implícito, explícito o lo que sea

116
00:09:14,830 --> 00:09:16,470
Pero siempre se hará una llamada

117
00:09:16,470 --> 00:09:16,909
¿Por qué?

118
00:09:16,990 --> 00:09:19,870
Porque tiene que crear la superclase antes de poder

119
00:09:19,870 --> 00:09:21,309
O sea, el superobjeto, digamos

120
00:09:21,309 --> 00:09:24,370
Antes de poder crear la parte específica del objeto

121
00:09:24,370 --> 00:09:25,990
Del que estoy llamando, ¿vale?

122
00:09:26,549 --> 00:09:27,850
Bien, esta primera acción del constructor

123
00:09:27,850 --> 00:09:30,049
Aparece en la primera línea, ¿vale?

124
00:09:30,110 --> 00:09:38,210
Tiene que aparecer en la primera línea siempre y se puede o no indicarlo explícitamente o indicarlo explícitamente.

125
00:09:38,389 --> 00:09:39,330
Siempre en la primera línea.

126
00:09:39,830 --> 00:09:47,470
Si no lo hago explícitamente, él hace una llamada invisible a súper.

127
00:09:48,970 --> 00:09:55,990
Si yo tengo un constructor que hace todas estas cosas, automáticamente, hasta si yo hago esto,

128
00:09:55,990 --> 00:09:59,809
Veis que es un poco feo porque es el que habíamos dicho de no hacer.

129
00:10:00,490 --> 00:10:04,370
Pero aquí se ha hecho la llamada de super.

130
00:10:04,730 --> 00:10:10,129
Tened en cuenta que el nombre, apellido y año de nacimiento de alumno están definidos en persona.

131
00:10:10,850 --> 00:10:21,759
Entonces, cuando yo llamo este super, cuando yo desde empiezo a crear un alumno, creo crear un alumno.

132
00:10:21,759 --> 00:10:28,899
Y la primera cosa, hago el super, es porque me voy a crear un objeto con espacio suficiente

133
00:10:28,899 --> 00:10:40,889
con espacio suficiente para poner aquí el nombre, aquí el año y aquí el

134
00:10:40,889 --> 00:10:55,470
Y luego crearé mi alumno y hemos dicho que el nombre que me has pasado por parámetro lo guardo aquí.

135
00:10:55,830 --> 00:10:59,610
Y fíjate que tengo este espacio porque lo he creado cuando he creado la persona.

136
00:10:59,610 --> 00:11:05,309
Entonces ahora el nombre lo pongo aquí, el año de nacimiento lo pongo aquí, el no sé qué otro lo pongo aquí.

137
00:11:05,309 --> 00:11:16,629
Y luego, en vez, los parámetros que son más propios del alumno, que son grupo y horario, pues estarán en esta parte de aquí.

138
00:11:16,809 --> 00:11:19,210
Aquí habrá espacio para grupo y espacio para horario.

139
00:11:19,370 --> 00:11:22,929
Entonces, el grupo lo pondré aquí y el horario lo pondré aquí.

140
00:11:24,110 --> 00:11:25,570
Y ahora ya tengo toda la información.

141
00:11:26,129 --> 00:11:29,330
Tanto como si fuera una persona y como si fuera un alumno.

142
00:11:30,070 --> 00:11:30,490
¿Se entiende?

143
00:11:34,559 --> 00:11:36,759
Entonces, no digo nada.

144
00:11:36,759 --> 00:11:39,440
Él hace en automático

145
00:11:39,440 --> 00:11:41,700
Siempre una llamada a super

146
00:11:41,700 --> 00:11:43,820
Esto es el problema que decimos antes

147
00:11:43,820 --> 00:11:45,519
Si yo en mi clase superior

148
00:11:45,519 --> 00:11:47,740
Si yo en persona no tengo un constructor

149
00:11:47,740 --> 00:11:48,700
Sin parámetros

150
00:11:48,700 --> 00:11:50,639
Esto me dará un error

151
00:11:50,639 --> 00:11:53,299
No lo puedo hacer porque implícitamente

152
00:11:53,299 --> 00:11:55,720
Estoy haciendo una llamada a super sin parámetros

153
00:11:55,720 --> 00:11:58,039
Y tú no has definido un constructor

154
00:11:58,039 --> 00:11:59,139
Sin parámetros

155
00:11:59,139 --> 00:12:00,820
¿Sí?

156
00:12:02,059 --> 00:12:04,120
La otra opción es en vez que

157
00:12:04,120 --> 00:12:06,139
Explícitamente llame yo

158
00:12:06,139 --> 00:12:08,220
el super, entonces te estoy diciendo

159
00:12:08,220 --> 00:12:10,080
mira, no uses, o sí

160
00:12:10,080 --> 00:12:12,200
pero usa este constructor

161
00:12:12,200 --> 00:12:13,720
de aquí, que yo sé que existe

162
00:12:13,720 --> 00:12:15,419
arriba, ¿vale?

163
00:12:15,559 --> 00:12:18,039
y por lo tanto no necesitas

164
00:12:18,039 --> 00:12:19,879
tú hacer la llamada implícita

165
00:12:19,879 --> 00:12:22,220
al constructor por defecto o a lo que sea

166
00:12:22,220 --> 00:12:23,899
o al constructor sin parámetro

167
00:12:23,899 --> 00:12:25,220
¿dudas?

168
00:12:29,669 --> 00:12:29,950
vale

169
00:12:29,950 --> 00:12:33,809
dos conceptos relativamente

170
00:12:33,809 --> 00:12:36,129
complejos

171
00:12:36,129 --> 00:12:36,990
¿vale?

172
00:12:37,669 --> 00:12:39,629
shadowing y overriding

173
00:12:39,629 --> 00:12:56,370
¿Vale? Overriding lo hemos visto ya. Es lo de tu stream. Es sustantivamente sobrecargar, no, sobre escribir los métodos de clases superiores. ¿Vale? Lo vemos después.

174
00:12:56,370 --> 00:13:01,789
El shadowing es algo parecido, pero no con los métodos,

175
00:13:02,070 --> 00:13:03,190
sino con los atributos.

176
00:13:04,429 --> 00:13:10,509
Yo puedo declarar una subclase y en la subclase volver a declarar

177
00:13:10,509 --> 00:13:14,049
un atributo con el mismo nombre de la superclase.

178
00:13:15,149 --> 00:13:16,370
Esto le hace sombra.

179
00:13:20,379 --> 00:13:26,019
La clase derivada puede definir un atributo con el mismo nombre

180
00:13:26,019 --> 00:13:28,940
que uno de la clase base, o sea, que uno de la superclase,

181
00:13:29,220 --> 00:13:40,659
Esto se llama Shadowing, o puede declarar un método con la misma signatura, con la misma firma que uno de la clase base, de la superclase.

182
00:13:40,860 --> 00:13:42,080
Y esto se llama Overriding.

183
00:13:44,720 --> 00:13:49,159
Lo más usual cuando se produce la escritura es que se le escriba un método.

184
00:13:49,519 --> 00:13:51,320
O sea, normalmente se usa el Overriding.

185
00:13:51,539 --> 00:13:54,860
El Shadowing yo tengo muy poca experiencia de haberlo utilizado.

186
00:13:54,860 --> 00:14:00,720
servirá, se utilizará muchísimo, pero el overriding se usa constantemente,

187
00:14:00,720 --> 00:14:02,720
shadowing mucho menos.

188
00:14:04,720 --> 00:14:06,720
Shadowing, ejemplo.

189
00:14:06,720 --> 00:14:11,720
Imaginaos la clase Persona que pone public string nombre cuando.

190
00:14:12,720 --> 00:14:16,720
Y luego tengo la clase alumno que extiende Persona,

191
00:14:16,720 --> 00:14:18,720
es una subclase de Persona,

192
00:14:18,720 --> 00:14:23,720
y aquí pongo public int nombre y uno entero.

193
00:14:23,720 --> 00:14:32,059
¿Veis que es el mismo nombre, el mismo identificador utilizado, pero aquí es un string y aquí es un int?

194
00:14:32,500 --> 00:14:34,419
Podría ser otra vez string aquí, ¿eh?

195
00:14:35,159 --> 00:14:43,139
Pero es como si yo defino que la persona tiene que tener un nombre y el alumno también tiene que tener un nombre, ¿vale?

196
00:14:43,419 --> 00:14:47,980
Y este nombre de alumno hace sombra al nombre de persona.

197
00:14:47,980 --> 00:14:55,919
Ahora, si tú usas un alumno, usarás este nombre de aquí. Y si usas una persona, usarás este nombre de aquí.

198
00:14:55,919 --> 00:15:05,429
Grosso modo. De hecho, si tú creas un alumno y luego creas una referencia al mismo objeto alumno,

199
00:15:05,429 --> 00:15:18,340
pero la referencia de tipo persona. Fijaos. ¿Cuántos objetos hay aquí? Uno. Hay un solo

200
00:15:18,340 --> 00:15:31,730
objeto lo que he hecho es crear un objeto alumno este es el objeto alumno con dentro la cosa

201
00:15:31,730 --> 00:15:40,669
persona lo que sea y le he dicho que el alumno a se llama a es una variable de tipo alumno

202
00:15:42,169 --> 00:15:49,909
y apunta a este objeto y luego he dicho persona p es igual a entonces lo que he hecho es crear

203
00:15:49,909 --> 00:15:59,860
una variable p de tipo persona y ésta apunta al mismo objeto. ¿Lo puedo hacer? ¿Puedo

204
00:15:59,860 --> 00:16:09,340
poner un objeto alumno dentro de un objeto de una referencia persona? ¿Por qué puedo

205
00:16:09,340 --> 00:16:20,950
hacerlo? Un alumno es una persona, por lo tanto yo puedo referenciar a un alumno como

206
00:16:20,950 --> 00:16:27,009
Lo que no puedo hacer es referenciar con una referencia alumno, de tipo alumno, una persona.

207
00:16:32,110 --> 00:16:37,269
Porque alumno implicaría que podría hacer más cosas de lo que puede hacer una persona.

208
00:16:37,990 --> 00:16:44,190
Si yo tuviera un objeto persona, no lo puedo referenciar con una referencia alumno.

209
00:16:46,360 --> 00:16:50,000
Porque entonces esto me permitiría hacer cosas que una persona en realidad no puede hacer.

210
00:16:50,320 --> 00:16:52,139
Pero algunas cosas las podrías hacer también.

211
00:16:52,419 --> 00:16:53,399
Pero no todos los demás.

212
00:16:54,980 --> 00:16:58,980
Si tú me estás diciendo, este es un alumno, tiene que poder hacer todo lo que tenga que hacer un alumno.

213
00:16:59,500 --> 00:17:04,119
Y si hay nota media y una persona no tiene nota media, no lo puedes hacer.

214
00:17:04,619 --> 00:17:06,099
Entonces, esto no.

215
00:17:07,160 --> 00:17:12,299
Sin embargo, esto sí, porque un alumno puede hacer absolutamente todo lo que tiene una persona.

216
00:17:12,400 --> 00:17:15,380
Porque tiene una persona dentro. Cada alumno tiene una persona dentro.

217
00:17:20,259 --> 00:17:21,799
No todos, todos, pero...

218
00:17:21,799 --> 00:17:24,500
¿Vale? Entonces,

219
00:17:24,500 --> 00:17:40,640
Entonces, si yo ahora escribo system.auto.ptml p.nombre, o sea, estoy usando la referencia de persona, me escribe Juan, porque me lo trata como persona y accede a este nombre.

220
00:17:40,640 --> 00:17:54,250
Si en vez hago a.nombre, me accede como si fuera un alumno y me saca esta.

221
00:17:57,599 --> 00:18:02,859
Cuidado, porque es el exacto opuesto que en el overriding.

222
00:18:03,619 --> 00:18:05,440
¿Vale? Esto es como funciona en shadowing.

223
00:18:05,640 --> 00:18:06,759
Veremos que en overriding no.

224
00:18:09,619 --> 00:18:09,779
¿Sí?

225
00:18:12,180 --> 00:18:13,519
Va a complicar un poco las cosas.

226
00:18:14,680 --> 00:18:14,900
¿Vale?

227
00:18:14,900 --> 00:18:21,599
Si definimos en una subclase un atributo con el mismo nombre y tipo que la superclase,

228
00:18:21,599 --> 00:18:27,859
la superclase queda oculto. Podemos acceder a la variable de la subclase utilizando this

229
00:18:27,859 --> 00:18:35,420
y super como, de esta forma. Imaginaos que está transporte, vehículo que hereda de transporte

230
00:18:35,420 --> 00:18:42,480
y coche que hereda de vehículo. En transporte, en la clase transporte, ya he definido string

231
00:18:42,480 --> 00:18:49,720
le he dado el valor terrestre. En vehículo tengo string nombre turismo y en coche tengo

232
00:18:49,720 --> 00:18:59,200
string nombre Ferrari, como mi coche. Entonces, si yo uso nombre, si yo estoy en esta clase

233
00:18:59,200 --> 00:19:06,019
de aquí, si yo estoy en coche, estoy usando un objeto de coche y le digo nombre, me utilizará

234
00:19:06,019 --> 00:19:08,019
este nombre. ¿Vale?

235
00:19:08,220 --> 00:19:09,099
Saldrá Ferrari.

236
00:19:10,059 --> 00:19:11,619
Si hago dis.nombre,

237
00:19:12,000 --> 00:19:12,480
lo mismo.

238
00:19:14,019 --> 00:19:16,700
Si hago super.nombre,

239
00:19:17,640 --> 00:19:18,660
me usará

240
00:19:18,660 --> 00:19:19,579
el de vehículo.

241
00:19:20,619 --> 00:19:22,480
Me está diciendo, en vez de usar dis,

242
00:19:23,619 --> 00:19:24,420
usa super.

243
00:19:24,920 --> 00:19:26,460
O sea, considera

244
00:19:26,460 --> 00:19:28,640
este objeto, no como

245
00:19:28,640 --> 00:19:30,640
si fuera una instancia de esta

246
00:19:30,640 --> 00:19:32,740
clase, pero como si fuera

247
00:19:32,740 --> 00:19:34,559
una instancia de la clase

248
00:19:34,559 --> 00:19:37,910
super. Cuidado que este

249
00:19:37,910 --> 00:19:40,069
super no es el mismo super que hemos visto

250
00:19:40,069 --> 00:19:40,430
antes.

251
00:19:45,349 --> 00:19:45,910
Repito.

252
00:19:48,150 --> 00:19:48,710
Cuando

253
00:19:48,710 --> 00:19:50,710
usas este super de aquí, este super es

254
00:19:50,710 --> 00:19:52,769
igual a este dis. ¿Os acordáis que

255
00:19:52,769 --> 00:19:54,549
dis era una referencia a este

256
00:19:54,549 --> 00:19:56,589
objeto? Pues super es una

257
00:19:56,589 --> 00:19:58,069
referencia a este objeto,

258
00:19:58,650 --> 00:20:00,750
pero no considerado como si

259
00:20:00,750 --> 00:20:02,150
fuera de esta clase,

260
00:20:02,150 --> 00:20:04,269
sino como si fuera una instancia

261
00:20:04,269 --> 00:20:05,730
de la clase superior.

262
00:20:08,019 --> 00:20:09,079
O sea que en este caso

263
00:20:09,079 --> 00:20:11,559
te está refiriendo a este objeto, pero

264
00:20:11,559 --> 00:20:13,299
trátalo no como un coche,

265
00:20:13,819 --> 00:20:14,640
sino como un vehículo.

266
00:20:16,299 --> 00:20:17,599
O sea, super es un dis

267
00:20:17,599 --> 00:20:19,480
para la clase superior.

268
00:20:20,140 --> 00:20:21,700
Es un trata a este objeto

269
00:20:21,700 --> 00:20:23,119
en referencia a este objeto,

270
00:20:23,660 --> 00:20:25,740
pero considerado como si fuera

271
00:20:25,740 --> 00:20:26,740
de la clase superior.

272
00:20:28,160 --> 00:20:29,779
Si no quieres usar super porque te lía,

273
00:20:29,900 --> 00:20:30,880
puedes usar esto.

274
00:20:32,079 --> 00:20:32,839
Pillo dis,

275
00:20:33,740 --> 00:20:35,700
lo casteo a vehículo,

276
00:20:35,700 --> 00:20:38,140
entonces ahora

277
00:20:38,140 --> 00:20:40,099
dis se transforma en un objeto

278
00:20:40,099 --> 00:20:42,140
vehículo, y a este punto accedes al

279
00:20:42,140 --> 00:20:44,319
nombre. Y entonces sale el nombre del vehículo

280
00:20:44,319 --> 00:20:45,460
también. Turismo.

281
00:20:49,140 --> 00:20:50,519
Lo que no puedes hacer es super, super.

282
00:20:52,920 --> 00:20:54,980
Super, super, punto nombre, error.

283
00:20:55,779 --> 00:20:57,079
Si quieres hacer super, super,

284
00:20:57,180 --> 00:20:58,880
punto nombre, o sea que desde aquí

285
00:20:58,880 --> 00:21:01,180
acceder a esta

286
00:21:01,180 --> 00:21:03,019
variable de aquí, tienes que usar

287
00:21:03,019 --> 00:21:04,779
este mecanismo diciendo, oye,

288
00:21:05,160 --> 00:21:07,059
tú eres dis, eres este objeto.

289
00:21:07,880 --> 00:21:08,960
Castéalo como si

290
00:21:08,960 --> 00:21:10,880
estuvieras trabajando con un transporte,

291
00:21:10,880 --> 00:21:17,390
transporte y a este punto accede a su nombre. Entonces estoy accediendo a éste.

292
00:21:17,589 --> 00:21:22,029
No tendrías que pasar por vehículo directamente, hace referencia al supersuper.

293
00:21:22,230 --> 00:21:27,549
Porque este objeto tú lo puedes tratar como coche, pero es también un vehículo.

294
00:21:27,750 --> 00:21:29,470
También es un transporte. Aquí le estás

295
00:21:29,670 --> 00:21:36,869
simplemente diciendo a qué clase quieres, qué tipo de instancia quiere que sea.

296
00:21:37,069 --> 00:21:42,269
Realmente, si aquí le pongo gato, pues no funciona porque coche no es un gato.

297
00:21:42,269 --> 00:21:58,130
Entonces, desde coche, desde los métodos de coche, si yo puedo acceder a las tres variables que han sido sombreadas, que han sido hechas shadowing, que han sido ocultadas usando estas cosas de aquí.

298
00:21:58,130 --> 00:22:02,390
Si yo uso nombre a secas, pues me usará el nombre propio de esta árbol.

299
00:22:02,869 --> 00:22:06,109
Ahora, si usa esto, ¿es cómodo? ¿Para qué sirve?

300
00:22:09,759 --> 00:22:11,059
No lo he usado.

301
00:22:11,200 --> 00:22:21,160
No he llegado en sitios en mi carrera de profesor en el que ha sido necesario usar el shallot.

302
00:22:21,660 --> 00:22:23,559
Seguramente en algunas situaciones está.

303
00:22:23,559 --> 00:22:33,200
Por ejemplo, una cosa de ese estilo podría servir para ocultar la identidad de un alumno.

304
00:22:34,559 --> 00:22:36,759
Yo creo un alumno y le asigno un código.

305
00:22:37,619 --> 00:22:39,940
Por detrás está una persona con su nombre.

306
00:22:40,900 --> 00:22:46,819
Pero luego al profesor que corrige el examen no le doy acceso a la persona,

307
00:22:46,960 --> 00:22:50,740
no le doy acceso a métodos que permiten llegar a la persona.

308
00:22:50,740 --> 00:22:54,099
Entonces él cuando verá y buscará el nombre del alumno

309
00:22:54,099 --> 00:22:55,920
Siempre le saldrá un código

310
00:22:55,920 --> 00:22:57,240
Anonimizado

311
00:22:57,240 --> 00:22:58,440
No sabe quién es

312
00:22:58,440 --> 00:23:01,980
Pero una vez que ha acabado la corrección

313
00:23:01,980 --> 00:23:03,220
El profesor

314
00:23:03,220 --> 00:23:04,940
Debe dar las notas

315
00:23:04,940 --> 00:23:07,579
Y el sistema podrá acceder

316
00:23:07,579 --> 00:23:09,160
Por cada alumno

317
00:23:09,160 --> 00:23:10,940
A su nombre real

318
00:23:10,940 --> 00:23:12,660
Accediéndolo como persona

319
00:23:12,660 --> 00:23:18,759
Hay otra forma de hacer eso

320
00:23:18,759 --> 00:23:27,740
Vale, este era el shadowing

321
00:23:27,740 --> 00:23:29,079
Si habéis

322
00:23:29,079 --> 00:23:32,160
entendido algo de lo que os he dicho

323
00:23:32,160 --> 00:23:35,900
nosotros accedemos

324
00:23:35,900 --> 00:23:37,299
a una variable

325
00:23:37,299 --> 00:23:39,559
a un atributo, nombre por ejemplo

326
00:23:39,559 --> 00:23:40,460
¿vale?

327
00:23:41,339 --> 00:23:43,160
hay una referencia

328
00:23:43,160 --> 00:23:44,859
estas cajitas de aquí

329
00:23:44,859 --> 00:23:48,539
que apuntan a un objeto

330
00:23:48,539 --> 00:23:50,259
y yo de allí accedo a su nombre

331
00:23:50,259 --> 00:23:52,920
en el shadowing

332
00:23:52,920 --> 00:23:54,019
¿sí?

333
00:23:55,339 --> 00:23:55,759
el

334
00:23:55,759 --> 00:23:59,079
el atributo que voy

335
00:23:59,079 --> 00:24:01,319
a tocar depende

336
00:24:01,319 --> 00:24:03,700
de la referencia que use.

337
00:24:05,140 --> 00:24:05,900
Es decir,

338
00:24:07,279 --> 00:24:07,660
¿cuántos

339
00:24:07,660 --> 00:24:11,180
objetos hay aquí? Uno.

340
00:24:11,779 --> 00:24:13,220
¿Y ese objeto qué tipo tiene?

341
00:24:17,000 --> 00:24:17,680
Alumno.

342
00:24:20,849 --> 00:24:22,369
El new lo he hecho de alumno.

343
00:24:23,349 --> 00:24:24,430
¿Esto es una instancia

344
00:24:24,430 --> 00:24:25,109
de qué clase?

345
00:24:26,569 --> 00:24:27,750
De alumno.

346
00:24:29,170 --> 00:24:30,970
Pero dependiendo

347
00:24:30,970 --> 00:24:32,349
de su referencia,

348
00:24:32,349 --> 00:24:34,430
si uso

349
00:24:34,430 --> 00:24:36,549
A o uso P, que son la referencia

350
00:24:36,549 --> 00:24:38,470
A es una referencia de tipo alumno

351
00:24:38,470 --> 00:24:40,509
y P es una referencia de tipo persona,

352
00:24:40,950 --> 00:24:44,009
pues accederé a un nombre o a otro.

353
00:24:45,230 --> 00:24:48,549
Lo que cuenta es el tipo de la referencia,

354
00:24:49,309 --> 00:24:50,589
no el tipo de la instancia.

355
00:24:51,210 --> 00:24:53,769
Tanto P como A son alumnos.

356
00:24:55,880 --> 00:24:57,420
La instancia es un alumno.

357
00:24:57,599 --> 00:24:59,200
Yo he creado un objeto alumno.

358
00:25:00,099 --> 00:25:02,740
Pero dependiendo de si me refiero a él como alumno

359
00:25:02,740 --> 00:25:04,299
o me refiero a él como persona,

360
00:25:04,420 --> 00:25:06,660
me contestará el número o me contestará cuál.

361
00:25:07,859 --> 00:25:08,940
¿Se entiende?

362
00:25:10,420 --> 00:25:10,579
¿Sí?

363
00:25:11,380 --> 00:25:12,799
Pues en los riding es al revés.

364
00:25:13,220 --> 00:25:13,940
No es así.

365
00:25:15,920 --> 00:25:17,599
¿Cómo es riding? ¿Qué es?

366
00:25:17,819 --> 00:25:19,599
Es la reescritura de métodos

367
00:25:19,599 --> 00:25:23,299
de una superclase

368
00:25:23,299 --> 00:25:24,740
en una subclase.

369
00:25:25,460 --> 00:25:26,960
¿Vale? Entonces yo estoy en una subclase,

370
00:25:27,079 --> 00:25:29,259
sé que mi padre o mi superclase

371
00:25:29,259 --> 00:25:31,680
tiene un método ya implementado,

372
00:25:32,240 --> 00:25:32,539
pero

373
00:25:32,539 --> 00:25:35,740
se me queda corto.

374
00:25:35,740 --> 00:25:36,539
¿Vale?

375
00:25:36,539 --> 00:26:01,960
Como por ejemplo el describir, ¿no? Cuando nosotros hemos hecho esto y hemos hecho el estado, ¿vale? El estado del dispositivo solo habla de si está encendido y del número serial, que para un dispositivo vale, pero cuando llega un móvil me gustaría saber algo más porque yo tengo algo más de solo el número serial y el estado.

376
00:26:01,960 --> 00:26:05,400
Tengo también el número. Entonces, me gustaría que usara también eso.

377
00:26:06,359 --> 00:26:11,519
Entonces, a nivel de dispositivo, tengo el método, que es este de aquí.

378
00:26:11,640 --> 00:26:16,779
Lo puedo usar, pero lo quiero especificar más para la subclase.

379
00:26:17,940 --> 00:26:21,160
Quiero hacer algo más o algo distinto.

380
00:26:21,779 --> 00:26:23,980
A lo mejor en el dispositivo solo dice esta cosa.

381
00:26:24,059 --> 00:26:27,799
En el móvil quiero que haga cosas más, cosas distintas, cosas...

382
00:26:27,799 --> 00:26:28,420
Quiero cambiar.

383
00:26:28,420 --> 00:26:30,799
¿Vale? Entonces, lo que puedo hacer es

384
00:26:30,799 --> 00:26:32,940
sobreescribirlo. Overwrite.

385
00:26:33,200 --> 00:26:34,299
¿Vale? Que sería

386
00:26:34,299 --> 00:26:36,640
esto. ¿Vale? No es

387
00:26:36,640 --> 00:26:38,900
overwrite, no es overwrite.

388
00:26:39,240 --> 00:26:40,859
¿Vale? Pero en español

389
00:26:40,859 --> 00:26:41,940
creo que se dice sobreescribir.

390
00:26:42,720 --> 00:26:44,720
Entonces, vuelvo a escribir

391
00:26:44,720 --> 00:26:46,539
el mismo método

392
00:26:46,539 --> 00:26:48,539
con la misma firma.

393
00:26:48,940 --> 00:26:50,579
Fijaos que la firma es la misma.

394
00:26:52,839 --> 00:26:54,059
Y yo dentro de aquí

395
00:26:54,059 --> 00:26:57,619
no lo podría hacer. Porque me

396
00:26:57,619 --> 00:26:59,420
dice, ¡ay, mira! Tienes dos

397
00:26:59,420 --> 00:27:00,779
métodos con la misma firma.

398
00:27:01,299 --> 00:27:16,640
Pero si yo tengo una clase y otra clase la hereda y vuelve a escribir esto, Java te dice, vale, lo puedes hacer. Lo que estás haciendo es pillar ese método que existía para dispositivo, pues ahora existe para móvil.

399
00:27:16,640 --> 00:27:31,240
Y que si tú tienes una instancia, no una referencia, una instancia de dispositivo, yo usaré el método del dispositivo.

400
00:27:31,920 --> 00:27:38,700
Si tú tienes una instancia de móvil, yo usaré el método de móvil.

401
00:27:41,470 --> 00:27:44,150
No referencia, instancia.

402
00:27:44,710 --> 00:27:48,250
Aquí cuenta sobre qué has hecho la new.

403
00:27:48,849 --> 00:27:56,890
él siempre usará el método más cercano a la instancia que tú has creado.

404
00:27:58,470 --> 00:27:59,210
Está claro.

405
00:28:00,009 --> 00:28:02,410
Que es lo que no hacía con el shadowing.

406
00:28:02,869 --> 00:28:05,150
Con el shadowing contaba la referencia.

407
00:28:05,569 --> 00:28:08,630
Si yo tenía el mismo objeto, pero una referencia alumno o persona,

408
00:28:09,009 --> 00:28:11,470
si lo llamaba con alumno era una cosa, si lo llamaba con persona era otra.

409
00:28:12,130 --> 00:28:15,309
Ahora, si yo tengo un alumno y dos referencias, alumno y persona,

410
00:28:15,309 --> 00:28:17,509
pues siempre va a usar el de alumno

411
00:28:17,509 --> 00:28:19,289
porque la instancia es alumno

412
00:28:19,289 --> 00:28:20,309
no es persona

413
00:28:20,309 --> 00:28:23,960
es decir esto

414
00:28:23,960 --> 00:28:27,380
es decir donde estoy

415
00:28:27,380 --> 00:28:34,839
yo tengo

416
00:28:34,839 --> 00:28:36,819
Juan con el método imprimir

417
00:28:36,819 --> 00:28:38,680
¿vale? y luego tengo la persona

418
00:28:38,680 --> 00:28:40,519
que pone imprimir también

419
00:28:40,519 --> 00:28:41,400
¿vale?

420
00:28:42,299 --> 00:28:44,779
si aquí creo al alumno A con yo alumno

421
00:28:44,779 --> 00:28:46,740
en la persona P que es igual a

422
00:28:46,740 --> 00:28:48,180
la misma situación que antes

423
00:28:48,180 --> 00:28:51,279
ahora tanto A.imprimir como P.imprimir

424
00:28:51,279 --> 00:28:53,579
me hacen lo mismo, ¿vale?

425
00:28:53,720 --> 00:28:54,980
¿Qué será esto?

426
00:29:00,599 --> 00:29:03,440
Porque los dos harán referencia,

427
00:29:03,579 --> 00:29:05,900
pillarán el método de la instancia,

428
00:29:06,519 --> 00:29:07,720
no de la referencia.

429
00:29:08,220 --> 00:29:08,680
¿Se entiende?

430
00:29:11,099 --> 00:29:11,920
Vale, el va atrás.

431
00:29:12,940 --> 00:29:14,519
Entonces, vamos a ver qué dice más.

432
00:29:14,920 --> 00:29:17,500
¿Vale? ¿Para qué sirve reescribir un método?

433
00:29:17,660 --> 00:29:19,720
¿Vale? ¿Para ampliar la funcionalidad del método

434
00:29:19,720 --> 00:29:22,279
o para particularizar la funcionalidad de un método

435
00:29:22,279 --> 00:29:23,240
a la clase derivada?

436
00:29:23,940 --> 00:29:26,039
Tengo el mismo método, lo tenía ya hecho,

437
00:29:26,039 --> 00:29:28,400
pero quiero o ampliar

438
00:29:28,400 --> 00:29:30,099
su funcionalidad o quiero

439
00:29:30,099 --> 00:29:32,259
especializarla para la nueva

440
00:29:32,259 --> 00:29:33,319
cosa. Tengo

441
00:29:33,319 --> 00:29:36,279
saludar para alumno, para persona

442
00:29:36,279 --> 00:29:38,160
que dice hola a todos, pero ahora

443
00:29:38,160 --> 00:29:40,019
quiero un alumno y como soy un alumno

444
00:29:40,019 --> 00:29:42,039
quiero que diga oye, soy un alumno

445
00:29:42,039 --> 00:29:42,880
y te saludo.

446
00:29:43,759 --> 00:29:46,039
Lo quiero especializar para el alumno.

447
00:29:46,039 --> 00:29:48,059
Pues entonces, sobreescribo el método.

448
00:29:49,180 --> 00:29:50,480
Si definimos en la subclass

449
00:29:50,480 --> 00:29:51,839
el método con la misma asignatura,

450
00:29:51,920 --> 00:29:54,319
con la misma función, con la misma firma,

451
00:29:54,319 --> 00:30:01,319
nombre de un tipo de parámetros vale que en la superclase el de la superclase queda oculto

452
00:30:01,319 --> 00:30:07,140
entonces se oculta como antes vale como el shadowing de antes pero ahora es sobre métodos no sobre

453
00:30:07,140 --> 00:30:12,880
atributos entonces si yo desde esta clase llamo arrancar pues ejecuto el método del coche vale

454
00:30:12,880 --> 00:30:19,980
estoy en una situación parecida aquí si llamo arrancar se llama tis punto arrancar ejecuto

455
00:30:19,980 --> 00:30:29,200
el método de coche. Ahora tengo la posibilidad de llamar el método de mi padre, que es usando

456
00:30:29,200 --> 00:30:39,559
super punto arrancar. Esto sirve para esta fase aquí. Si yo quiero que haga todo lo

457
00:30:39,559 --> 00:30:45,779
que hacía mi padre, más otras cosas, pues lo que puedo hacer es llamar super punto el

458
00:30:45,779 --> 00:30:51,960
nombre del método así hace todo lo que hacía mi padre y ahora le hago hacer más cosas si yo quiero

459
00:30:51,960 --> 00:30:58,539
decir la persona dice hola a todos y el alumno dice hola a todos soy un alumno pues lo que puede

460
00:30:58,539 --> 00:31:05,220
hacer es llamar saludar super punto saludar que me dirá hola a todos y luego añadir yo como alumno

461
00:31:05,220 --> 00:31:06,279
soy un alumno.

462
00:31:07,180 --> 00:31:09,680
Ahora hacemos un ejemplo.

463
00:31:10,200 --> 00:31:11,440
No se puede usar súper, súper.

464
00:31:14,049 --> 00:31:15,490
¿Se puede usar esto aquí?

465
00:31:17,490 --> 00:31:19,029
Pregunta de un millón de dólares.

466
00:31:19,589 --> 00:31:21,950
Una cosa como esto

467
00:31:21,950 --> 00:31:22,730
se puede usar aquí.

468
00:31:38,039 --> 00:31:38,539
Vamos a ver.

469
00:31:40,640 --> 00:31:42,720
Entonces, esta situación es

470
00:31:42,720 --> 00:31:44,180
tengo dispositivo

471
00:31:44,180 --> 00:31:46,039
y móvil que hereda el dispositivo.

472
00:31:46,400 --> 00:31:47,819
Por ejemplo, tengo

473
00:31:47,819 --> 00:31:50,299
aquí estado que dice

474
00:31:50,299 --> 00:31:51,319
algo

475
00:31:51,319 --> 00:32:05,680
y tengo móvil, que dice algo distinto. Si yo ahora aquí quito todo y llamo mov.estado,

476
00:32:05,680 --> 00:32:22,769
pues esto va a llamar el de móvil. Si yo llamo disp.estado, llama el de dispositivo.

477
00:32:25,349 --> 00:32:27,109
¿Estamos de acuerdo hasta aquí?

478
00:32:30,180 --> 00:32:34,519
Ahora, ¿cómo podría yo desde aquí llamar al de mi padre?

479
00:32:36,259 --> 00:32:37,720
Opción número A.

480
00:32:38,799 --> 00:32:39,440
Borro esto.

481
00:32:43,349 --> 00:32:45,430
Entonces ya el de móvil no existe.

482
00:32:46,309 --> 00:32:52,450
Entonces cuando lo llamo sobre el móvil, me usa el del padre.

483
00:32:53,809 --> 00:32:57,890
No, pero yo lo quiero porque quiero hacer lo mismo que hace el padre y luego algo más.

484
00:32:58,529 --> 00:32:58,730
¿Vale?

485
00:32:59,190 --> 00:33:00,609
Entonces me voy al móvil.

486
00:33:00,789 --> 00:33:17,119
Lo vuelvo a poner y digo, ¿cómo podría de aquí decir algo más, pero decir antes todo lo que hace mi padre normalmente?

487
00:33:17,460 --> 00:33:21,660
O sea, quiero ejecutar el método como si fuera un dispositivo y luego algo más.

488
00:33:27,660 --> 00:33:29,160
Super, punto estado.

489
00:33:31,549 --> 00:33:39,009
Esto me está diciendo, utilízame a mí como si fuera una instancia superior.

490
00:33:39,970 --> 00:33:41,369
Y llama el método estado.

491
00:33:41,369 --> 00:33:43,809
O sea, ejecuta esto.

492
00:33:43,809 --> 00:33:49,960
Cuando lo hayas ejecutado, escribes también esta cosa.

493
00:33:49,960 --> 00:33:51,960
Vamos a ver si funciona.

494
00:33:51,960 --> 00:33:56,230
Mi padre y yo.

495
00:33:56,230 --> 00:33:59,990
¿Estás de acuerdo hasta aquí?

496
00:33:59,990 --> 00:34:03,809
¿Dudas o no?

497
00:34:05,809 --> 00:34:09,889
Repito.

498
00:34:09,889 --> 00:34:11,889
Esto es el método de dispositivo,

499
00:34:11,889 --> 00:34:16,889
que simplemente dice el número serial y se está encendido o parado.

500
00:34:16,889 --> 00:34:21,889
Esto es el método del móvil, que hereda de dispositivo.

501
00:34:21,889 --> 00:34:35,909
Entonces, con esta llamada, yo lo que le estoy diciendo es, antes haz todo lo que haría un dispositivo y después añades algo más que es lo que hace el móvil.

502
00:34:38,010 --> 00:34:48,909
Estoy extendiendo la funcionalidad. Estoy diciendo, cuando un móvil quiere hacer su estado, pues hará todo lo que hace un dispositivo cualquiera y luego hará algo específico del móvil.

503
00:34:48,909 --> 00:34:53,190
para esto uso super

504
00:34:53,190 --> 00:34:55,269
super me está diciendo

505
00:34:55,269 --> 00:34:57,289
tráptame como si fuera

506
00:34:57,289 --> 00:34:59,590
una instancia de una clase

507
00:34:59,590 --> 00:35:00,210
superior

508
00:35:00,210 --> 00:35:03,650
tráptame como si fuera una instancia

509
00:35:03,650 --> 00:35:05,170
de dispositivo

510
00:35:05,170 --> 00:35:07,170
y entonces cuando tú

511
00:35:07,170 --> 00:35:08,809
haces dispositivo punto

512
00:35:08,809 --> 00:35:11,230
estado ejecutarás esto

513
00:35:11,230 --> 00:35:13,050
¿vale? esto

514
00:35:13,050 --> 00:35:16,039
y después

515
00:35:16,039 --> 00:35:18,420
una vez que has ejecutado

516
00:35:18,420 --> 00:35:20,260
todo esto, entonces has hecho lo que haría

517
00:35:20,260 --> 00:35:22,219
un cualquier dispositivo, pues ahora

518
00:35:22,219 --> 00:35:24,099
pasas a hacer lo que haría

519
00:35:24,099 --> 00:35:25,059
un móvil en concreto.

520
00:35:29,400 --> 00:35:30,519
A ver, esto funciona.

521
00:35:31,480 --> 00:35:32,739
La pregunta es

522
00:35:32,739 --> 00:35:43,630
esto

523
00:35:43,630 --> 00:35:48,699
que, fijaos, por el

524
00:35:48,699 --> 00:35:50,139
shadowing funcionaría.

525
00:35:50,780 --> 00:35:52,099
Porque hemos dicho que se puede hacer.

526
00:35:52,099 --> 00:35:52,639
¿Dónde está?

527
00:35:53,780 --> 00:35:55,420
Aquí, ¿veis?

528
00:35:56,820 --> 00:35:57,840
Y yo el disk

529
00:35:57,840 --> 00:35:59,960
lo casteo a lo que quiero

530
00:35:59,960 --> 00:36:01,980
castear y accedo al atributo que

531
00:36:01,980 --> 00:36:09,480
quiero acceder, accedo a ese nivel. Si hago esto accedería a turismo, si hago esto accedería a

532
00:36:09,480 --> 00:36:18,539
terrestre. En el Shadowing esto funciona. La pregunta es ¿esto funcionará? No es equivalente

533
00:36:18,539 --> 00:36:30,440
a super.estado, no es lo mismo esto que esto, porque esto me está diciendo trátame como una

534
00:36:30,440 --> 00:36:33,980
instancia de la clase superior o sea de dispositivo y ahora llama estado de

535
00:36:33,980 --> 00:36:40,460
dispositivo vale y esto me está diciendo píllame a mí castéame, trátame como un

536
00:36:40,460 --> 00:36:52,920
dispositivo y llama estado. Funciona?

537
00:36:52,920 --> 00:37:00,179
Pam!

538
00:37:01,840 --> 00:37:07,880
Os suena de algo esto? O ya solo usáis inglés en el

539
00:37:07,880 --> 00:37:13,030
Hay una página web que se llama Stack Overflow.

540
00:37:16,289 --> 00:37:17,730
Bienvenidos a Stack Overflow.

541
00:37:19,250 --> 00:37:20,510
¿Qué ha pasado aquí?

542
00:37:21,710 --> 00:37:23,150
Que no está funcionando.

543
00:37:24,329 --> 00:37:29,170
Nosotros hemos dicho que el overreading no se basa sobre la referencia,

544
00:37:29,730 --> 00:37:31,409
mas se basa sobre la instancia.

545
00:37:32,289 --> 00:37:35,949
Entonces, no obstante yo le diga, oye mira, soy un dispositivo,

546
00:37:35,949 --> 00:37:38,510
la instancia que tengo dentro es un móvil.

547
00:37:39,389 --> 00:37:44,809
Entonces, cuando hago esto, estoy volviendo a llamar este método.

548
00:37:45,610 --> 00:37:48,889
Y este método, como primera cosa, lo que hace es llamarse otra vez.

549
00:37:49,250 --> 00:37:51,989
Y este método, lo que hace es llamarse otra vez.

550
00:37:52,150 --> 00:37:54,269
Y esta es la primera cosa que hace, es llamarse otra vez.

551
00:37:54,570 --> 00:37:57,530
Y se llama otra vez, y se llama otra vez, y se llama otra vez, y se llama otra vez.

552
00:37:57,969 --> 00:38:03,110
¿Lo veis? Se llama estado, llama estado, llama estado, llama estado, llama estado, llama estado, llama estado.

553
00:38:03,389 --> 00:38:04,449
Y por unas cuantas veces.

554
00:38:04,789 --> 00:38:08,659
Unas cuantas veces.

555
00:38:08,659 --> 00:38:16,719
Lo que pasa es que cada vez que tú haces una llamada de método, la pones en una cosa

556
00:38:16,719 --> 00:38:17,719
que se llama pila.

557
00:38:17,719 --> 00:38:18,719
¿Vale?

558
00:38:18,719 --> 00:38:22,719
Tú llamas un método, otro método, otro método, otro método, otro método, otro

559
00:38:22,719 --> 00:38:27,159
método, otro método, otro método, porque cuando luego acaba este método, tú vuelves

560
00:38:27,159 --> 00:38:31,659
al método que lo habías llamado, y cuando acaba este método, vuelves al método que

561
00:38:31,659 --> 00:38:32,659
lo habías llamado.

562
00:38:32,659 --> 00:38:36,860
Pero el problema es que aquí estamos llamando métodos y llamando métodos sin nunca acabar

563
00:38:36,860 --> 00:38:37,860
el método.

564
00:38:37,860 --> 00:38:52,519
Entonces esta pila crece, y crece, y crece, hasta que a un cierto momento, overflow, he hecho demasiadas llamadas de método, y entonces no lo aguanto, y es pronto.

565
00:38:54,489 --> 00:39:02,699
Es decir que esta cosa de aquí, que sí funcionaba en el otro, no puede funcionar aquí.

566
00:39:02,699 --> 00:39:05,980
esto implícitamente quiere decir

567
00:39:05,980 --> 00:39:07,400
que antes con el

568
00:39:07,400 --> 00:39:09,800
riding podía escalar

569
00:39:09,800 --> 00:39:10,880
cuanto me daba la gana

570
00:39:10,880 --> 00:39:13,219
es decir, desde aquí

571
00:39:13,219 --> 00:39:15,559
desde coche podía llegar al vehículo

572
00:39:15,559 --> 00:39:19,650
pero también podía llegar al transporte

573
00:39:19,650 --> 00:39:21,389
mientras ahora con el roller riding

574
00:39:21,389 --> 00:39:23,849
como mucho puedo llegar a mi padre

575
00:39:23,849 --> 00:39:25,730
usando el

576
00:39:25,730 --> 00:39:26,730
super punto estado

577
00:39:26,730 --> 00:39:29,130
ahora lo que puede hacer mi padre

578
00:39:29,130 --> 00:39:30,769
es llamar super punto estado

579
00:39:30,769 --> 00:39:33,369
eso sí

580
00:39:33,369 --> 00:39:49,840
Pero yo como clase solo puedo acceder a los métodos de mi padre.

581
00:39:49,840 --> 00:39:51,840
Veamos un poco.

582
00:39:51,840 --> 00:39:56,840
Aquí está descripción.

583
00:39:56,840 --> 00:40:04,840
Si yo estoy en esta clase de aquí.

584
00:40:04,840 --> 00:40:10,840
Si hago dist.decirDescripción estoy usando este método de aquí que sobreescribe esto.

585
00:40:10,840 --> 00:40:17,239
si uso super punto decir la descripción, estoy usando este método de aquí, ¿vale?

586
00:40:17,239 --> 00:40:19,639
Pero no podría llegar a algo que está por aquí.

587
00:40:20,159 --> 00:40:25,099
Esta sí puede llegar a su padre, yo puedo llegar a mi padre, pero no puedo llegar al abuelo.

588
00:40:27,679 --> 00:40:35,980
Al mandar un mensaje a un objeto, el método seleccionado depende de la clase real de la que el objeto es una instancia, ¿vale?

589
00:40:36,059 --> 00:40:38,659
No de la clase de referencia, lo que decíamos antes.

590
00:40:38,659 --> 00:40:42,880
Es decir, cuando yo llamo un método, no voy a mirar la referencia,

591
00:40:43,019 --> 00:40:44,619
mas voy a mirar la instancia real.

592
00:40:45,000 --> 00:40:50,840
Cuando yo tengo que elegir aquí, si voy a utilizar imprimir de alumno,

593
00:40:50,940 --> 00:40:55,000
imprimir de persona, no voy a mirar la referencia,

594
00:40:55,619 --> 00:40:57,820
mas voy a mirar el objeto creado.

595
00:40:58,320 --> 00:41:01,940
Y como los dos, en este caso, son referencias al mismo objeto

596
00:41:01,940 --> 00:41:06,820
y el objeto es tipo alumno, los dos llamadas llamarán el de alumno.

597
00:41:08,929 --> 00:41:09,409
¿Entienden?

598
00:41:09,409 --> 00:41:21,670
siempre el más específico, vale

599
00:41:21,670 --> 00:41:26,710
super, referencia al objeto actual como si fuera un instante

600
00:41:26,710 --> 00:41:30,550
de una superclase, vale, a diferencia de la referencia

601
00:41:30,550 --> 00:41:34,710
super, se puede acceder especialmente a métodos de la superclase

602
00:41:34,710 --> 00:41:38,309
a través, vale, para reescribir

603
00:41:38,309 --> 00:41:42,670
métodos, no solo el constructor, puede ser útil usar la referencia

604
00:41:42,670 --> 00:41:46,690
super, vale, como aquí, este es el ejemplo que hemos hecho nosotros, este ejemplo aquí

605
00:41:46,690 --> 00:42:00,190
Y yo lo que voy a hacer es llamar lo que hace mi padre, y una vez que he hecho todo lo que hace mi padre, pues sigo con las cosas específicas de mi padre.

606
00:42:05,730 --> 00:42:11,550
Entonces, super, la palabra super, la palabra de se vea super, nosotros la hemos visto para dos cosas distintas.

607
00:42:12,329 --> 00:42:17,750
Por un lado, es super con las paréntesis, o super con las paréntesis con parámetros dentro.

608
00:42:17,750 --> 00:42:23,530
Este es como un super método, se usa en los constructores, es un super constructor, ¿vale?

609
00:42:24,170 --> 00:42:30,469
Es la primera línea del constructor y lo que hace, que si no pone nada hay una implícita a esta de aquí,

610
00:42:30,650 --> 00:42:38,989
y lo que hace es usar el constructor de la super clase antes de seguir con este constructor.

611
00:42:39,750 --> 00:42:43,309
Esa es una forma de usar super, ¿vale? Es un tipo de super.

612
00:42:43,309 --> 00:42:47,650
Y luego hay un super distinto, que es super que luego tiene un punto.

613
00:42:47,750 --> 00:42:56,750
Este es super con paréntesis detrás y este es super con punto y puedo hacer super punto método o super punto atributo.

614
00:42:56,750 --> 00:43:06,750
Lo que está haciendo este aquí es trátame como si yo fuera una instancia dis pero de clase superior que accede a este método o accede a este atributo.

615
00:43:06,750 --> 00:43:14,639
¿Entonces no hay una manera de llegar al abuelo, a un método del abuelo?

616
00:43:14,639 --> 00:43:49,059
parámetros no, sí y no. Lo tengo. Imagínate que tengo móvil y luego tengo otra clase, que sea el abuelo, que sea móvil hijo, que esténs móvil, móvilo, quito móvilo.

617
00:43:49,059 --> 00:43:59,780
se enfada porque no hay el super constructor, vale, entonces yo digo public movilojo, no

618
00:43:59,780 --> 00:44:09,800
sé por qué ha salido así, con string s y no sé qué más necesitaba.

619
00:44:09,800 --> 00:44:40,650
tengo un móvil que crea fijaos que aquí yo estoy usando el super o sea que antes de crear un móvil

620
00:44:40,650 --> 00:44:48,130
ojo tendré que crear un móvil y antes de crear un móvil tendré que crear un dispositivo y antes

621
00:44:48,130 --> 00:44:57,690
de crear un dispositivo tendré que crear un object, luego creo el object, le añado a este object estas

622
00:44:57,690 --> 00:45:05,090
dos cosas, luego entonces vuelvo a este de aquí y le añado el número y luego vuelvo al móvil ojo y le

623
00:45:05,090 --> 00:45:14,489
añado lo que quieran añadirle al móvil ojo que no lo sé. Entonces nuestra pregunta era, ¿desde aquí

624
00:45:14,489 --> 00:45:28,159
¿Puedo yo acceder a esto, a estado, a este estado? Y la respuesta es no. ¿Vale? No directamente.

625
00:45:28,159 --> 00:45:40,980
Lo que yo puedo hacer es, por ejemplo, decir public void, de verdad void, estado, y hacer

626
00:45:40,980 --> 00:45:51,360
super punto estado. Entonces este super punto estado está llamando este super punto estado.

627
00:45:51,360 --> 00:45:59,340
Y como este estado a su vez está llamando el super punto estado, sí que estoy utilizando este

628
00:46:00,599 --> 00:46:10,099
desde movilogio. Pero a través de, tengo que escalar cada uno. Si en algún momento de mi

629
00:46:10,099 --> 00:46:18,519
escalada esto no hace el súper, hasta aquí hemos llegado. Pero, como lo desarrollo yo, acepto.

630
00:46:18,519 --> 00:46:28,179
O sea, que tendrías que concatenar o usar métodos para llegar a niveles más de otras superfrases.

631
00:46:28,179 --> 00:46:33,599
Podría yo hacer trampas, siempre si yo soy el desarrollador, y cuidado con lo que hacéis. Aquí,

632
00:46:33,599 --> 00:46:47,800
por ejemplo hacer un public void estado abuelo que lo que hace es super punto estado y nada más

633
00:46:47,800 --> 00:47:00,300
entonces ahora estoy dando está estoy dando la posibilidad a quien hereden de mí de utilizar

634
00:47:00,300 --> 00:47:17,420
hasta el abuelo como esto. Esto lo que está haciendo es, pasando por aquí, acceder al

635
00:47:17,420 --> 00:47:24,280
estado del dispositivo. Poder se puede hacer. No está codificado directamente también

636
00:47:24,280 --> 00:47:31,039
porque normalmente no te sirve. Tienes dispositivo móvil y otra cosa. Todo lo que tú quieres

637
00:47:31,039 --> 00:47:38,679
hacer es extender. Como tú extendes las clases, tú eres un móvil y tú eres un dispositivo,

638
00:47:38,679 --> 00:47:45,079
es difícil que tú quieras hacer completamente algo igual al dispositivo abuelo. Lo que estás

639
00:47:45,079 --> 00:47:52,000
haciendo tú es pillar lo que hacía el de arriba y hacer algo más. Entonces, tú eres

640
00:47:52,000 --> 00:47:57,980
un móvil especializado, o sea, un móvil foldable, que sí, ¿vale? Que eres un móvil.

641
00:47:57,980 --> 00:48:06,320
quieres hacer todo lo que hacía el móvil más algo tuyo entonces no tienes que ir para ti si quieres

642
00:48:06,320 --> 00:48:11,380
ir para arriba porque eres distinto de un móvil debería ser realidad del móvil debería ser el

643
00:48:11,380 --> 00:48:25,610
dispositivo mal hecho vale entonces hay estos dos súper vale que queden claro el súper con

644
00:48:25,610 --> 00:48:31,369
paréntesis el súper con punto vale son dos cosas un poquito distintas esto se usa en constructores

645
00:48:31,369 --> 00:48:33,869
para llamar a los constructores de la clase superior

646
00:48:33,869 --> 00:48:35,909
y esto de aquí en vez de se llama

647
00:48:35,909 --> 00:48:38,710
para utilizar métodos o atributos

648
00:48:38,710 --> 00:48:40,090
de la clase de la que debe.

649
00:48:41,349 --> 00:48:42,690
Y casi se acaba.

650
00:48:42,949 --> 00:48:43,210
Dos.

651
00:48:45,010 --> 00:48:47,369
También repaso de overriding y overloading.

652
00:48:48,809 --> 00:48:50,369
Overriding es lo que hemos visto aquí,

653
00:48:50,710 --> 00:48:52,190
que es la subclase sustituida

654
00:48:52,190 --> 00:48:54,849
a la implementación de un método de la superclase.

655
00:48:55,329 --> 00:48:56,829
Antes métodos tienen la misma

656
00:48:56,829 --> 00:49:00,010
signature, la misma firma.

657
00:49:00,010 --> 00:49:10,449
¿Vale? En vez de cuando se habla de overloading o sobrecarga, se está diciendo que existen dos métodos con el mismo nombre, pero distintas firmas.

658
00:49:11,150 --> 00:49:16,090
¿Vale? Y los métodos sobrecargados pueden definirse la misma clase o en clases distintas de la jerarquía.

659
00:49:17,789 --> 00:49:17,989
¿Sí?

660
00:49:19,550 --> 00:49:22,789
Última cosa, el comando instance of.

661
00:49:22,789 --> 00:49:31,730
Nosotros hemos empezado a ver ahora un problemilla, que es que por un lado están las instancias

662
00:49:31,730 --> 00:49:38,889
y por un lado están las referencias y hasta hoy nosotros si creamos un objeto gato lo

663
00:49:38,889 --> 00:49:44,369
poníamos una variable gato y si llamamos una variable persona o una instancia persona

664
00:49:44,369 --> 00:49:46,050
la metemos en una

665
00:49:46,050 --> 00:49:48,769
variable persona.

666
00:49:49,309 --> 00:49:50,030
Pero ahora

667
00:49:50,030 --> 00:49:52,389
hemos empezado a hacer estas cosas de aquí.

668
00:49:53,710 --> 00:49:54,469
O sea, de crear

669
00:49:54,469 --> 00:49:56,789
un alumno y meterlo en un alumno

670
00:49:56,789 --> 00:49:58,429
o crear un alumno y meterlo

671
00:49:58,429 --> 00:49:59,170
en una persona.

672
00:50:01,130 --> 00:50:02,789
O sea que, mientras antes

673
00:50:02,789 --> 00:50:04,329
referencia e instancias

674
00:50:04,329 --> 00:50:06,570
eran del mismo tipo para nosotros,

675
00:50:07,349 --> 00:50:08,690
ahora estamos empezando a ver

676
00:50:08,690 --> 00:50:10,570
que no tiene por qué ser así.

677
00:50:11,550 --> 00:50:12,690
Con la herencia

678
00:50:12,690 --> 00:50:14,809
herencia, como un alumno

679
00:50:14,809 --> 00:50:16,909
es una persona y un objeto

680
00:50:16,909 --> 00:50:18,530
alumno lo puedo guardar

681
00:50:18,530 --> 00:50:20,530
dentro de una referencia alumno

682
00:50:20,530 --> 00:50:22,590
entonces podrá hacer todo lo que hace un alumno

683
00:50:22,590 --> 00:50:24,809
o lo podré guardar dentro de una referencia

684
00:50:24,809 --> 00:50:26,750
persona, entonces podrá hacer todo lo que

685
00:50:26,750 --> 00:50:27,369
hace una persona

686
00:50:27,369 --> 00:50:30,909
entonces puede ser que en un determinado

687
00:50:30,909 --> 00:50:32,869
momento yo tenga una referencia

688
00:50:32,869 --> 00:50:34,909
una variable y no

689
00:50:34,909 --> 00:50:36,849
tenga ni idea de que hay

690
00:50:36,849 --> 00:50:37,489
ahí dentro

691
00:50:37,489 --> 00:50:40,869
yo tengo la persona P y no sé

692
00:50:40,869 --> 00:50:42,349
si hay dentro de la persona un alumno

693
00:50:42,349 --> 00:50:45,289
Porque los dos se pueden portar como personas

694
00:50:45,289 --> 00:50:47,630
Pero no sé si es una instancia de personas

695
00:50:47,630 --> 00:50:48,750
O si es una instancia de alumnos

696
00:50:48,750 --> 00:50:50,730
Entonces me ayuda

697
00:50:50,730 --> 00:50:52,030
Instance of

698
00:50:52,030 --> 00:50:55,630
Por ejemplo, si yo tengo la clase gato

699
00:50:55,630 --> 00:50:57,230
¿Vale? Fijaos

700
00:50:57,230 --> 00:50:59,570
Hay la clase animal, la clase gato

701
00:50:59,570 --> 00:51:01,630
Que está en animal y la clase perro que está en animal

702
00:51:01,630 --> 00:51:02,389
¿Vale?

703
00:51:03,250 --> 00:51:05,250
Si yo pregunto gato

704
00:51:05,250 --> 00:51:07,090
¿Veis que es un gato?

705
00:51:07,449 --> 00:51:08,989
Es una instancia de animal

706
00:51:08,989 --> 00:51:10,409
True

707
00:51:10,409 --> 00:51:19,670
esto devuelve true, porque gato es un animal. Si yo pregunto, ¿gato es una instancia de gato?,

708
00:51:19,670 --> 00:51:27,050
también me devuelve true, porque gato es un gato. Si gato es una instancia de perro, me dice que

709
00:51:27,050 --> 00:51:37,690
no. Pero con esto de aquí, yo puedo preguntarme si gato es una instancia de gato, entonces lo

710
00:51:37,690 --> 00:51:42,489
puedo usar como gato. Si en vez me digo gato es una instancia de gato y me dice no, no es un gato,

711
00:51:42,489 --> 00:51:44,210
pues entonces lo uso como animal.

712
00:51:45,389 --> 00:51:46,570
Si se me explica lo que es.

713
00:51:47,010 --> 00:51:50,269
Lo veremos porque esto es útil.

714
00:51:51,010 --> 00:51:52,389
Cuando veremos el polimorfismo.

715
00:51:54,050 --> 00:51:54,150
¿Sí?

716
00:51:54,550 --> 00:51:56,530
Pero acordaos que está esta cosa aquí.

717
00:51:56,690 --> 00:51:57,570
Por ejemplo,

718
00:52:02,360 --> 00:52:03,199
yo podría hacer

719
00:52:03,199 --> 00:52:05,219
dispositivo

720
00:52:05,219 --> 00:52:07,659
de

721
00:52:07,659 --> 00:52:09,280
es igual

722
00:52:09,280 --> 00:52:11,320
a mov1.

723
00:52:13,590 --> 00:52:15,210
Lo puedo hacer porque el dispositivo

724
00:52:15,210 --> 00:52:17,349
es, o sea, el móvil es un dispositivo.

725
00:52:17,349 --> 00:52:19,050
Si ahora me pregunto

726
00:52:19,050 --> 00:52:43,199
SISO de instancios dispositivo que me da TRU. Fijaos que soy un móvil, pero un móvil es un

727
00:52:43,199 --> 00:52:50,039
dispositivo. Me puedo preguntar, fijaos que esta es una instancia de dispositivo. Puedo decir eres

728
00:52:50,039 --> 00:53:01,079
un móvil soy una referencia de tipo dispositivo pero estoy apuntando a un

729
00:53:01,079 --> 00:53:10,400
objeto que es una instancia de móvil entonces ahora lo que podría hacer es si

730
00:53:10,400 --> 00:53:19,329
esta referencia que me estás diciendo que es un dispositivo

731
00:53:19,329 --> 00:53:28,130
en realidad de una instancia de un móvil pues entonces móvil m es igual a

732
00:53:28,130 --> 00:53:42,719
móvil de si tú vas tienes esta referencia que me dices que es un dispositivo y verificas que

733
00:53:42,719 --> 00:53:47,400
efectivamente es de un móvil la instancia que tiene dentro es un móvil no es un dispositivo

734
00:53:47,400 --> 00:53:58,599
entonces lo que puede hacer es hacer una referencia móvil y castigar el dispositivo a móvil

735
00:53:58,599 --> 00:54:01,760
y ahora tengo una referencia de móvil

736
00:54:01,760 --> 00:54:03,300
¿por qué quiero una referencia de móvil?

737
00:54:03,380 --> 00:54:05,179
porque si ahora vosotros hacéis de punto

738
00:54:05,179 --> 00:54:06,599
aquí

739
00:54:06,599 --> 00:54:11,960
aquí cuando hacéis de punto

740
00:54:11,960 --> 00:54:14,440
aquí aparecen sólo los métodos

741
00:54:14,440 --> 00:54:16,059
del dispositivo

742
00:54:16,059 --> 00:54:18,840
pero si yo

743
00:54:18,840 --> 00:54:21,579
ahora tengo M.

744
00:54:22,000 --> 00:54:24,480
pues aquí aparecerán también los métodos

745
00:54:24,480 --> 00:54:25,880
del móvil

746
00:54:25,880 --> 00:54:31,699
lo veremos con más calma

747
00:54:31,699 --> 00:54:33,599
por ahora que simplemente

748
00:54:33,599 --> 00:54:35,340
os quede claro que existe

749
00:54:35,340 --> 00:54:37,500
instance of. Si yo no sé

750
00:54:37,500 --> 00:54:39,480
si una referencia es una instancia de otra

751
00:54:39,480 --> 00:54:41,460
cosa, le puedo preguntar

752
00:54:41,460 --> 00:54:43,480
oye mira, es una instancia de móvil

753
00:54:43,480 --> 00:54:45,139
y si me dice true, pues

754
00:54:45,139 --> 00:54:47,480
es como si

755
00:54:47,480 --> 00:54:49,420
estuvieses cambiando el tipo

756
00:54:49,420 --> 00:54:50,500
de objeto.

757
00:54:52,340 --> 00:54:53,659
El tipo de la

758
00:54:53,659 --> 00:54:55,719
referencia. El tipo

759
00:54:55,719 --> 00:54:56,820
del objeto no varía.

760
00:54:57,599 --> 00:54:59,659
Porque cuando tú has creado el objeto

761
00:54:59,659 --> 00:55:01,260
el objeto existe.

762
00:55:01,699 --> 00:55:04,980
Este es un móvil. Su instancia es una instancia de móvil.

763
00:55:04,980 --> 00:55:11,800
Pero tú lo puedes referenciar como un dispositivo o referenciar como un móvil.

764
00:55:14,949 --> 00:55:17,130
¿Por qué? Porque el móvil es un dispositivo.

765
00:55:21,030 --> 00:55:24,090
¿Para qué me sirve esto? ¿Para que lo entendáis?

766
00:55:24,469 --> 00:55:32,630
Porque yo mañana haré un array de dispositivos y dentro pongo tanto móviles como ordenadores.

767
00:55:32,630 --> 00:55:40,150
Porque todos son dispositivos. Solo que cuando luego los pillo, estoy pillando dispositivos

768
00:55:40,150 --> 00:55:46,980
y me tengo que preguntar, ¿lo que he pillado ahora es un móvil o es un ordenador? Repito,

769
00:55:46,980 --> 00:55:53,940
me crearé una red de dispositivos y dentro le pongo móviles y ordenadores.

770
00:55:53,940 --> 00:55:59,639
¿El dispositivo solo puede tener dispositivos? Sí, pero el móvil es un dispositivo y el ordenador

771
00:55:59,639 --> 00:56:04,920
es un dispositivo. Entonces estoy poniendo dentro de una red de dispositivos tanto móviles

772
00:56:04,920 --> 00:56:10,500
como dispositivos, como ordenadores. Ahora, pero cuando luego lo recorro y pillo uno de

773
00:56:10,500 --> 00:56:15,940
estos objetos, sé que es un dispositivo, pero no sé si es un móvil o si es un ordenador.

774
00:56:16,719 --> 00:56:22,420
Y entonces usaré esto para saber si lo puedo tratar como móvil o si lo puedo tratar como

775
00:56:22,420 --> 00:56:30,179
operador. Más de esto más adelante. Vale.