1
00:00:00,000 --> 00:00:16,320
Inicia la grabación, la semana pasada después de hacer la grabación la subí a la mediateca que es desde donde las comparto y de forma inmediata no está disponible la mediateca, como que la tienen que cocinar allí de alguna forma, no sé.

2
00:00:16,320 --> 00:00:21,219
y luego ya por la noche suele estar disponible para poder utilizarla o al día siguiente

3
00:00:21,219 --> 00:00:25,620
y se me pasa dos o tres días hasta que bueno, uno de los que creo que andáis por aquí

4
00:00:25,620 --> 00:00:29,399
el que me pusisteis el mensajillo, si me vuelve a pasar pues avisarme

5
00:00:29,399 --> 00:00:33,219
que es que se me olvidó poner el enlace en la ola virtual para que la vierais

6
00:00:33,219 --> 00:00:39,750
luego deciros también que la semana que viene, bueno tanto el viernes

7
00:00:39,750 --> 00:00:43,149
no sé si tenéis alguna tutoría, como luego el lunes son días no lectivos

8
00:00:43,149 --> 00:01:01,350
Es verdad que no son festivos los dos, me parece, para los trabajos, pero sí que son no lectivos, con lo cual esos dos días no tendréis tutorías. Si tenéis alguna el viernes, no contéis con ella y, bueno, pues el lunes, este lunes que viene, no tendremos clase como todos los lunes habitualmente.

9
00:01:01,350 --> 00:01:08,579
de tal forma que creo que el siguiente tema, el tema 8

10
00:01:08,579 --> 00:01:12,200
abre el martes de la semana que viene, como lo tenemos

11
00:01:12,200 --> 00:01:16,400
estipulados así en martes, con lo cual en principio hoy es el último

12
00:01:16,400 --> 00:01:20,439
día que tenemos del tema 7 y luego una vez cerrado el tema

13
00:01:20,439 --> 00:01:24,579
sabéis que siempre solemos dedicar, si no hay ninguna petición

14
00:01:24,579 --> 00:01:28,400
particular, solemos dedicar la tutoría siguiente a resolver la tarea

15
00:01:28,400 --> 00:01:32,159
es decir, tenemos en principio para el tema 7

16
00:01:32,159 --> 00:01:43,019
Si luego es necesario echar un ratillo por ahí alguna otra tutoría con alguna cosa, pues lo buscaríamos el día de hoy para pegar un pequeño repaso de lo que vaya surgiendo por aquí del tema 7.

17
00:01:43,140 --> 00:01:51,540
Tengo por aquí un guión para iros contando algunas cosas y luego, no el lunes que viene, sino en 14 días haríamos la tarea.

18
00:01:51,840 --> 00:01:59,120
Y bueno, en base a la tarea ya sabéis que vamos siempre muy despacito, de tal forma que volvemos a repasar un poco de nuevo todos los conceptos.

19
00:01:59,120 --> 00:02:45,939
Y bueno, antes de empezar a contaros, como siempre, preguntaros si tenéis alguna cosilla, alguna aclaración que queráis que hagamos de alguna cosa de las que estáis viendo o de algún aspecto por ahí que queráis comentar. Bueno, sí, podemos, pues lo alargamos, no sé. Estás, bueno, para que quede grabado me proponen alargar un poquito más la tarea. No sé, podríamos, podría ser un par de días. ¿Pensabas en un par de días o en tres días o en cuánto tiempo estabas pensando hacer la propuesta de alargarla?

20
00:02:45,939 --> 00:03:19,539
Bueno, pues nada, si al fin y al cabo las tutorías es para que las podáis trabajar y si me comentáis que en principio os ha pillado un poco el toro, en este caso a ti, para hacerla, pues bueno, la pospongo una semana y ya está.

21
00:03:19,539 --> 00:03:30,800
vale

22
00:03:30,800 --> 00:03:35,979
vale, pues nada

23
00:03:35,979 --> 00:03:36,520
pues

24
00:03:36,520 --> 00:03:40,199
los plazos para ir abriendo temas

25
00:03:40,199 --> 00:03:42,060
los mantenemos, pero lo que es

26
00:03:42,060 --> 00:03:44,060
la posibilidad de entrega de la tarea, pues en lugar

27
00:03:44,060 --> 00:03:45,819
de cerrar el próximo

28
00:03:45,819 --> 00:03:48,000
lunes, que sería, pues lo

29
00:03:48,000 --> 00:03:49,960
dejamos para cerrar una semana después

30
00:03:49,960 --> 00:03:51,819
y ya está, vale, pues ya está

31
00:03:51,819 --> 00:03:53,639
lo hago así, luego os pongo también

32
00:03:53,639 --> 00:03:55,659
si no se me olvida, os pongo

33
00:03:55,659 --> 00:03:58,199
un mensajillo para que lo sepa todo el mundo

34
00:03:58,199 --> 00:03:59,379
que no esté

35
00:03:59,379 --> 00:04:01,879
que no vea la tutoría o que no esté

36
00:04:01,879 --> 00:04:06,020
ahora aquí o no la había luego grabada y ya está, que sepan que la alargamos una semana

37
00:04:06,020 --> 00:04:12,949
y ya está, vale, sí, sin problema. Vale, pues nada, si

38
00:04:12,949 --> 00:04:17,509
no hay más cosillas por ahí, pues os empiezo a contar un poco

39
00:04:17,509 --> 00:04:21,110
algunas cosas que tengo por aquí apuntadas de guión que

40
00:04:21,110 --> 00:04:25,350
he sacado de lo que es la teoría de este tema. En realidad

41
00:04:25,350 --> 00:04:29,470
muchas de ellas, es verdad que es un tema extenso, pero muchas de ellas

42
00:04:29,470 --> 00:04:33,509
las hemos ido hablando durante el curso, así que bueno, si ya tenemos

43
00:04:33,509 --> 00:04:36,949
un poco base de algunos conceptos, pues bienvenido sea.

44
00:04:37,649 --> 00:04:41,290
Vamos a crear un proyecto y vamos hablando

45
00:04:41,290 --> 00:04:45,689
de los diferentes conceptos teóricos que aparecen

46
00:04:45,689 --> 00:04:48,949
por ahí. Vamos a poner aquí tema 7

47
00:04:48,949 --> 00:04:59,879
para el proyecto. Este tema, en principio,

48
00:05:00,120 --> 00:05:04,040
arranca hablando de lo que son las relaciones entre diferentes

49
00:05:04,040 --> 00:05:06,019
clases que nos podemos encontrar en un proyecto.

50
00:05:06,019 --> 00:05:10,120
y bueno, a grandes rasgos, ya os digo que hemos hablado

51
00:05:10,120 --> 00:05:13,300
de las relaciones que podemos tener, tenemos dos

52
00:05:13,300 --> 00:05:16,420
una, que podemos tener

53
00:05:16,420 --> 00:05:19,500
definida una clase y ser un atributo

54
00:05:19,500 --> 00:05:22,439
de otra, vamos a ponernos en la situación

55
00:05:22,439 --> 00:05:25,160
de una persona y de la clase persona

56
00:05:25,160 --> 00:05:26,620
y de la clase brazo

57
00:05:26,620 --> 00:05:31,579
podemos entender que una persona está formada

58
00:05:31,579 --> 00:05:33,699
por cabeza, tronco y extremidades

59
00:05:33,699 --> 00:05:38,439
podríamos definir una clase tronco que tuviera sus propios

60
00:05:38,439 --> 00:05:42,480
atributos como clase en sí o los objetos que podamos definir

61
00:05:42,480 --> 00:05:46,540
de ella y sus métodos, como siempre, como toda clase

62
00:05:46,540 --> 00:05:50,339
y luego en sí, cuando definimos la clase

63
00:05:50,339 --> 00:05:53,560
persona, si está formada por cabeza, tronco y extremidades

64
00:05:53,560 --> 00:05:58,300
el tronco sería uno de los posibles atributos de la clase

65
00:05:58,300 --> 00:06:02,500
persona. Entonces esto es uno de los tipos de relación que principalmente

66
00:06:02,500 --> 00:06:06,959
existen. Y luego, el otro tipo de relación es el de herencia.

67
00:06:09,040 --> 00:06:10,660
Bueno, ahora hablamos también

68
00:06:10,660 --> 00:06:13,660
de un tercer tipo que aparece ahí en la teoría.

69
00:06:14,680 --> 00:06:18,740
Pero vamos, como dos grandes relaciones entre clases, esta, que una

70
00:06:18,740 --> 00:06:22,519
clase sea atributo de otra. Ahora hacemos un ejemplillo donde aparezca,

71
00:06:22,660 --> 00:06:26,319
aunque ya hemos trabajado con ella en algún momento. Por ejemplo, en la tarea

72
00:06:26,319 --> 00:06:30,300
esta de cocina, pues la cocina tenía como

73
00:06:30,300 --> 00:06:34,819
clase integrada en forma de atributo de la clase cocina

74
00:06:34,819 --> 00:06:37,720
tenía el frigorífico y tenía la placa, ¿no? Pues esa está la idea.

75
00:06:38,759 --> 00:06:42,920
Y luego tenemos la posibilidad de herencia, que es una de las

76
00:06:42,920 --> 00:06:46,779
características de la programación orientada a objetos, en alguna otra tutoría hemos hablado ya

77
00:06:46,779 --> 00:06:50,899
de ello, y lo que hacemos es que las clases hijas

78
00:06:50,899 --> 00:06:54,600
de la clase, hay una estructura en árbol, digamos, de clases

79
00:06:54,600 --> 00:06:58,980
cuanto más arriba estás, pues digamos que las clases

80
00:06:58,980 --> 00:07:02,860
que están por encima de las que están por debajo actúan de clases padre de las clases que están

81
00:07:02,860 --> 00:07:08,779
por abajo entonces las clases que están por abajo en esta estructura heredan características de la

82
00:07:08,779 --> 00:07:17,100
clase padre básicamente heredan sus atributos y sus métodos los que tienen disponibles y luego

83
00:07:17,100 --> 00:07:21,079
bueno pues está la otra de las características de la programación orientada a objetos que es la

84
00:07:21,079 --> 00:07:25,939
sobrescritura que podemos sobre escribir el comportamiento que tiene heredado de un método

85
00:07:25,939 --> 00:07:31,220
por ejemplo, de la clase padre, lo podemos sobrescribir en la clase hijo para que sea la que considera.

86
00:07:33,220 --> 00:07:43,759
La primera, en la que son atributos una clase de otra, en la teoría la refiere como composición

87
00:07:43,759 --> 00:07:48,660
y la mete dentro de una categoría de tipos de clase de uso de clientela.

88
00:07:49,000 --> 00:07:50,180
Es como aparece ahí en la teoría.

89
00:07:51,519 --> 00:07:56,220
Y dentro de estar del uso de clientela, también tenemos la posibilidad de anidamiento.

90
00:07:56,220 --> 00:08:12,879
Y el anidamiento es que dentro, no que tenemos un objeto o una referencia de una clase como atributo de otra, sino que la definición de la propia clase está dentro, una clase está dentro de otra en su código.

91
00:08:12,879 --> 00:08:30,300
Pues en una clase podemos tener, imaginaos la clase Persona, de la que hablábamos antes, pues tendríamos sus atributos, tendríamos sus métodos y además de sus atributos y sus métodos podríamos tener definida una clase dentro de la clase Persona.

92
00:08:30,300 --> 00:08:54,539
Pues esto es lo que es el anidamiento. Bueno, yo lo uso poco, en verdad, la idea viene relacionada, la idea de anidar unas clases con otras, que también en la teoría aparece como uso de tipo clientela, tiene que ver con cuestiones de encasulamiento, que es otra de las características que tenemos en la programación orientada a objetos.

93
00:08:54,539 --> 00:08:59,419
típicamente si nosotros tenemos un programa

94
00:08:59,419 --> 00:09:02,519
ahora llegamos a las clases

95
00:09:02,519 --> 00:09:05,919
sanidadas, pero si tenemos un programa con diferentes clases

96
00:09:05,919 --> 00:09:09,580
para acceder desde unas clases a otras, lo hacemos bien

97
00:09:09,580 --> 00:09:14,500
si la visibilidad lo permite, bien accediendo directamente

98
00:09:14,500 --> 00:09:18,440
a sus atributos o bien a través de métodos también en función de la visibilidad

99
00:09:18,440 --> 00:09:21,440
si es público, privada, PACAS, os acordáis de todo esto

100
00:09:21,440 --> 00:09:44,620
Entonces, esta forma de acceder a las características y a las acciones que puedan hacer los objetos de una determinada clase a través de sus atributos y sus métodos, llamándolos, para que una clase externa sea capaz de trabajar con ello, necesita conocer su protocolo.

101
00:09:44,620 --> 00:10:06,720
¿Cómo puedo yo comunicar con un objeto de esta clase o su protocolo o su interfaz? ¿Qué interfaz me da la clase persona de cara al resto del programa? Pues hay un método que será el método saludar, otro que será el método despedir y un atributo para la persona que sea el nombre y la edad. Pues ese es el interfaz, la cara que da un objeto de la clase persona hacia el resto del programa.

102
00:10:06,720 --> 00:10:16,500
como imaginaos que dentro de la clase persona se puede consultar el dni verdad con un getter

103
00:10:16,500 --> 00:10:23,399
del atributo dni o directamente con un método que te devuelve el número del dni que tiene esa

104
00:10:23,399 --> 00:10:29,559
persona pues resulta que en la estructura del programa en general nosotros desde cualquier

105
00:10:29,559 --> 00:10:35,980
clase podríamos poner haber instanciado un objeto de la clase persona que sea no a poner

106
00:10:35,980 --> 00:10:42,580
noa.getDNI, el getter del DNI y me daría el número o el string que tiene el DNI.

107
00:10:43,659 --> 00:10:52,039
Pero desde fuera nos despreocupamos por completo de cómo el getter de la clase persona ha obtenido ese DNI.

108
00:10:52,379 --> 00:10:58,000
Imaginaros que en un momento dado podría estar en una base de datos, no sé si habéis estudiado el módulo de base de datos

109
00:10:58,000 --> 00:11:05,259
y hacer un select a una tabla, o podría estar en un fichero o directamente desde el getter con un escáner

110
00:11:05,259 --> 00:11:18,539
se podría pedir desde teclado. La implementación del getter está encerradita dentro de la clase persona y a quien quiera utilizar el método getter de la clase

111
00:11:18,539 --> 00:11:29,019
persona le es ajeno por completo porque lo único que hace es llamar a través de un método que es el getedad de la clase persona le es ajeno si en realidad de la clase

112
00:11:29,019 --> 00:11:32,940
persona se ha obtenido ese dato accediendo a una base de datos a un

113
00:11:32,940 --> 00:11:37,019
fichero por teclado o se lo ha inventado directamente con

114
00:11:37,019 --> 00:11:41,139
un DNI aleatorio. Él solamente conoce el interfaz

115
00:11:41,139 --> 00:11:45,200
y sabe de la clase persona, desde una clase externa

116
00:11:45,200 --> 00:11:48,860
a la persona y sabe que para tener el DNI de un objeto de la clase persona

117
00:11:48,860 --> 00:11:52,759
utiliza el getter y ya está. En cambio, el desarrollo

118
00:11:52,759 --> 00:11:56,980
puede estar montado de una forma u otra. Imaginaos que este getter

119
00:11:56,980 --> 00:11:59,100
estuviera haciendo un select a una base de datos

120
00:11:59,100 --> 00:12:00,539
para devolvernos el DNI.

121
00:12:00,799 --> 00:12:03,940
Pues estupendo, la clase externa de mi programa

122
00:12:03,940 --> 00:12:07,539
utiliza el getter, pero mañana de repente

123
00:12:07,539 --> 00:12:09,960
se hace una actualización del programa

124
00:12:09,960 --> 00:12:12,600
y alguien me va a preguntar algo

125
00:12:12,600 --> 00:12:14,679
un segundo en que termino de desarrollar esto

126
00:12:14,679 --> 00:12:15,759
y te doy la palabra.

127
00:12:17,059 --> 00:12:19,759
Una persona, o sea, de repente

128
00:12:19,759 --> 00:12:23,019
a nivel de desarrollo se decide

129
00:12:23,019 --> 00:12:24,320
que se va a quitar la base de datos

130
00:12:24,320 --> 00:12:26,399
y esa información se va a volcar a un fichero.

131
00:12:26,980 --> 00:12:39,559
Simplemente tendríamos que trabajar sobre el código del método getter de la clase persona, pero el resto del programa seguiría funcionando de igual forma, porque el interfaz se mantiene y seguiríamos obteniendo esa información a través del getter.

132
00:12:39,559 --> 00:13:00,559
Esto es lo que nos permite trabajar desde fuera con interfaces y utilizar la característica de abstracción, es decir, que la información está ahí, es indiferente a nosotros cómo se tiene esa información porque nosotros trabajamos desde otras clases a través de interfaces o protocolos de acceso a las clases.

133
00:13:00,559 --> 00:13:03,279
si, alguien me quería preguntar algo por ahí

134
00:13:03,279 --> 00:13:05,960
o ha levantado la mano, no sé si por error

135
00:13:05,960 --> 00:13:15,690
un mensaje al chat, a ver, vamos a ver

136
00:13:15,690 --> 00:13:23,860
no, solo estoy contando de momento, no me he puesto a escribir

137
00:13:23,860 --> 00:13:26,700
nada de momento, no, era por si teníais duda

138
00:13:26,700 --> 00:13:29,600
si estaba escribiendo, no, simplemente os estoy contando, ahora arrancamos

139
00:13:29,600 --> 00:13:33,899
a hacerlo, entonces pues nada

140
00:13:33,899 --> 00:13:37,159
el interfaz, las tracciones son las características

141
00:13:37,159 --> 00:13:39,000
de la programación como os digo orientada a objetos

142
00:13:39,000 --> 00:13:43,080
y consiste en esto, entonces

143
00:13:43,080 --> 00:14:01,639
El anidamiento, que es una forma de relacionar diferentes clases, es meter una clase dentro de otra y típicamente cuando trabajas con anidación, pues imaginaos que estás con la clase tronco y dentro del tronco, de forma anidada, dentro de la clase tronco define la clase corazón.

144
00:14:01,639 --> 00:14:16,559
Pero no la defines como una clase fuera y tienes un atributo, sino que la defines dentro. Es un poco como bajo el concepto general de a la clase corazón no se va a acceder desde ningún sitio que no sea la clase tronco.

145
00:14:16,559 --> 00:14:43,960
Con lo cual me puedo permitir dejarla ahí muy encerradita dentro de la clase tronco porque no va a haber ningún acceso por ahí externo. Es un poco esa la idea. Entonces la anido dentro de la tronco y lo dejo ahí muy encasulado para que esté muy muy encerradito con la idea esa de hago todo el desarrollo del tronco y cuando necesite un servicio del corazón internamente ahí lo tengo encerradito el código y no está accesible desde otras partes de los programas.

146
00:14:43,960 --> 00:15:01,139
En lugar de tenerla anidada, la podríamos tener en una clase diferente, probablemente privada, o sea, probablemente que solamente fuera accesible desde el propio proyecto, desde el propio paquete y tenerla como un atributo. En ese caso se convertiría en una clase de composición.

147
00:15:01,139 --> 00:15:28,450
Entonces esto es los dos usos generales, un uso de clientela que principalmente si dejamos a un lado el anidamiento es la composición, clase cocina que tenía como atributos frigorífico, luego incluso tuvimos un array de frigoríficos, un array de placas o herencia que hemos hablado en algún momento en alguna tutoría y hoy hacemos algún ejercicio también de herencia.

148
00:15:28,970 --> 00:15:36,710
Vamos a ir desarrollando aquí algunas clases para ir apoyándonos en el código.

149
00:15:37,350 --> 00:16:09,820
Vamos a definir la clase persona, vamos a definir la clase cabeza, vamos a definir la clase alumno, vamos a definir la clase profesor, por ejemplo.

150
00:16:09,820 --> 00:16:20,580
y vamos a buscar relaciones un poco entre todas estas cosas.

151
00:16:20,580 --> 00:16:29,320
Mirad, en la clase persona, a la hora de buscar una relación con cabeza,

152
00:16:30,559 --> 00:16:36,480
pues entendemos que la cabeza es algo, es una parte de una persona.

153
00:16:36,940 --> 00:16:38,919
Una cabeza pertenece a una persona.

154
00:16:38,919 --> 00:17:00,860
En cambio, la clase alumno no es algo que pertenezca a una persona, sino que es un tipo de persona. Y profesor no es algo que pertenezca a una persona. Digamos que están un poco al mismo nivel una persona y un profesor. Un profesor no es una parte de una persona como sí que lo es una cabeza o lo es el tronco.

155
00:17:00,860 --> 00:17:05,680
entonces a la hora de buscar una relación entre persona y estas otras clases

156
00:17:05,680 --> 00:17:08,180
un poco la pregunta que nos podemos hacer es esto

157
00:17:08,180 --> 00:17:11,960
queremos que la clase cabeza esté relacionada con la clase persona

158
00:17:11,960 --> 00:17:14,680
si la consideráramos como una herencia

159
00:17:14,680 --> 00:17:17,980
tendríamos que decir, ¿la cabeza es un tipo de persona?

160
00:17:19,519 --> 00:17:22,200
si tenemos un concepto general de persona

161
00:17:22,200 --> 00:17:24,900
¿un grupo de personas sería la cabeza?

162
00:17:24,900 --> 00:17:28,500
pues no, no es un tipo de persona, es una parte de las personas

163
00:17:28,500 --> 00:17:50,460
Entonces la relación que tenemos es de clientela, según dice la teoría, esto de clientela la verdad aparece en nuestra teoría, pero yo creo que no está luego mucho por ahí en textos, pero bueno, y lo que sería, sería una relación de composición, la cabeza es un tipo de, es una parte de las personas.

164
00:17:50,460 --> 00:18:08,740
Entonces, podríamos decir que como atributo, perdón, aquí no, como atributo de la clase persona, pues resulta que tiene una cabeza. Luego también tendría ese nombre, pues esto sería un atributo, ¿verdad?

165
00:18:08,740 --> 00:18:27,599
Este va a terminar siendo un objeto referenciado de la clase cabeza. Y el string, bueno, el string ya decimos que es referenciado, pero también tiene ciertas características de los tipos primitivos, porque no lo hacemos el new, pues sería otro atributo y en este caso basado en tipo string.

166
00:18:27,599 --> 00:18:31,599
Y uno primitivo, puramente dicho, pues podría ser la edad.

167
00:18:33,059 --> 00:18:34,740
No referenciado y primitivo.

168
00:18:35,200 --> 00:18:40,559
Tiene tres atributos, la clase persona, una de ellas, ya que es una relación entre diferentes clases,

169
00:18:40,559 --> 00:18:45,460
la clase cabeza y la clase persona, es que la cabeza es una parte de la persona,

170
00:18:45,579 --> 00:18:49,599
con lo cual hacemos una relación de composición.

171
00:18:51,160 --> 00:18:58,200
En cambio, pegaría aquí poner alumno, lógicamente se lo va a tragar, ¿no?

172
00:18:58,200 --> 00:19:02,740
porque es una clase que existe, a nivel de Java se lo traga, pero a nivel de conceptual

173
00:19:02,740 --> 00:19:06,980
podríamos decir que un alumno es una característica

174
00:19:06,980 --> 00:19:10,059
de una persona, pues no, más bien es un tipo de persona

175
00:19:10,059 --> 00:19:14,539
lo que haríamos sería decir que si es un tipo de persona

176
00:19:14,539 --> 00:19:18,900
y tenemos una jerarquía, un orden de clases de arriba abajo, podríamos decir

177
00:19:18,900 --> 00:19:23,019
pues tenemos las personas que pueden ser de tipo

178
00:19:23,019 --> 00:19:27,319
alumno o de tipo profesor

179
00:19:27,319 --> 00:19:44,140
Y las personas, esto sería una relación de herencia. ¿Un alumno es un tipo de persona? Sí. ¿Un profesor es un tipo de persona? Sí. ¿Un alumno podrá hacer cosas o tendrá características típicas de las personas? Pues sí.

180
00:19:44,140 --> 00:20:03,299
Fijaros en la clase alumno, podríamos coger y decir, ¿los alumnos tienen como relación de composición una cabeza? Pues sí, podríamos coger y definir aquí que tienen una cabeza. Sería correcto como atributo de clase de la clase alumno.

181
00:20:03,299 --> 00:20:32,380
Pero lo que vamos a hacer va a ser aprovechar otra relación entre clases que es la de herencia para decir, definimos que toda persona tiene una cabeza, un alumno que es un tipo de persona la haremos hija de la clase persona y como hereda todos sus atributos directamente como herencia ya obtendrá el atributo de CAP de tipo cabeza como herencia de la clase persona.

182
00:20:33,299 --> 00:20:54,940
Un poco la estructura podría ser esta, por herencia de arriba abajo y aquí podríamos decir los atributos que tiene una persona, que sería el nombre, en este caso la edad y en principio que tiene una cabeza, también podríamos decir una clase que fuese de tipo, de otros tipos, de tronco y extremidades, como fuera para piernas y todo esto.

183
00:20:54,940 --> 00:21:19,690
En la teoría creo que habla también de un ave a la hora de explicar esto. Entonces dice, vamos a considerar la clase ave y la clase loro. Entonces podríamos decir, ¿un loro es una característica de un ave o es un tipo de ave?

184
00:21:19,690 --> 00:21:24,089
más bien un tipo de ave, pues la respuesta que nos da la relación entre

185
00:21:24,089 --> 00:21:28,309
ave y loro es que es un tipo de, pues entonces la relación

186
00:21:28,309 --> 00:21:32,329
podría ser de herencia, y luego habrá por ejemplo de la clase

187
00:21:32,329 --> 00:21:36,430
pico y alas, un pico es un tipo

188
00:21:36,430 --> 00:21:40,009
de ave o es una característica que tienen las aves

189
00:21:40,009 --> 00:21:44,549
pues si es una característica que tienen las aves, en este caso sería una relación de composición

190
00:21:44,549 --> 00:21:47,289
esta es un poco la idea

191
00:21:48,029 --> 00:22:08,609
Bien, fijaros, si tenemos la clase persona por aquí, entonces hemos utilizado una referencia, que no todavía una cabeza, porque para que exista la estructura de cabeza, sabéis que tendríamos que hacer el new, una referencia, es decir, a este logo le tendremos que hacer en algún momento un new para poder utilizar esta referencia a la cabeza.

192
00:22:08,609 --> 00:22:24,750
Y en cuanto a la relación de herencia, lo que haríamos sería para indicar que una clase es hija de otra, que en principio es la clase padre, es decir, que el alumno va a heredar cosas de la clase persona, que es la padre.

193
00:22:24,750 --> 00:22:28,210
la etiqueta que utilizamos es Stents.

194
00:22:28,730 --> 00:22:33,309
Con Stents está la forma que tenemos de identificar

195
00:22:33,309 --> 00:22:37,009
que un alumno en el código es un tipo de persona

196
00:22:37,009 --> 00:22:41,109
y alumno será una clase que en esa estructura en árbol estará justo por debajo

197
00:22:41,109 --> 00:22:45,109
de la clase persona. Y esta herencia, Stents

198
00:22:45,109 --> 00:22:49,190
de persona, ya me garantiza que tengo disponibles

199
00:22:49,190 --> 00:22:53,230
los atributos y métodos que están definidos

200
00:22:53,230 --> 00:22:54,569
en la clase persona.

201
00:22:56,609 --> 00:22:57,549
Imaginaos que tenemos aquí

202
00:22:57,549 --> 00:22:59,529
pues yo que sé

203
00:22:59,529 --> 00:23:00,509
public

204
00:23:00,509 --> 00:23:02,670
voy a saludar

205
00:23:02,670 --> 00:23:05,170
como siempre, siempre utilizamos los mismos métodos

206
00:23:05,170 --> 00:23:07,650
la verdad para poner los ejemplos

207
00:23:07,650 --> 00:23:15,779
ponemos aquí un hola

208
00:23:15,779 --> 00:23:19,000
soy una persona

209
00:23:19,000 --> 00:23:21,460
pues resulta que ahora

210
00:23:21,460 --> 00:23:23,759
la clase alumno

211
00:23:23,759 --> 00:23:25,799
por esta herencia

212
00:23:25,799 --> 00:23:27,599
que estamos identificando aquí de la clase

213
00:23:27,599 --> 00:23:28,119
persona

214
00:23:28,119 --> 00:23:33,400
tiene estos atributos

215
00:23:33,400 --> 00:23:37,480
y tiene un método disponible

216
00:23:37,480 --> 00:23:44,079
mirad, si creamos aquí otra clase

217
00:23:44,079 --> 00:23:47,359
por un momento

218
00:23:47,359 --> 00:23:51,619
vamos a poner la clase humano, por ejemplo

219
00:23:51,619 --> 00:23:58,690
podríamos decir también que un alumno

220
00:23:58,690 --> 00:23:59,670
es

221
00:23:59,670 --> 00:24:02,809
un tipo de humano, ¿verdad?

222
00:24:03,789 --> 00:24:05,309
Y que un profesor es un tipo

223
00:24:05,309 --> 00:24:07,289
de humano, viene a ser algo equivalente

224
00:24:07,289 --> 00:24:09,109
a la clase persona. Entonces

225
00:24:09,109 --> 00:24:11,410
podríamos estar tentados de coger y decir

226
00:24:11,410 --> 00:24:12,890
fijaros, la clase

227
00:24:12,890 --> 00:24:15,210
humano, pues un humano también podría

228
00:24:15,210 --> 00:24:15,910
tener un nombre.

229
00:24:19,930 --> 00:24:20,910
Y un humano

230
00:24:20,910 --> 00:24:23,190
también podría saludar. Voy a hacer copia y pega

231
00:24:23,190 --> 00:24:23,970
de este saludar.

232
00:24:34,799 --> 00:24:35,839
Fijaros que el programa

233
00:24:35,839 --> 00:24:38,819
me compila perfectamente. Bueno, pues si está en una clase humano

234
00:24:38,819 --> 00:24:41,440
podríamos darle un nombre y podremos llamar al método saludar

235
00:24:41,440 --> 00:24:44,140
de la misma forma que podemos hacerlo con la clase persona.

236
00:24:45,240 --> 00:24:47,619
La clase alumno, dentro del diseño de nuestro programa,

237
00:24:47,680 --> 00:24:50,980
hemos decidido que herede de persona. Pero podríamos decir

238
00:24:50,980 --> 00:24:54,119
oye, un alumno, las características, imaginaos

239
00:24:54,119 --> 00:24:57,140
que los alumnos, los humanos, yo que sé,

240
00:24:57,240 --> 00:24:59,180
que deciros, pues tienen un método también aquí

241
00:24:59,180 --> 00:25:01,720
que es el método respirar.

242
00:25:03,500 --> 00:25:05,019
Lo hemos implementado justo

243
00:25:05,019 --> 00:25:35,519
a ver, voy a ponerlo siguiendo el formato que tenemos con minúscula, que si no, así, pues en la clase humana resulta que también definimos el método respirar y aquí pondríamos el código correspondiente a la acción de respirar, el que estuviera definido en nuestro programa, código en Java para respirar.

244
00:25:37,299 --> 00:25:41,740
Entonces podríamos decir, oye, si un alumno también es un humano

245
00:25:41,740 --> 00:25:46,839
y me apetece tener disponible el método respirar que se ha definido en la clase humano,

246
00:25:47,440 --> 00:25:50,299
entonces podríamos tener la tentación de coger aquí y decir, pues mira,

247
00:25:50,779 --> 00:25:56,940
que herede de persona para heredar ciertas cosas y además herede de humano también para,

248
00:25:56,940 --> 00:26:03,779
y así ya tengo la posibilidad de poder llamar al método respirar que lo tengo implementado en esta clase,

249
00:26:03,779 --> 00:26:21,799
Ya que un alumno responde a esto de es un tipo de humano, pues esto no me deja, ¿verdad? Fijaros, dice que no le gusta esta coma, si quitamos la coma sigue sin gustarle y me dice por aquí que quite humano por aquí.

250
00:26:22,599 --> 00:26:36,660
¿Cuál es el motivo? Pues que en algún lenguaje de programación sí que está permitido y bueno, y vete a saber cómo lo terminan gestionando, pero Java coge el criterio de decir que una clase no puede tener herencia múltiple.

251
00:26:36,660 --> 00:27:00,380
La herencia es única y exclusivamente la que tengamos aquí definida de una clase padre solo. ¿Y cuál es el motivo que se argumenta? Pues el motivo que se argumenta es este, que una persona, la clase persona, tiene un método saludar donde sacaría un hola soy una persona y la clase humano está diciendo hola soy humano, el mismo método.

252
00:27:00,380 --> 00:27:16,480
¿Qué sucede si hacemos una herencia múltiple de varias clases? Que si yo cojo y defino un objeto de la clase alumno y llamo al método saludar, por herencia, como él no lo tiene aquí escrito, por herencia intentaría localizar ese método saludar.

253
00:27:16,480 --> 00:27:21,099
y resulta que tendría dos opciones y volveríamos a esas ambigüedades

254
00:27:21,099 --> 00:27:24,900
que estamos ya acostumbrados a ver que Java no nos las acepta

255
00:27:24,900 --> 00:27:28,680
porque diría, oye, si yo tengo un método saludar desde la clase persona

256
00:27:28,680 --> 00:27:32,799
y un método saludar desde la clase humano, con esta ambigüedad, ¿cuál de los dos

257
00:27:32,799 --> 00:27:36,779
utilizo? ¿Cómo lo resolvemos? Pues obligando

258
00:27:36,779 --> 00:27:40,920
a que la herencia sea única. Si es única, ¿qué es lo que

259
00:27:40,920 --> 00:27:44,920
pasa? Pues que ahora ya no hay ambigüedad. Si he decidido que herede la clase

260
00:27:44,920 --> 00:27:51,380
persona y llamo al método saludar, me sacará este. Y si por el contrario he decidido que herede la clase

261
00:27:51,380 --> 00:27:58,279
humano, fijaros como también me compila, también le vendría y llamo al método saludar, pues me saludará

262
00:27:58,279 --> 00:28:04,259
como este sin amigudad ninguna. Con toda seguridad al heredar de humano diría hola soy un humano.

263
00:28:06,519 --> 00:28:15,039
Bueno, esto lo enseño para argumentar que la herencia no puede ser múltiple. Leyendo la teoría,

264
00:28:15,039 --> 00:28:37,819
Bueno, pues nos dice, y también lo he comentado yo alguna vez, que hay una herencia implícita, esta, bueno, aquí la ponemos de forma explícita de quién queremos heredar a través de la etiqueta stent, pero hay una herencia implícita, es decir, que toda clase disponible en Java siempre tiene un comportamiento de herencia desde la clase object.

265
00:28:37,819 --> 00:28:44,440
que si tenemos, ya os digo, una estructura en árbol de padres, hijos, hijos, nietos, bisnietos

266
00:28:44,440 --> 00:28:47,940
y todo esto es la que está arriba del todo, la clase object en Java.

267
00:28:51,039 --> 00:28:56,160
Entonces, de esta clase object, características de esta clase heredan todas.

268
00:28:56,640 --> 00:28:58,960
Todas las clases la tienen de forma implícita.

269
00:28:59,200 --> 00:29:03,460
Es decir, eso de que solamente tenemos características heredadas desde una clase

270
00:29:03,460 --> 00:29:07,039
que identificamos con la etiqueta stents es un poquito mentira

271
00:29:07,039 --> 00:29:09,859
desde el momento en el que sí que tenemos

272
00:29:09,859 --> 00:29:13,519
la posibilidad de utilizar cosas de forma heredada

273
00:29:13,519 --> 00:29:16,079
desde la clase Object. Pero bueno, es

274
00:29:16,079 --> 00:29:18,839
la clase Object y la que pongamos nosotros aquí.

275
00:29:20,140 --> 00:29:22,119
Y no herencias a través de

276
00:29:22,119 --> 00:29:24,319
más clases, pues, porque no

277
00:29:24,319 --> 00:29:28,119
para que no se produzca esa situación que

278
00:29:28,119 --> 00:29:30,740
hemos visto antes con el método saludar.

279
00:29:33,319 --> 00:29:35,220
Y vamos a crear otra clase aquí que sea principal.

280
00:29:35,220 --> 00:29:44,319
y en esta clase vamos a decir que meta el main

281
00:29:44,319 --> 00:29:45,940
que yo creo que lo podemos identificar por aquí

282
00:29:45,940 --> 00:29:47,960
aquí en Eclipse

283
00:29:47,960 --> 00:29:51,160
aquí tenemos el main

284
00:29:51,160 --> 00:29:53,460
de nuestro programa

285
00:29:53,460 --> 00:29:56,480
entonces aquí podríamos coger y definir

286
00:29:56,480 --> 00:29:59,839
un objeto de la clase alumno

287
00:29:59,839 --> 00:30:05,910
mi alumno igual a new

288
00:30:05,910 --> 00:30:07,230
alumno

289
00:30:07,230 --> 00:30:11,950
como siempre el new para hacer la reserva del espacio de memoria

290
00:30:11,950 --> 00:30:16,730
y llamamos a un constructor, como no hemos escrito

291
00:30:16,730 --> 00:30:20,490
ninguno en la clase alumno, pues tiene uno por defecto

292
00:30:20,490 --> 00:30:24,650
que es este, en cuanto escribamos uno el de por defecto desaparece y ya tenemos

293
00:30:24,650 --> 00:30:27,170
que utilizar alguno de los definidos dentro de la clase

294
00:30:27,170 --> 00:30:32,109
fijaros que la clase alumno la tenemos completamente vacía

295
00:30:32,109 --> 00:30:36,329
aquí en cuanto a código, pero decimos que estamos heredando

296
00:30:36,329 --> 00:30:39,950
vamos a poner de humano, vamos a poner de persona

297
00:30:39,950 --> 00:30:46,490
humano lo había puesto, lo había creado para que vierais que no me dejaba

298
00:30:46,490 --> 00:30:48,549
compilar con herencia múltiple

299
00:30:48,549 --> 00:30:54,450
entonces como hereda de persona, aunque aquí no tengo nada definido, tiene heredado

300
00:30:54,450 --> 00:30:58,430
todos los atributos y los métodos que tenga

301
00:30:58,430 --> 00:31:04,009
la clase persona, entonces si yo pongo mi al punto aquí

302
00:31:04,009 --> 00:31:07,609
punto, fijaros como me ofrece los atributos

303
00:31:07,609 --> 00:31:12,549
que tiene la clase Persona. Fijaros, todos estos, Equals, GetClass,

304
00:31:12,690 --> 00:31:17,869
HasCode, Notify, NotifyAll, Saludar, no, ToString, todos estos métodos,

305
00:31:17,990 --> 00:31:22,170
¿por qué me los estará ofreciendo Eclipse para el objeto de la clase

306
00:31:22,170 --> 00:31:26,450
alumno si no los tengo definidos aquí? Pues los estará recibiendo

307
00:31:26,450 --> 00:31:29,230
a través de alguna herencia. En la herencia que tenemos aquí

308
00:31:29,230 --> 00:31:32,789
identificada de la clase Persona, ¿tenemos definidos todos esos

309
00:31:32,789 --> 00:31:35,730
métodos? No, solamente el método Saludar. ¿De dónde nos estarán

310
00:31:35,730 --> 00:31:42,390
viniendo al resto de métodos de la clase object entonces cualquier objeto que pongáis tendrá estos

311
00:31:42,390 --> 00:31:48,509
métodos ecuas get class has code notify notify all to stream por ejemplo to stream hemos hablado en

312
00:31:48,509 --> 00:31:56,289
algún momento de que es convertir el ahora después trabajamos con él incluso convertir el objeto a

313
00:31:56,289 --> 00:32:01,349
una cadena caracteres para que salga cuando llames al método y además este método es el que se llama

314
00:32:01,349 --> 00:32:04,769
con el println de forma escondida.

315
00:32:05,950 --> 00:32:09,670
Estos tienen que ver con gestión de hilos que estudiaréis

316
00:32:09,670 --> 00:32:13,289
en la asignatura de programación de servicios y procesos el año que viene

317
00:32:13,289 --> 00:32:17,089
probablemente. Todos estos otros métodos los tiene heredados

318
00:32:17,089 --> 00:32:21,430
desde la clase object. En cualquier caso vamos a utilizar

319
00:32:21,430 --> 00:32:25,650
el que tenemos identificado en la clase persona ahora inicialmente.

320
00:32:26,470 --> 00:32:28,009
Entonces si ejecutamos

321
00:32:28,009 --> 00:32:34,920
me dice hola soy una persona, ha utilizado el método

322
00:32:34,920 --> 00:32:37,880
que él no tiene definido, pero en cambio

323
00:32:37,880 --> 00:32:42,900
por herencia lo tiene disponible de la clase persona y precisamente

324
00:32:42,900 --> 00:32:49,240
este código es el que nos ha mostrado aquí. Una de las características que

325
00:32:49,240 --> 00:32:53,779
si cogemos y decimos que la clase profesor

326
00:32:53,779 --> 00:32:57,579
también no es una

327
00:32:57,579 --> 00:33:01,519
característica de una persona, un profesor, sino que es un tipo de

328
00:33:01,519 --> 00:33:20,640
Y como es un tipo de persona, lo consideramos a través de la relación entre clases de herencia, pues la misma jugada de un profesor. Entonces, si cogemos aquí en el principal y ahora en lugar de definir un alumno, definimos un profesor.

329
00:33:20,640 --> 00:33:34,430
tenemos el saludar también de forma heredada

330
00:33:34,430 --> 00:33:39,660
y los dos efectivamente

331
00:33:39,660 --> 00:33:43,400
llaman al mismo método, ninguno de los dos tiene definido el método saludar

332
00:33:43,400 --> 00:33:47,220
los dos lo tienen disponible a través de herencia de la clase persona

333
00:33:47,220 --> 00:33:51,140
con lo cual el código que ejecutan ambos dos para saludar es este

334
00:33:51,140 --> 00:33:55,519
y nos sacan por pantalla hola soy una persona y aquí tenemos en la consola

335
00:33:55,519 --> 00:33:59,339
como resultado dos veces el mensaje, una vez cuando ha saludado al alumno

336
00:33:59,339 --> 00:34:01,819
y una segunda vez cuando ha saludado al profesor.

337
00:34:03,339 --> 00:34:05,819
Bueno, pues está estupendo tener ese método, pero

338
00:34:05,819 --> 00:34:10,920
resulta que puede ser que, digamos, mira, este

339
00:34:10,920 --> 00:34:15,659
método me parece suficiente cuando saluda a un profesor,

340
00:34:15,659 --> 00:34:19,719
pero me parece un poquito serio cuando saluda

341
00:34:19,719 --> 00:34:23,440
a un alumno, que tiene a lo mejor un lenguaje un poquito más informal.

342
00:34:24,280 --> 00:34:43,199
Pues, ¿qué podemos hacer en ese caso? Pues, podríamos coger, quitar la herencia directamente e implementar aquí el método saludar, pero si quitamos la herencia, perdemos este método porque lo queremos tener propio, pero también perderíamos estas características que pueden seguir interesándome en la clase alumno.

343
00:34:43,199 --> 00:34:46,059
entonces podemos decir, oye mira, voy a mantenerme

344
00:34:46,059 --> 00:34:51,119
efectivamente como una persona, voy a mantener la herencia de persona

345
00:34:51,119 --> 00:34:54,960
porque me interesa de la clase persona estos atributos y otros

346
00:34:54,960 --> 00:34:58,960
métodos más que pudiera tener por aquí, pero en cambio la forma de saludar

347
00:34:58,960 --> 00:35:02,940
ya os digo que me parece un poquito seria para un alumno, pues

348
00:35:02,940 --> 00:35:08,380
lo que puedo hacer es sobrescribir el método

349
00:35:08,380 --> 00:35:13,909
saludar, cuando sobrescribimos el método saludar podemos poner

350
00:35:13,909 --> 00:35:16,409
aquí una etiqueta, a ver si me acuerdo

351
00:35:16,409 --> 00:35:17,829
como era, overwrite creo que es

352
00:35:17,829 --> 00:35:25,130
si ponemos aquí una etiqueta overwrite

353
00:35:25,130 --> 00:35:26,849
es decir, sobre escribiendo

354
00:35:26,849 --> 00:35:29,550
o sobre escrito, y ponemos aquí un método

355
00:35:29,550 --> 00:35:31,489
lo que estamos haciendo, si no aparece

356
00:35:31,489 --> 00:35:33,409
el comportamiento en java es

357
00:35:33,409 --> 00:35:35,150
el mismo, también nos funciona

358
00:35:35,150 --> 00:35:37,269
ahora os cuento para que nos puede

359
00:35:37,269 --> 00:35:39,489
en que nos puede ayudar poner esta etiqueta

360
00:35:39,489 --> 00:35:41,550
en el código, entonces si yo

361
00:35:41,550 --> 00:35:43,389
cojo ahora aquí dentro de la clase alumno y

362
00:35:43,389 --> 00:35:44,130
sobre escribo

363
00:35:44,130 --> 00:35:54,360
ponemos aquí hola qué tal así para que sea un poquito más informal como saluda el alumno yo

364
00:35:54,360 --> 00:36:00,820
me vengo ahora ejecuto aquí y fijaros que como tengo sobre escrito en la propia clase el método

365
00:36:00,820 --> 00:36:06,679
saludar en el momento que lo llamo antes de irse a buscar el método saludar que tiene disponible

366
00:36:06,679 --> 00:36:12,460
por herencia desde la clase persona localiza a ver si tiene él un método saludar propio y si lo

367
00:36:12,460 --> 00:36:16,420
tiene es el que utiliza. Entonces coge y llama al

368
00:36:16,420 --> 00:36:20,099
método saludar propio y en cambio el profesor

369
00:36:20,099 --> 00:36:24,320
que no ha implementado un método saludar, el único que tiene disponible es el de

370
00:36:24,320 --> 00:36:28,300
por herencia desde la clase persona y por eso se mantiene aquí el mensaje

371
00:36:28,300 --> 00:36:31,480
que nos mostraba el saludar de esta clase.

372
00:36:32,239 --> 00:36:36,239
En cambio, el alumno muestra este otro. Esta es otra

373
00:36:36,239 --> 00:36:39,619
de las características que tenemos en la programación orientada a objetos que es

374
00:36:39,619 --> 00:36:41,239
la sobrescritura.

375
00:36:52,579 --> 00:36:54,380
Si dentro de la clase persona,

376
00:36:54,820 --> 00:36:56,719
imaginaos que, bueno, aquí simplemente es un mensaje

377
00:36:56,719 --> 00:36:59,039
y estamos intentando que sustituya uno a otro,

378
00:36:59,699 --> 00:37:00,539
pero imaginaos que,

379
00:37:01,920 --> 00:37:06,739
bueno, imaginaos que, oye, pues

380
00:37:06,739 --> 00:37:08,780
no es esto justo lo que quiero hacer, sino que

381
00:37:08,780 --> 00:37:11,019
quiero utilizar el método saludar

382
00:37:11,019 --> 00:37:12,780
de la clase persona, lo que tengan como

383
00:37:12,780 --> 00:37:14,639
tal y como saluden las personas, pero además

384
00:37:14,639 --> 00:37:18,639
de eso, quiero yo hacer más cosas aquí. Entonces, lo que

385
00:37:18,639 --> 00:37:22,400
podemos hacer es sobreescribir el método y para que siga saludando como

386
00:37:22,400 --> 00:37:25,880
la clase persona, podemos utilizar la etiqueta super.

387
00:37:27,039 --> 00:37:30,519
Con la etiqueta super, lo que estamos diciendo es, llama al método

388
00:37:30,519 --> 00:37:34,179
saludar, pero al método saludar de la clase padre.

389
00:37:34,880 --> 00:37:38,500
Entonces, esto lo que ejecuta es el método saludar que tiene la clase padre

390
00:37:38,500 --> 00:37:42,559
y luego como alumno, bueno, pues puedo hacer algunas cosas más.

391
00:37:42,559 --> 00:37:46,179
lo que quisiera yo aquí con código Java.

392
00:37:47,519 --> 00:37:50,340
Mejor escribir en una base de datos

393
00:37:50,340 --> 00:37:54,480
cuando los alumnos saludan, aparte de mostrar el mensaje

394
00:37:54,480 --> 00:37:58,519
hola, soy una persona, quiero que escriba en una base de datos

395
00:37:58,519 --> 00:38:02,179
que ha saludado una persona o en un fichero o que

396
00:38:02,179 --> 00:38:06,440
saque a través de un luminoso, lo que sea. Bueno, todo lo que podamos

397
00:38:06,440 --> 00:38:10,639
programar aquí con Java lo podríamos poner. Para eso tenemos a nuestra disposición

398
00:38:10,639 --> 00:38:13,019
en un método que estamos llamando en algún momento.

399
00:38:14,519 --> 00:38:17,320
Aquí, bueno, para argumentarlo vamos a poner aquí otro mensaje

400
00:38:17,320 --> 00:38:21,570
que sea, soy un alumno.

401
00:38:24,750 --> 00:38:33,360
Entonces, si hacemos esta ejecución, fijaros cómo la ejecución

402
00:38:33,360 --> 00:38:36,579
del saludar del alumno, como está sobrescrito, me llama

403
00:38:36,579 --> 00:38:39,780
al saludar propio del alumno y el saludar propio del alumno

404
00:38:39,780 --> 00:38:43,019
lo primero que hace a través de la etiqueta super que viene

405
00:38:43,019 --> 00:38:47,079
a ser padre, llama al método saludar, me muestra lo que

406
00:38:47,079 --> 00:38:50,960
hace el método saludar del padre y luego continúa ejecutando, dice

407
00:38:50,960 --> 00:38:55,340
soy un alumno, por aquí, se acaba el saludar del alumno

408
00:38:55,340 --> 00:38:59,019
y luego como saluda el profesor, ¿verdad? El profesor

409
00:38:59,019 --> 00:39:02,860
que no tiene sobrescrito el método, pues el único

410
00:39:02,860 --> 00:39:07,199
que utiliza es el que tiene disponible por herencia y me saca

411
00:39:07,199 --> 00:39:10,920
el hola soy una persona. Bueno, pues para ver

412
00:39:10,920 --> 00:39:12,139
la etiqueta super

413
00:39:12,139 --> 00:39:17,599
el método este overwrite

414
00:39:17,599 --> 00:39:18,260
fijaros

415
00:39:18,260 --> 00:39:25,630
la etiqueta

416
00:39:25,630 --> 00:39:27,630
el método no, la etiqueta esta overwrite

417
00:39:27,630 --> 00:39:29,550
que ya os digo que no es imprescindible

418
00:39:29,550 --> 00:39:31,349
imaginaos que yo pongo aquí public

419
00:39:31,349 --> 00:39:33,329
estoy programando la clase alumno y digo

420
00:39:33,329 --> 00:39:35,690
voy a sobreescribir un método

421
00:39:35,690 --> 00:39:35,969
de la

422
00:39:35,969 --> 00:39:39,429
en la clase alumno un método

423
00:39:39,429 --> 00:39:41,329
de los que tenga heredados, en este caso

424
00:39:41,329 --> 00:39:42,869
heredados de la clase persona

425
00:39:42,869 --> 00:39:45,190
entonces si yo pongo aquí

426
00:39:45,190 --> 00:39:48,389
saludor, en lugar de saludar, ¿vale?

427
00:39:52,150 --> 00:39:56,210
¿Veis que se me queja? ¿Por qué? Porque le he dicho que este método

428
00:39:56,210 --> 00:39:59,750
es un método que estoy sobreescribiendo de la clase padre y dice

429
00:39:59,750 --> 00:40:04,269
la clase padre no tiene ningún método que sea saludor. Si quitamos este overwrite

430
00:40:04,269 --> 00:40:11,699
no me compila por más cosas, vamos a poner aquí un public void

431
00:40:11,699 --> 00:40:18,500
Si quitamos aquí este overwrite, fijaros que

432
00:40:18,500 --> 00:40:22,400
ahora sí me compila. ¿Por qué me compila? Pues porque lo considera saludor

433
00:40:22,400 --> 00:40:26,500
como un método de la clase alumno, no un método que está sobrescribiendo

434
00:40:26,500 --> 00:40:30,960
de ningún sitio. Pero si pongo yo aquí el override, ya no me compila.

435
00:40:31,079 --> 00:40:34,599
¿Por qué? Porque dice, está diciendo que lo siguiente que vas a identificar

436
00:40:34,599 --> 00:40:38,619
es un método que vas a sobrescribir de la clase padre y la clase padre

437
00:40:38,619 --> 00:40:41,739
no tiene ningún método saludor. No me gusta lo que estás haciendo.

438
00:40:42,539 --> 00:40:46,840
Entonces, esta etiqueta, sin tener ninguna consecuencia

439
00:40:46,840 --> 00:40:51,019
durante la ejecución en el programa, nos garantiza que si ponemos

440
00:40:51,019 --> 00:40:55,760
el arroba overwrite, lo siguiente que estaremos poniendo es

441
00:40:55,760 --> 00:40:59,639
un método que de verdad tiene heredado desde la clase padre y

442
00:40:59,639 --> 00:41:03,679
nos evita un posible error como el que estoy cometiendo yo aquí

443
00:41:03,679 --> 00:41:07,820
al poner saludor en lugar de saludar. Ya pongo saludar y ya me compila de nuevo.

444
00:41:07,820 --> 00:41:11,719
¿Por qué? Porque saludar sí está disponible en el padre y en verdad lo estoy

445
00:41:11,719 --> 00:41:16,019
sobreescribiendo. En relación a esta etiqueta

446
00:41:16,019 --> 00:41:18,940
que os había puesto aquí, del overwrite.

447
00:41:18,940 --> 00:41:28,639
más cosas que os puedo contar de esto

448
00:41:28,639 --> 00:41:30,599
el super, el override

449
00:41:30,599 --> 00:41:34,900
irme parando, si tenéis dudas o algo me vais diciendo

450
00:41:34,900 --> 00:41:37,059
si alguna cosa no queda clara

451
00:41:37,059 --> 00:41:41,900
las relaciones de composición y la relación de herencia

452
00:41:41,900 --> 00:41:45,300
la herencia solamente puede ser desde una clase

453
00:41:45,300 --> 00:41:48,400
aunque tenemos disponible herencia

454
00:41:48,400 --> 00:41:52,010
desde la clase object

455
00:41:52,010 --> 00:41:55,409
fijaros, aquí estamos utilizando

456
00:41:55,409 --> 00:42:00,449
el método saludar, heredado por la clase, tanto profesor

457
00:42:00,449 --> 00:42:04,130
alumno, desde la clase persona, podríamos poner

458
00:42:04,130 --> 00:42:06,289
mi punto

459
00:42:06,289 --> 00:42:11,849
a ver, mirad, string s

460
00:42:11,849 --> 00:42:14,750
aus, ponemos aquí una variable auxiliar

461
00:42:14,750 --> 00:42:19,909
ponemos aquí mi prof.toString

462
00:42:19,909 --> 00:42:24,449
y ahora vamos a poner aquí un system.out.println

463
00:42:24,449 --> 00:42:27,610
Println de SAUS.

464
00:42:33,780 --> 00:42:34,880
Println, ahí está.

465
00:42:35,920 --> 00:42:40,760
Fijaros, el método toString no está definido ni en el profesor,

466
00:42:41,920 --> 00:42:46,000
ni en la clase que tiene identificada como herencia,

467
00:42:46,119 --> 00:42:47,039
ni en la clase persona.

468
00:42:47,500 --> 00:42:48,980
Pero en cambio, me compila.

469
00:42:48,980 --> 00:42:49,840
¿Por qué me compila?

470
00:42:50,159 --> 00:42:54,380
Pues bueno, porque toString lo tenemos disponible desde la clase

471
00:42:54,380 --> 00:42:54,719
object.

472
00:42:54,840 --> 00:42:55,840
A ver si no lo chiva por aquí.

473
00:42:55,840 --> 00:43:03,719
Fijaros, aquí en esta primera parte nos dice que lo tiene disponible desde java.lang.object.toString, efectivamente, de la clase object.

474
00:43:05,179 --> 00:43:10,360
Y dice, aquí devuelve un string que representa el objeto.

475
00:43:12,829 --> 00:43:16,570
Este string lo hemos cargado en esta variable y lo vamos a mostrar aquí por pantalla.

476
00:43:16,989 --> 00:43:20,289
Mirad, si le damos aquí a ejecutar, mirad lo que nos muestra.

477
00:43:20,289 --> 00:43:22,409
nos muestra

478
00:43:22,409 --> 00:43:27,309
que pertenece a un objeto de la clase profesor

479
00:43:27,309 --> 00:43:30,110
y un código que probablemente tenga que ver

480
00:43:30,110 --> 00:43:33,110
muy probablemente es un código identificativo

481
00:43:33,110 --> 00:43:35,769
de este objeto y probablemente yo siempre digo

482
00:43:35,769 --> 00:43:38,869
aunque no tengo una certeza al 100% que a lo mejor hasta tiene que ver

483
00:43:38,869 --> 00:43:41,289
con la relación en memoria RAM de donde está

484
00:43:41,289 --> 00:43:44,769
almacenada la información del objeto

485
00:43:44,769 --> 00:43:46,590
gracias a que le hemos hecho un new por aquí

486
00:43:46,590 --> 00:43:49,469
¿por qué nos muestra esto?

487
00:43:50,289 --> 00:43:53,869
tan poco identificativo de lo que es un profesor.

488
00:43:55,130 --> 00:43:57,730
Pues fijaos, nos muestra esto porque el método toString

489
00:43:57,730 --> 00:44:00,829
lo está heredando desde la clase Object.

490
00:44:01,710 --> 00:44:05,349
Entonces, y hemos dicho que cualquier clase que tengamos

491
00:44:05,349 --> 00:44:08,309
en nuestro programa tiene disponible este método,

492
00:44:08,409 --> 00:44:09,469
el método toString.

493
00:44:10,250 --> 00:44:14,230
Entonces, pensad que el código que hayan implementado

494
00:44:14,230 --> 00:44:17,090
en las librerías de Java para la clase Object,

495
00:44:18,090 --> 00:44:19,969
en particular para el método toString,

496
00:44:20,289 --> 00:44:26,909
Tiene que valer para cualquier tipo de objeto que se le ocurra hacer a cualquiera en Java.

497
00:44:27,289 --> 00:44:32,110
¿Por qué? Porque cualquier tipo de objeto que se le ocurra a cualquiera en cualquier contexto en Java

498
00:44:32,110 --> 00:44:35,690
tendrá heredado el método toString desde la clase Object.

499
00:44:36,829 --> 00:44:44,070
En verdad, si buscamos algo que nos identifique a una persona con el toString o a un alumno,

500
00:44:44,530 --> 00:44:49,329
a un profesor en este caso, pues estaríamos pensando más en alguna información de sus atributos.

501
00:44:49,329 --> 00:45:15,550
En este caso no tiene ninguno profesor y por herencia tiene estos. Por ejemplo, el nombre. Pues diríamos, oye, que el toString nos devuelva mejor el nombre, ¿no? Y no esto. Porque esto, ¿qué me dice de un profesor en particular? Pues nada. O que me devuelva su edad, o que me devuelva el nombre diciéndome, tiene un nombre tal y su edad es no sé cuál, ¿vale? Pues eso sería algo más razonable para identificar un objeto de una persona que no esté dato.

502
00:45:15,550 --> 00:45:19,210
pero si estamos utilizando

503
00:45:19,210 --> 00:45:21,309
el toString heredado desde Object

504
00:45:21,309 --> 00:45:23,369
no podríamos ir al código

505
00:45:23,369 --> 00:45:25,150
de Object en las librerías

506
00:45:25,150 --> 00:45:27,090
y decir devuélveme un nombre y una edad

507
00:45:27,090 --> 00:45:29,349
porque en otro programa que también

508
00:45:29,349 --> 00:45:31,409
tendrá un string heredado de ese mismo código

509
00:45:31,409 --> 00:45:33,369
Object, pues igual estamos hablando

510
00:45:33,369 --> 00:45:35,110
de algo que no tiene edad

511
00:45:35,110 --> 00:45:37,309
o que no tiene nombre, yo que sé

512
00:45:37,309 --> 00:45:39,070
de colores, es una clase colores

513
00:45:39,070 --> 00:45:41,090
con los diferentes matices

514
00:45:41,090 --> 00:45:42,590
o en esa decimal

515
00:45:42,590 --> 00:45:45,690
justo si tendría

516
00:45:45,690 --> 00:45:47,369
a lo mejor los colores un nombre

517
00:45:47,369 --> 00:45:48,969
pero no tendría una edad

518
00:45:48,969 --> 00:45:50,929
entonces si decidimos en la clase

519
00:45:50,929 --> 00:45:52,969
object para que cuando herede

520
00:45:52,969 --> 00:45:55,230
mi clase persona poner en el código

521
00:45:55,230 --> 00:45:57,190
algo relacionado con la edad

522
00:45:57,190 --> 00:45:59,250
de esa persona, ya no me valdría

523
00:45:59,250 --> 00:46:01,090
ese toString para cuando lo esté

524
00:46:01,090 --> 00:46:02,849
utilizando un objeto de la clase

525
00:46:02,849 --> 00:46:05,090
colores que también hereda de la clase

526
00:46:05,090 --> 00:46:07,349
object, entonces han tenido que buscar

527
00:46:07,349 --> 00:46:08,929
en el toString

528
00:46:08,929 --> 00:46:11,030
definido en la clase object algo que

529
00:46:11,030 --> 00:46:13,449
me valga para cualquier clase en el mundo mundial.

530
00:46:13,630 --> 00:46:16,230
Entonces, todas las clases con toda seguridad tendrán un nombre

531
00:46:16,230 --> 00:46:17,909
y un identificador.

532
00:46:19,230 --> 00:46:22,329
Para particularizar en mi programa este toString,

533
00:46:22,409 --> 00:46:23,250
¿qué es lo que puedo hacer?

534
00:46:23,750 --> 00:46:26,989
¿Qué es lo que he hecho para particularizar el método saludar

535
00:46:26,989 --> 00:46:31,429
en la clase alumno respecto a lo que tenía el método saludar

536
00:46:31,429 --> 00:46:32,349
de la clase persona?

537
00:46:32,710 --> 00:46:34,130
Pues le he hecho una sobrescritura.

538
00:46:34,130 --> 00:46:36,909
Entonces, yo podría coger aquí y decir overwrite.

539
00:46:37,550 --> 00:46:38,710
Esto es opcional solo.

540
00:46:38,710 --> 00:46:42,469
public string

541
00:46:42,469 --> 00:46:44,230
to string

542
00:46:44,230 --> 00:46:56,530
a ver de que se me queda

543
00:46:56,530 --> 00:46:58,789
bueno, me está diciendo que devuelva

544
00:46:58,789 --> 00:47:00,530
y por ejemplo puedo poner aquí un return

545
00:47:00,530 --> 00:47:02,150
hola

546
00:47:02,150 --> 00:47:06,530
que es lo que estoy haciendo

547
00:47:06,530 --> 00:47:09,489
un alumno, perdón lo he puesto

548
00:47:09,489 --> 00:47:11,409
en la clase alumno y en el otro sitio

549
00:47:11,409 --> 00:47:13,570
lo hemos utilizado

550
00:47:13,570 --> 00:47:15,610
con la de profesor, no venimos aquí a la profesor

551
00:47:15,610 --> 00:47:17,130
la misma jugada

552
00:47:17,130 --> 00:47:33,190
Un profesor, sabíamos que tenía este método disponible y antes de sobrescribirlo, lo tenía disponible heredado desde Object. Ahora, ¿qué he hecho con el profesor? Pues lo he sobrescrito y este toString que hace devuelve hola.

553
00:47:33,190 --> 00:47:40,989
ejecuto por aquí, fijaros como ya en lugar de salirme ese código

554
00:47:40,989 --> 00:47:44,909
ya utiliza en primer lugar la forma

555
00:47:44,909 --> 00:47:49,210
en la que hemos puesto el toString para la clase

556
00:47:49,210 --> 00:47:52,909
profesor, a ver vamos a poner aquí, no sé si

557
00:47:52,909 --> 00:47:56,949
super para los, si mirad, si ponemos aquí un super de toString

558
00:47:56,949 --> 00:48:00,769
pues se irá a buscar el del padre que en principio sería el de la clase

559
00:48:00,769 --> 00:48:09,599
object, el toString de esta clase lo que estará

560
00:48:09,599 --> 00:48:12,539
haciendo será devolver un string. Vamos a mostrarlo por pantalla.

561
00:48:25,690 --> 00:48:28,809
En este caso la ejecución ahora la repasamos otra vez si es necesario.

562
00:48:30,369 --> 00:48:33,889
Fijaros que ahora ya lo que hace es mostrarnos lo de la clase

563
00:48:33,889 --> 00:48:37,469
object. Aquí en la clase profesor

564
00:48:37,469 --> 00:48:41,030
el método toString lo que hemos dicho ha sido, oye, devuélveme

565
00:48:41,030 --> 00:48:45,369
lo que devuelve el toString de la clase

566
00:48:45,369 --> 00:48:48,449
Padre, que lo tiene heredado desde la clase Object.

567
00:48:49,230 --> 00:48:52,929
Como devuelve un string, el toString, hemos dicho que lo muestre por pantalla.

568
00:48:54,130 --> 00:48:56,869
Y luego lo que hemos hecho ha sido hacer un return de hola.

569
00:48:58,570 --> 00:49:00,849
Este system out me ha mostrado esto

570
00:49:00,849 --> 00:49:04,750
y este return de hola lo ha cargado

571
00:49:04,750 --> 00:49:08,829
en esta variable souse y este otro system out es el que me lo ha escrito por pantalla.

572
00:49:09,309 --> 00:49:15,079
Es decir, hemos cogido el control de lo que devuelve el

573
00:49:15,079 --> 00:49:18,940
toString y lo hemos particularizado para lo que queremos que pase

574
00:49:18,940 --> 00:49:23,300
cuando se llame al método toString de la clase Persona. ¿Cómo? Sobrescribiendo

575
00:49:23,300 --> 00:49:27,219
el que tiene heredado, que en este caso era una herencia de la clase

576
00:49:27,219 --> 00:49:31,320
Persona en la clase Profesor, sino lo tenía heredado desde la clase

577
00:49:31,320 --> 00:49:37,449
Object. Vale, pues ya, hola, soy un profe. Vamos a poner aquí

578
00:49:37,449 --> 00:49:46,199
soy un profesor. Ejecutamos

579
00:49:46,199 --> 00:49:49,739
y efectivamente ya es algo

580
00:49:49,739 --> 00:49:53,880
que nos dan más pistas de lo que diría

581
00:49:53,880 --> 00:49:57,960
con el toString un profesor que si ponemos esto. Pero si tenemos

582
00:49:57,960 --> 00:50:02,139
15 profesores y en el toString decimos hola soy un profesor

583
00:50:02,139 --> 00:50:05,940
todos ellos me van a decir hola soy un profesor.

584
00:50:06,079 --> 00:50:10,059
Entonces, ¿qué podemos hacer? Pues podemos aprovechar información de cada uno

585
00:50:10,059 --> 00:50:14,280
de los profesores en particular. ¿Y dónde tenemos particularizado cada uno de los profesores?

586
00:50:14,280 --> 00:50:18,420
En sus atributos. Entonces, si para este

587
00:50:18,420 --> 00:50:22,960
profesor antes de llamar a saludar cogemos y le

588
00:50:22,960 --> 00:50:27,800
decimos que su ese nombre si tuviéramos privadas estas estos

589
00:50:27,800 --> 00:50:33,820
atributos lo daríamos con setters y getters pues decimos que es valeria su

590
00:50:33,820 --> 00:50:39,039
nombre y mi prof punto y edad

591
00:50:39,039 --> 00:51:09,139
Decimos que tenga 13 años, pues ahora cuando llamemos al método toString, por aquí, podemos coger y decir que, bueno, un profesor de 13 años hemos dicho, pero bueno, podríamos decir que lo que devuelva, en lugar de ser una cadena así directamente, pues sea un hola, soy.

592
00:51:09,139 --> 00:51:39,559
Y aquí aprovecho y en esta cadena aprovecho y le meto información de sus atributos. Ese nombre y tengo y edad. Antes de hacer el retune del stream, pues aprovechará y hará esta transformación.

593
00:51:39,559 --> 00:51:44,139
entonces si ejecutamos por aquí, fijaros como ahora ya dice

594
00:51:44,139 --> 00:51:48,719
hola soy Valeria y tengo 13 años, ese toString inicial que teníamos

595
00:51:48,719 --> 00:51:52,219
que decía que era de la clase profesor

596
00:51:52,219 --> 00:51:56,719
y un identificador, hemos conseguido particularizarlo

597
00:51:56,719 --> 00:51:59,679
para cada uno de los profesores

598
00:51:59,679 --> 00:52:04,420
mediante la acción de identificar

599
00:52:04,420 --> 00:52:07,800
en la programación orientada a objetos que es la sobrescritura de métodos

600
00:52:07,800 --> 00:52:11,360
y particularizándolo de esta forma.

601
00:52:15,849 --> 00:52:17,750
¿Qué hemos hecho? Hemos llamado un método toString

602
00:52:17,750 --> 00:52:20,230
que devolvía un string,

603
00:52:20,969 --> 00:52:22,829
que es como está identificado en la clase object.

604
00:52:23,610 --> 00:52:25,610
En particular, el método toString ya hemos hablado

605
00:52:25,610 --> 00:52:29,090
y lo que hemos hecho ha sido capturar lo que devuelve ese string

606
00:52:29,090 --> 00:52:31,750
que devuelve el método toString en una variable

607
00:52:31,750 --> 00:52:34,309
y luego mostrar la información de esa variable.

608
00:52:35,230 --> 00:52:38,730
El método toString, en particular, aparte de esta función

609
00:52:38,730 --> 00:52:42,050
que acabamos de ver que tiene es el que se utiliza

610
00:52:42,050 --> 00:52:45,230
directamente Java

611
00:52:45,230 --> 00:52:48,269
considera cuando nosotros ponemos aquí

612
00:52:48,269 --> 00:52:49,949
el nombre de un objeto, miProf

613
00:52:49,949 --> 00:52:54,170
ponemos esto solo, lo que hace es buscar

614
00:52:54,170 --> 00:52:57,030
el método toString para cargarlo en el

615
00:52:57,030 --> 00:53:00,630
System.out.println, entonces si ponemos esto fijaros como al ejecutarlo

616
00:53:00,630 --> 00:53:03,489
me saca esa información

617
00:53:03,489 --> 00:53:06,650
del toString, es decir lo mismo que habíamos hecho aquí en dos pasitos

618
00:53:06,650 --> 00:53:13,670
que era, oye, tu string me devuelve lo que hayamos programado en ese método dentro de la clase profesor.

619
00:53:13,849 --> 00:53:19,409
Lo voy a guardar ya que devuelve un string, que es lo que hemos puesto aquí, que devuelve un string.

620
00:53:19,929 --> 00:53:24,949
Lo voy a guardar en una variable auxiliar string y luego escribo lo de la variable auxiliar.

621
00:53:25,510 --> 00:53:32,590
Pues si directamente ponemos aquí la referencia a la clase profesor, aunque tengas más métodos identificados por aquí,

622
00:53:32,590 --> 00:54:00,690
Java lo que hace siempre cuando integras una referencia dentro de un println es buscar el toString, que es precisamente lo que muestra aquí. Por eso es un método importante y por eso, por ejemplo, es un método disponible en toda clase que tengas, toda, toda lo tiene disponible, la forma de tenerlo disponible toda clase, aunque tú no lo escribas, es mediante enencia de object, porque cualquier referencia la puedes poner en el println.

623
00:54:00,690 --> 00:54:14,110
Y si no estuviera disponible por herencia desde object, los programas no nos compilarían. Más allá de que si no lo sobreescribimos, la información que nos dé no sea muy significativa en este caso de un objeto de la clase profesor.

624
00:54:14,110 --> 00:54:31,010
Pero sí, al tenerlo de herencia, aunque sea una información muy general y no muy útil, permite, nos garantiza que a través de esa herencia cualquier println no va a funcionar porque lo que utiliza aquí es el método toString y lo tiene todo objeto heredado desde la clase object.

625
00:54:31,010 --> 00:54:51,769
¿Sí? ¿Se entiende? ¿Más o menos? ¿No hay dudas de momento? No, vale. Vale, pues nada, esto tenemos con la herencia.

626
00:54:54,590 --> 00:55:01,769
Otra de las características que tenemos en la programación orientada a objetos es el polimorfismo.

627
00:55:01,769 --> 00:55:41,159
Morfismo. ¿Esto qué nos permite? Pues fijaros, si nosotros cogemos y definimos aquí en el main un objeto de la clase persona, en este contexto una persona, según el enunciado de un posible ejercicio que estuviéramos haciendo, pues diríamos, hay un ejercicio, en este ejercicio van a participar alumnos y profesores.

628
00:55:41,179 --> 00:55:54,719
Ambos dos son personas con estas características en común. Estas características en común de alumnos y profesores serían las que podríamos poner en la clase persona, ya que los dos luego van a heredar de la clase persona, pues solo los escribimos ahí en un sitio.

629
00:55:55,380 --> 00:56:06,920
Y luego el enunciado podría continuar diciendo, los alumnos tendrán su número de matrícula como atributo, mientras que los profesores tendrán su número de cuenta para cuando les ingresen la nómina.

630
00:56:06,920 --> 00:56:35,639
Los alumnos, como desafortunadamente no cobran por estudiar, pues no tienen nómina y los profesores no tienen número de matrícula porque no se han matriculado en ningún curso. Entonces, todas aquellas cosas comunes las podríamos poner en la clase persona y las particulares en la alumno y en la de profesor. Por herencia, las comunes las tendrían desde la clase persona por herencia a través del Stents que hemos puesto aquí al definir la clase tanto en una como en otra.

631
00:56:35,639 --> 00:56:47,510
Imaginaos que arrancamos el programa y este programa consiste en que solamente se va a conectar un alumno o un profesor, uno de los dos

632
00:56:47,510 --> 00:56:56,090
Y a través de esa conexión va a saludar

633
00:56:56,090 --> 00:57:01,050
Pero al principio podríamos no saber si va a ser un alumno o un profesor

634
00:57:01,050 --> 00:57:13,690
Imaginaos una clínica veterinaria que cuida a gatos y perros y cada día le pueden venir, a lo mejor atiende hasta dos animales cada día y le puede venir un gato, un perro, dos perros o dos gatos.

635
00:57:13,690 --> 00:57:32,710
Entonces, si yo cojo y defino aquí de forma directa alumnos, o lo que sería en el otro caso gatos, como va a ser uno solo, mi al igual a new alumno, pues ya mal iría, porque si quien saluda hoy es un profesor.

636
00:57:32,710 --> 00:57:43,010
Y si defino un profesor, mal iría si lo que defino aquí es un alumno. Pero en cambio, tanto si es un profesor como un alumno, pues está claro que va a ser una persona.

637
00:57:43,010 --> 00:57:56,690
Entonces, tenemos la posibilidad de definir una persona y que luego esta referencia a persona coja bien la forma de alumno o bien la forma de profesor para seguir ejecutando el programa.

638
00:57:57,670 --> 00:58:02,690
Entonces, ahí viene el tema un poco de lo que definimos como poliformismo.

639
00:58:02,690 --> 00:58:27,010
Bueno, normalmente lo que haríamos es que si, imaginaros que vamos a tomar aquí el criterio de selección que lo metemos por teclado, pero a lo mejor sería que leemos un fichero, bueno, el criterio de selección podría ser uno u otro.

640
00:58:27,010 --> 00:58:46,050
Aquí vamos a decir si lo que entra es un alumno al final en la ejecución de este programa o es un profesor. En tiempo de ejecución, no en tiempo de desarrollo del programa ni en tiempo de compilación, sino ya en tiempo de ejecución vamos a meter por teclado, cuando estemos ejecutando el programa, si quien entra hoy es un alumno o un profesor.

641
00:58:46,050 --> 00:59:15,570
Y así esta persona cogerá la forma de alumno o cogerá la forma de profesor. Esto que vamos a identificar es la forma que vamos a utilizar a través de teclado para identificar que es una persona, pues bueno, podría ser a través de, bueno, yo qué sé, de un lector de cámaras que de repente identifica si es un chico o una chica según tiene barba o no tiene barba o yo qué sé qué deciros o si lo lee de una base de datos y resulta que en la base de datos para el día de hoy justo la entrada dice que era un chico o que era una chica.

642
00:59:22,989 --> 00:59:29,710
Como aquí no tenemos para leer de base de datos de momento ni la cámara para hacer una identificación, pues lo vamos a capturar desde teclado.

643
00:59:30,210 --> 00:59:37,570
Entonces aquí cogemos y decimos un System.out.

644
00:59:40,630 --> 00:59:45,210
Decimos para arrancar el programa, oye, mira, lo que quiero es que sea una persona.

645
00:59:46,730 --> 01:00:02,679
Aquí pongo miper.saluda.

646
01:00:03,219 --> 01:00:06,519
Fijaros que quien saluda es el objeto de la persona.

647
01:00:06,780 --> 01:00:29,099
indica chico o chica

648
01:00:29,099 --> 01:00:33,579
chico o chica no, es alumno

649
01:00:33,579 --> 01:00:36,800
alumno o profesor

650
01:00:36,800 --> 01:00:47,170
mi scan.nextline

651
01:00:47,170 --> 01:01:05,050
y ahora aquí cogemos y hacemos un casting

652
01:01:05,050 --> 01:01:07,909
al tipo de objeto que sea, entonces decimos

653
01:01:07,909 --> 01:01:11,849
ese, si ese aus punto

654
01:01:11,849 --> 01:01:15,230
compare to, si es

655
01:01:15,230 --> 01:01:20,269
no vamos a validar mucho, vamos a decir chico en minúsculas

656
01:01:20,269 --> 01:01:29,469
chico no, alumno o profesor

657
01:01:29,469 --> 01:01:34,530
entonces aquí cogemos y decimos mi per

658
01:01:34,530 --> 01:01:41,670
que sea, a ver

659
01:01:41,670 --> 01:01:46,010
aquí no lo hacemos el new, vale, y aquí cogemos

660
01:01:46,010 --> 01:01:48,349
y aquí decimos miper que sea igual a new

661
01:01:48,349 --> 01:01:49,489
alumno

662
01:01:49,489 --> 01:01:56,349
en lugar de compare tú vamos a poner equals

663
01:01:56,349 --> 01:01:58,090
método equals

664
01:01:58,090 --> 01:02:00,590
si no es un alumno, es un profesor

665
01:02:08,739 --> 01:02:09,860
entonces lo que hacemos

666
01:02:09,860 --> 01:02:14,019
es definir

667
01:02:14,019 --> 01:02:17,300
me falta el new

668
01:02:17,300 --> 01:02:20,420
lo que hacemos es definir

669
01:02:20,420 --> 01:02:21,780
una referencia, una persona

670
01:02:21,780 --> 01:02:24,360
no lo hacemos el new, había puesto el new persona antes

671
01:02:24,360 --> 01:02:27,659
no se lo hacemos, y terminamos haciéndole un new

672
01:02:27,659 --> 01:02:30,840
para decir, oye, esta persona, según el contexto

673
01:02:30,840 --> 01:02:33,559
del programa, según haya ido, aquí lo estamos cogiendo por teclado

674
01:02:33,559 --> 01:02:36,079
pero podría ser mediante algún otro mecanismo, ¿verdad?

675
01:02:36,920 --> 01:02:39,239
Termina siendo un alumno esa persona

676
01:02:39,239 --> 01:02:42,880
coge la forma, poliformismo, es la característica

677
01:02:42,880 --> 01:02:45,840
de la programación orientada a objetos de la que estamos hablando

678
01:02:45,840 --> 01:02:48,940
de un alumno o coge la forma de un profesor

679
01:02:48,940 --> 01:02:51,699
¿Y quién saluda? Saluda mi per

680
01:02:51,699 --> 01:02:53,400
Fijaros que este código es genérico

681
01:02:53,400 --> 01:03:01,400
y en una ejecución resultará ser un alumno y en otra será un profesor.

682
01:03:02,340 --> 01:03:05,139
Y aquí cuando lo hemos definido a la referencia también lo hemos hecho genérico.

683
01:03:05,280 --> 01:03:10,239
Es decir, todo el código es genérico menos en el momento en el que tomamos la decisión

684
01:03:10,239 --> 01:03:12,679
de si esa persona va a actuar como alumno o como profesor.

685
01:03:12,760 --> 01:03:14,159
Va a coger una forma u otra.

686
01:03:16,639 --> 01:03:22,940
Entonces le damos aquí, a ver, salvo por aquí, le doy aquí a ejecutar

687
01:03:22,940 --> 01:03:38,119
Y digo que sea un alumno, y si digo que sea un alumno, pues entonces fijaros cómo ha llamado, a pesar de que hemos utilizado el objeto de la clase, perdonad un segundo.

688
01:03:38,800 --> 01:03:48,059
Natalia, tenemos... Ah, vale, bueno.

689
01:03:51,230 --> 01:03:52,869
No, no, en absoluto, en absoluto.

690
01:03:54,949 --> 01:03:57,130
No, no, no me molestas, no, no te preocupes.

691
01:03:58,670 --> 01:03:59,150
Continúo.

692
01:03:59,150 --> 01:04:15,210
Pues nada, fijaros cómo aquí, en realidad, este saludar, si nos fijamos en este miper y vemos que hemos definido una referencia a la clase persona, lo previsible sería que el saludo dijese hola, soy una persona, ¿verdad?

693
01:04:19,679 --> 01:04:29,500
Bueno, a ver aquí en el principal. Bueno, me ha mostrado los dos, en realidad. Hola, soy una persona y soy... No, a ver, perdón. Lo que ha hecho ha sido el alumno, porque tenemos aquí llamando al super.

694
01:04:30,039 --> 01:04:46,969
Quito el super este, saludar, vuelvo a ejecutar, pues si es un alumno, lo previsible, en principio, si no estuviéramos considerando la característica de sobrecarga de la programación orientada a objetos,

695
01:04:47,309 --> 01:04:57,949
al haber definido mi per como una referencia a persona, sería que este saludar, pues si no viéramos esta parte del código, tendríamos la tentación de coger y venirnos a la clase persona y decir,

696
01:04:58,429 --> 01:05:01,829
Al saludar me va a decir, hola, soy una persona, pero nos ha dicho, hola, soy un alumno.

697
01:05:02,349 --> 01:05:12,869
¿Por qué? Bueno, pues porque hemos decidido hacer el new de un alumno.

698
01:05:12,869 --> 01:05:18,590
Entonces, el método que en realidad ha utilizado ha sido el método saludar de la clase alumno.

699
01:05:20,610 --> 01:05:26,230
Si os fijáis, aquí le estamos haciendo como alternativa el new sobre la clase profesor.

700
01:05:26,230 --> 01:05:51,289
Entonces, si hacemos una nueva ejecución, aquí ahora decimos que lo que queremos es que sea un profesor, nos dice hola, soy una persona. En realidad nos está saludando como saludan los profesores. Si nos vamos a la clase profesor, el método saludar no existe. Como no existe, ¿cuál utiliza? El que tiene heredado de la clase persona, entonces nos ha dicho hola, soy una persona, pero ha saludado como si fuese un profesor.

701
01:05:51,289 --> 01:05:56,250
si en la clase profesor sobrescribimos el método

702
01:05:56,250 --> 01:06:00,150
saludar de la clase persona para garantizar que

703
01:06:00,150 --> 01:06:04,050
efectivamente está saludando como un profesor y no como una persona ya que nos ha sacado este texto

704
01:06:04,050 --> 01:06:09,320
nos venimos por aquí, podemos poner la etiqueta

705
01:06:09,320 --> 01:06:13,559
overwrite esta para garantizar efectivamente que no

706
01:06:13,559 --> 01:06:16,519
nos hemos equivocado y si que estamos sobrescribiendo algo

707
01:06:16,519 --> 01:06:21,440
y ahora en la clase profesor respecto al comportamiento que teníamos de la clase

708
01:06:21,440 --> 01:06:24,840
persona, lo modificamos y decimos, hola, soy un profesor.

709
01:06:27,139 --> 01:06:30,420
Entonces, hacemos una nueva ejecución y vamos a hacer el new.

710
01:06:31,760 --> 01:06:35,039
Vamos a darle forma de profesor a algo que inicialmente

711
01:06:35,039 --> 01:06:38,880
era una referencia a una persona. Le digo

712
01:06:38,880 --> 01:06:43,539
profesor por aquí. Y fijaros cómo efectivamente ya su comportamiento

713
01:06:43,539 --> 01:06:48,539
no es como el de una persona, sino el método

714
01:06:48,539 --> 01:06:52,340
saludar actúa como lo tenemos sobrescrito. Dice, hola, soy un profesor.

715
01:06:53,340 --> 01:07:18,559
Bueno, pues esto es otra de las características de la programación orientada a objetos que nos hace referencia a este tema y que tiene que ver con el polimorfismo, es decir, un objeto definido en el programa de una determinada forma puede coger las diferentes formas de objetos de aquellas clases que son hijas suyas.

716
01:07:18,559 --> 01:07:27,199
Es decir, que la tiene identificada con Stents como hijas gracias a la etiqueta Stents, ¿verdad? De la clase padre.

717
01:07:27,199 --> 01:07:56,019
Claro, sí. La idea de esto es, aquí yo tengo capacidad de que un objeto coja diferentes formas. Fijaros cómo estamos haciendo que coja la forma de alumno a través de la característica de polimorfismo de la programación orientada a objetos.

718
01:07:56,019 --> 01:08:16,920
Que coja la forma de alumno o que coja la forma de profesor. Este if que he puesto aquí lo hemos capturado desde teclado mediante un objeto de la clase escáner, pero podría haber sido por diferentes medios. Imaginaros que los días lunes, miércoles y viernes saludan los profesores y los martes y los jueves saludan los alumnos.

719
01:08:17,520 --> 01:08:21,760
pues aquí podríamos coger del sistema el día que es

720
01:08:21,760 --> 01:08:24,760
y según una cosa, por decir, oye, pues si el lunes, miércoles o viernes,

721
01:08:24,880 --> 01:08:28,180
que sea un alumno, y si el jueves o martes, que sea un profesor.

722
01:08:29,100 --> 01:08:33,640
Aquí es donde tomamos la decisión de que un objeto tome una forma en particular.

723
01:08:34,699 --> 01:08:38,500
Pero aquí el código es general y aquí el código es general.

724
01:08:38,859 --> 01:08:42,140
Aquí yo no he puesto código particular para que sea un alumno

725
01:08:42,140 --> 01:08:45,479
ni para que sea un profesor, ni aquí tampoco, en todo esto.

726
01:08:46,479 --> 01:08:53,739
Entonces, ¿en qué momento se aplica el polimorfismo a un objeto que de inicio era un objeto de la clase persona?

727
01:08:53,899 --> 01:09:00,420
Pues se aplica cuando hacemos el new al identificar que tome forma de alumno o que tome forma de profesor.

728
01:09:04,239 --> 01:09:04,640
¿Sí?

729
01:09:10,600 --> 01:09:11,819
Eso es, claro, claro.

730
01:09:13,399 --> 01:09:14,340
Claro, ¿por qué?

731
01:09:16,680 --> 01:09:20,079
Ahora intentamos a ver si nos deja Eclipse que compile si no es hija.

732
01:09:20,079 --> 01:09:29,039
Vamos a intentarlo, yo creo que no nos va a dejar, pero bueno, vamos a buscar un poco un razonamiento antes de coger e ir con el código a ver si nos compila o no.

733
01:09:29,960 --> 01:09:36,579
Fijaros que aquí lo que estamos llamando es a un método saludar que está disponible en la clase persona.

734
01:09:38,060 --> 01:09:48,100
Si yo utilizo aquí un saludar y aquí le hago un new de algo que no sea su hijo, esa otra clase que no es su hija podría no tener el método saludar.

735
01:09:49,060 --> 01:09:57,300
En cambio, todo aquel que sea su hijo, con toda seguridad, tiene el método de saludar porque o bien lo tiene sobrescrito o como poco lo tiene heredado de la clase padre.

736
01:09:59,819 --> 01:10:06,239
Imaginaos aquí la clase humano. Tiene la clase saludar, el método de saludar. Se lo voy a borrar para que no exista.

737
01:10:06,239 --> 01:10:08,380
saludar

738
01:10:08,380 --> 01:10:10,619
si yo cojo y aquí cojo

739
01:10:10,619 --> 01:10:12,260
y quiero que

740
01:10:12,260 --> 01:10:14,159
esta referencia a la clase persona

741
01:10:14,159 --> 01:10:16,300
en realidad se comporte como un humano

742
01:10:16,300 --> 01:10:18,100
cuando llegase aquí y dijese

743
01:10:18,100 --> 01:10:20,399
igual que aquí se estaba comportando

744
01:10:20,399 --> 01:10:21,920
como un alumno, como un profesor

745
01:10:21,920 --> 01:10:23,939
si al llegar aquí fuese un humano

746
01:10:23,939 --> 01:10:26,520
cuando llamo al método saludar, el programa me diría

747
01:10:26,520 --> 01:10:28,020
saludar, que saludar

748
01:10:28,020 --> 01:10:30,659
si tú no tienes definido aquí saludar

749
01:10:30,659 --> 01:10:32,560
ni lo tienes disponible por herencia

750
01:10:32,560 --> 01:10:34,180
de ningún sitio, pues eso no me vale

751
01:10:34,180 --> 01:10:38,560
¿lo veis?

752
01:10:38,560 --> 01:10:45,300
vamos a intentar aquí a ver si nos deja hacer un new

753
01:10:45,300 --> 01:10:47,920
pero yo entiendo que no

754
01:10:47,920 --> 01:10:51,119
porque no, vamos, fijaros que directamente

755
01:10:51,119 --> 01:10:53,619
ya no me deja el IDE, a ver que nos dice

756
01:10:53,619 --> 01:10:56,340
dice no puedes convertir un humano a una persona

757
01:10:56,340 --> 01:10:59,579
no puedes coger esa forma

758
01:10:59,579 --> 01:11:01,680
no puedes utilizar la característica de poliformismo

759
01:11:01,680 --> 01:11:04,960
por eso simplemente, directamente no nos deja

760
01:11:04,960 --> 01:11:09,140
y si queremos buscar una explicación lógica, pues podría ser esta que te cuento

761
01:11:09,140 --> 01:11:36,899
Un humano no podría saludar porque no tiene código para saludar, ni implementado ni heredado. En cambio, todo aquel que sí que herede de persona, obvio, lo tiene sobrescrito y ejecutará este código, pero si no lo tiene, lo tendrá disponible por herencia desde la clase principal, que es la clase para la cual hemos definido aquí la referencia al objeto, miper en este caso.

762
01:11:36,899 --> 01:11:52,000
claro, es que este es el momento

763
01:11:52,000 --> 01:11:53,819
en el que aplicamos polimorfismo

764
01:11:53,819 --> 01:11:57,300
que haces el new para que se comporte como un alumno

765
01:11:57,300 --> 01:11:59,159
o haces el new para que se comporte como un profesor

766
01:11:59,159 --> 01:12:01,640
si no haces este new

767
01:12:01,640 --> 01:12:04,319
¿qué es lo que tienes?

768
01:12:04,420 --> 01:12:05,359
pues lo que tienes es

769
01:12:05,359 --> 01:12:08,140
un programa normal sin polimorfismo

770
01:12:08,140 --> 01:12:11,479
pues tendrías una persona que saluda

771
01:12:11,479 --> 01:12:12,619
y como quien saludaría

772
01:12:12,619 --> 01:12:14,319
pues bueno, aquí no me compila

773
01:12:14,319 --> 01:12:16,939
porque no le he hecho aquí el new para que sea una persona, ¿verdad?

774
01:12:17,500 --> 01:12:20,260
Pero como me saludaría como una persona y ya está.

775
01:12:20,399 --> 01:12:22,479
Sería una persona sin polimorfismo ni nada.

776
01:12:22,640 --> 01:12:24,199
Entonces la característica de polimorfismo es

777
01:12:24,199 --> 01:12:30,310
no la proporciona en este momento hacer un new o hacer otro.

778
01:12:34,170 --> 01:12:38,220
¿Sí? ¿Se entiende? Vale.

779
01:12:40,220 --> 01:12:42,619
Bueno, pues aprovechéis los foros y volvéis a preguntar.

780
01:12:43,319 --> 01:12:45,699
Acordaros que os respondo gustosamente,

781
01:12:45,939 --> 01:12:48,800
pero aunque fuera un poco menos gustosamente me pagan por esto,

782
01:12:48,859 --> 01:12:49,840
así que no me queda más remedio.

783
01:12:49,840 --> 01:12:51,899
así que los aprovecháis y me preguntáis por ahí.

784
01:12:53,000 --> 01:12:59,539
Bueno, mirad, introducido un poco el polimorfismo, hemos hablado en esta tutoría

785
01:12:59,539 --> 01:13:02,859
de varias características de la programación orientada a objetos, polimorfismo ahora,

786
01:13:03,560 --> 01:13:11,340
hemos hablado de la ocultación o, como lo decíamos, cuando teníamos el código oculto

787
01:13:11,340 --> 01:13:16,619
y simplemente veíamos una clase daba la cara a una clase y, por tanto, los objetos,

788
01:13:16,619 --> 01:13:21,760
cuando llamábamos a métodos y atributos, daba la clase a través de su protocolo, su interfaz.

789
01:13:22,680 --> 01:13:27,020
También hemos hablado de la sobrecarga, que hemos sobrecargado el método saludar.

790
01:13:28,600 --> 01:13:32,239
Cuando no estamos hablando de Java y estamos hablando de programación orientada a objetos

791
01:13:32,239 --> 01:13:35,859
y te explican lo que son las clases, lo que son los objetos, lo que son las características,

792
01:13:36,659 --> 01:13:41,739
pues hay cinco o seis conceptos que son los que de base definen la programación orientada a objetos.

793
01:13:41,739 --> 01:14:04,420
Y estos tres, la extracción era este que te oculta la información para que no la veas y simplemente interactúes con los objetos a través de sus interfaces. Pues estos conceptos de programación orientada a objetos, los diferentes lenguajes, si quieren ser realmente lenguajes basados en este concepto, pues tienen que implementarlos.

794
01:14:04,420 --> 01:14:08,000
y ahora estamos viendo, por ejemplo, cómo Java implementa algunos de ellos.

795
01:14:12,439 --> 01:14:15,220
Y otra cosa que también habíamos hablado algún día

796
01:14:15,220 --> 01:14:20,359
son las clases abstractas y de la mano de las clases abstractas

797
01:14:20,359 --> 01:14:25,060
los interfaces, que vendrían a ser como unas especies de clases abstractas

798
01:14:25,060 --> 01:14:27,039
un poquito más llevadas al último extremo.

799
01:14:27,380 --> 01:14:31,560
Vamos a repasar un poco estos conceptos, que también os habla de ellos en este tema.

800
01:14:33,680 --> 01:14:37,539
Tú dentro de una clase es posible que definas aquí

801
01:14:37,539 --> 01:14:50,500
mediante algún método, mediante la etiqueta abstract, public, abstract, despedir y pones aquí un punto y coma.

802
01:14:50,500 --> 01:15:00,560
A ver, tenemos que decir si devuelve algo, abstract, voy, despedir no devuelve nada, a ver, ¿por qué todavía no me compila?

803
01:15:01,619 --> 01:15:04,460
Voy a ponerlo con minúscula, aunque ese no es el motivo por el que no compile.

804
01:15:04,460 --> 01:15:13,449
vale, bueno, puedo definir un método abstracto

805
01:15:13,449 --> 01:15:17,489
y aquí ahora mismo no me está compilando porque me dice, oye, si tú tienes en una clase

806
01:15:17,489 --> 01:15:21,329
un método que sea abstracto, fijaros que no me compila tampoco, la clase también

807
01:15:21,329 --> 01:15:27,890
tiene que ser abstracta, vale, ya me compila, fijaros que cuando he definido

808
01:15:27,890 --> 01:15:31,909
el método despedir, como, y le he puesto la etiqueta

809
01:15:31,909 --> 01:15:35,649
abstracta, el resto de etiquetas ya las conocemos, el public y el void

810
01:15:35,649 --> 01:15:38,590
me ha obligado también a poner que la clase sea abstracta

811
01:15:39,289 --> 01:15:51,449
He puesto, después de la asignatura o encabezado de este método, he puesto un punto y coma y no, como solemos hacer al uso, la apertura y cierre de llaves con el código que realmente se ejecuta cuando llamamos a ese método.

812
01:15:52,109 --> 01:15:55,729
Es decir, aquí no he dicho lo que tiene que pasar cuando un profesor se despide.

813
01:15:56,890 --> 01:16:05,069
¿Y para qué hago esto? Pues parece un poco inútil si no lo explicamos un poquito más, cosa que vamos a hacer ahora.

814
01:16:05,069 --> 01:16:10,550
aquí lo que estoy diciendo es cuando haya algo que sea un profesor

815
01:16:10,550 --> 01:16:13,930
pues quiero que mediante el método este sobre escrito

816
01:16:13,930 --> 01:16:17,510
el toString se comporte de esta forma, tenga unos determinados

817
01:16:17,510 --> 01:16:22,210
esperad porque esto, más que aquí lo quería meter en otra clase

818
01:16:22,210 --> 01:16:26,250
voy a quitarlo de aquí y me lo voy a llevar a la clase, no profesor sino a la clase

819
01:16:26,250 --> 01:16:36,340
persona, también podría estar en la otra pero para contarlo

820
01:16:36,340 --> 01:16:40,439
me facilita la cosa tenerlo aquí, entonces cuando

821
01:16:40,439 --> 01:16:44,439
algo sea una persona, yo podré saludar

822
01:16:44,439 --> 01:16:48,460
mediante esto, tendrá estas características, pero el hecho de definir

823
01:16:48,460 --> 01:16:51,539
la clase abstracta, lo que me permite es

824
01:16:51,539 --> 01:16:55,779
definir métodos que sean abstractos, y estos métodos abstractos lo que hago es

825
01:16:55,779 --> 01:17:00,439
no identificar el código que va a tener en respuesta a la llamada a este método.

826
01:17:01,159 --> 01:17:03,640
¿Para qué sirve esto? Pues esto me sirve para que

827
01:17:03,640 --> 01:17:08,279
las clases que sean hijas de la clase

828
01:17:08,279 --> 01:17:12,319
persona, en este caso la clase alumno y la clase profesor, estoy de alguna

829
01:17:12,319 --> 01:17:16,420
forma obligando a que estas clases, toda clase que quiera ser hija de la clase

830
01:17:16,420 --> 01:17:20,180
persona, heredará sus atributos y sus métodos

831
01:17:20,180 --> 01:17:24,380
pero además tienen que firmar conmigo un contrato, como si sacáramos

832
01:17:24,380 --> 01:17:28,220
ahí un papel y delante del notario echáramos una firma, oye tú si quieres ser alumno

833
01:17:28,220 --> 01:17:32,760
hijo mediante STEM de la clase persona, obligatoriamente

834
01:17:32,760 --> 01:17:36,399
tendrás que ser capaz de despedirte, yo no te voy a decir cómo, pero sí

835
01:17:36,399 --> 01:17:40,159
que quiero que te puedas despedir y si no, olvídate de ser

836
01:17:40,159 --> 01:17:44,340
una clase hija mía, ¿vale? ¿Cómo te tienes que despedir? Yo no te lo estoy

837
01:17:44,340 --> 01:17:48,119
diciendo. ¿Cómo tienes que saludar? Si no lo escribes, saluda así.

838
01:17:48,600 --> 01:17:51,920
Esto sí, pero el despedirte no te lo voy a decir,

839
01:17:52,359 --> 01:17:56,319
pero sí que quiero que tengas esa posibilidad de despedirte. Fijaros cómo desde el

840
01:17:56,319 --> 01:18:00,060
momento en el que hemos metido el método despedir como clase abstracta,

841
01:18:00,500 --> 01:18:04,220
la clase alumno ha dejado de compilarme y la clase profesor también ha dejado de

842
01:18:04,220 --> 01:18:08,039
compilar. ¿Por qué? Porque ahora son hijas de una clase abstracta con algún

843
01:18:08,039 --> 01:18:13,890
método sin implementar. Y es eso en lo que consiste

844
01:18:13,890 --> 01:18:17,630
la clase abstracta. Es un acuerdo de, no te voy a decir

845
01:18:17,630 --> 01:18:20,850
cómo, pero despídete. ¿Por qué? Pues porque

846
01:18:20,850 --> 01:18:25,409
toda persona en el programa en general, cuando instancie un objeto de la clase

847
01:18:25,409 --> 01:18:29,770
alumno, tendrá que tener a través del interfaz de la clase alumno la posibilidad

848
01:18:29,770 --> 01:18:33,430
de despedirse. Si yo no te pongo aquí esto como abstracto,

849
01:18:33,430 --> 01:18:37,609
como no lo tienes heredado, si tú no lo implementas aquí en tu código,

850
01:18:37,989 --> 01:18:41,689
luego igual alguien que instancie un alumno y quiera llamar al método de despedir

851
01:18:41,689 --> 01:18:45,869
no va a ser capaz. ¿Por qué? Porque ni existe en la clase alumno ni lo tiene disponible

852
01:18:45,869 --> 01:18:50,229
por herencia. Pero si lo pongo así, pues ya te obligo.

853
01:18:50,989 --> 01:18:53,989
Entonces, si vengo aquí a la clase alumno ahora, nos ayudamos

854
01:18:53,989 --> 01:18:57,489
del IDE, que siempre nos ha hecho una mano estupenda para estas cosas,

855
01:18:58,710 --> 01:19:01,890
pues fijaros cómo al ponerme sobre el error me dice que

856
01:19:01,890 --> 01:19:04,890
añada los métodos que están sin implementar.

857
01:19:05,109 --> 01:19:07,289
Entonces, le doy aquí ahora, ¿y qué método me añade?

858
01:19:07,770 --> 01:19:08,729
El despedir. ¿Por qué?

859
01:19:08,850 --> 01:19:12,430
Porque a través de la herencia he firmado como alumno,

860
01:19:12,670 --> 01:19:16,510
al ser su hija, un acuerdo para implementar aquellos métodos

861
01:19:16,510 --> 01:19:19,510
que la clase persona tiene definidos como abstractos.

862
01:19:20,189 --> 01:19:21,210
Entonces, voy a ir aquí a salvar.

863
01:19:21,850 --> 01:19:24,550
Fijaros cómo la clase alumno ya me empieza a compilar.

864
01:19:25,069 --> 01:19:28,149
Ahora tendré que meter aquí el código de cómo se despiden los alumnos, ¿verdad?

865
01:19:28,149 --> 01:19:32,170
por herencia no tengo ningún método

866
01:19:32,170 --> 01:19:36,850
ningún código disponible desde la clase padre sobre cómo despedirme

867
01:19:36,850 --> 01:19:40,829
pero al ser abstracto me ha obligado a implementar un código

868
01:19:40,829 --> 01:19:44,069
de cómo se despiden los alumnos, con lo cual cuando para un alumno

869
01:19:44,069 --> 01:19:49,010
llamemos al método de despedir pues ya hará el código

870
01:19:49,010 --> 01:19:52,310
que tengamos puesto aquí, system.out, vamos a poner aquí un system.out

871
01:19:52,310 --> 01:19:58,630
y decimos, bueno pues

872
01:19:58,630 --> 01:20:01,069
algo sencillo, soy un alumno y me despido

873
01:20:01,069 --> 01:20:09,109
¿Qué nos sucede en la clase

874
01:20:09,109 --> 01:20:10,949
profesor que todavía no nos compila? Pues lo mismo

875
01:20:10,949 --> 01:20:12,590
que nos estaba pasando en la clase alumno

876
01:20:12,590 --> 01:20:15,090
hereda de persona y

877
01:20:15,090 --> 01:20:17,189
aquí, en el momento que ha dicho

878
01:20:17,189 --> 01:20:19,130
que heredo, ha firmado un acuerdo

879
01:20:19,130 --> 01:20:20,229
con la clase persona

880
01:20:20,229 --> 01:20:23,109
de que todos aquellos métodos

881
01:20:23,109 --> 01:20:24,949
que tenga como abstractos, los tendrá que

882
01:20:24,949 --> 01:20:26,970
implementar, porque en el contexto

883
01:20:26,970 --> 01:20:30,829
de este programa, todo aquel que sea una persona o un hijo

884
01:20:30,829 --> 01:20:34,729
de una persona tendrá que tener la posibilidad de despedirse porque desde clases terceras

885
01:20:34,729 --> 01:20:38,649
por ahí a lo mejor vamos a querer que los profesores, en un momento haremos una llamada al método

886
01:20:38,649 --> 01:20:42,770
de despedir. Pues nada, si me pongo aquí sobre el profesor, fijaros que lo que

887
01:20:42,770 --> 01:20:46,510
me requiere aquí el IDE es de nuevo que meta los

888
01:20:46,510 --> 01:20:50,670
métodos que no están implementados, pues ya está, me pone el despedir, fijaros

889
01:20:50,670 --> 01:20:55,270
como me pone la etiqueta override, ¿por qué? porque estamos sobrescribiendo

890
01:20:55,270 --> 01:21:00,029
el despedir de la clase Persona, que en verdad no tenía código, pero lo estamos sobrescribiendo.

891
01:21:02,460 --> 01:21:04,399
Voy a hacer copy de esto por escribir menos.

892
01:21:06,659 --> 01:21:08,300
Y aquí decimos soy un profesor.

893
01:21:12,760 --> 01:21:15,840
Y ya está, pues ya tenemos otra vez el programa en marcha. Fijaros como

894
01:21:15,840 --> 01:21:22,050
esto ya está en marcha, ya va bien. Hemos introducido

895
01:21:22,050 --> 01:21:26,250
otro nuevo concepto que es la etiqueta ASTRAD para los métodos

896
01:21:26,250 --> 01:21:28,090
que viene a identificarnos. Métodos sin

897
01:21:28,090 --> 01:21:32,250
métodos donde no indicamos

898
01:21:32,250 --> 01:21:36,569
cómo, qué código Java tiene que ejecutarse

899
01:21:36,569 --> 01:21:40,529
cuando lo hacemos, pero sí que nos obliga a que los hijos de esta clase

900
01:21:40,529 --> 01:21:42,970
tengan que implementarlos.

901
01:21:44,090 --> 01:21:48,729
Aparte del astrat este, fijaros en el método, me ha obligado a poner que la clase

902
01:21:48,729 --> 01:21:52,430
es astrat. ¿Y qué significa que la clase sea astrat?

903
01:21:52,430 --> 01:21:56,409
Pues lo que me va a suponer ahora es que ya no voy a poder instanciar

904
01:21:56,409 --> 01:21:59,470
objetos de la clase persona desde el momento en el que

905
01:21:59,470 --> 01:22:02,409
se abstracta. ¿Y por qué sucede

906
01:22:02,409 --> 01:22:05,510
esto? Pues nada, intentamos buscar la explicación yendo al sentido

907
01:22:05,510 --> 01:22:07,489
común de nuevo. Si yo defino una persona

908
01:22:07,489 --> 01:22:11,369
cuya referencia sea miPer y ahora cojo y pongo

909
01:22:11,369 --> 01:22:14,170
miPer.despedir, vas a ver

910
01:22:14,170 --> 01:22:16,770
ese objeto de la clase persona que hacer

911
01:22:16,770 --> 01:22:20,350
si el método es abstracto y no tiene el código Java de cómo

912
01:22:20,350 --> 01:22:23,609
se tiene que comportar, pues no. Entonces, como no existe

913
01:22:23,609 --> 01:22:26,310
esta posibilidad, en el momento que la clase

914
01:22:26,310 --> 01:22:30,489
es abstracta, ya no podemos instanciar objetos de esa clase y el motivo

915
01:22:30,489 --> 01:22:34,369
es este. Una persona debería ser capaz

916
01:22:34,369 --> 01:22:37,010
de despedirse y no tengo código de cómo hacerlo.

917
01:22:38,550 --> 01:22:42,050
Si vengo aquí ahora y yo cojo y digo

918
01:22:42,050 --> 01:22:44,229
aquí en mi per igual a new persona

919
01:22:44,229 --> 01:22:49,850
y le pongo el constructor, fijaros que directamente no me deja. Y si me pongo por aquí

920
01:22:49,850 --> 01:22:53,970
dice no puedes instanciar un objeto de la clase

921
01:22:53,970 --> 01:22:57,109
persona. ¿Cuál es el motivo? Que la clase persona es abstracta.

922
01:22:57,649 --> 01:23:00,970
¿Y por qué es abstracta? Porque se entiende que hay métodos

923
01:23:00,970 --> 01:23:05,050
que no tienen definido cómo comportarse.

924
01:23:08,600 --> 01:23:12,380
Bueno, aquí me faltaba un new. Igual, bueno, en cualquier caso

925
01:23:12,380 --> 01:23:19,430
sigue sin dejarme con el mismo motivo. ¿Dudas de la clase abstracta?

926
01:23:19,890 --> 01:23:22,250
¿Método y clase abstracta? ¿Para qué nos sirve esta etiqueta?

927
01:23:26,180 --> 01:23:28,399
De alguna forma fijamos comportamientos

928
01:23:28,399 --> 01:23:33,600
en la clase abstracta a través de los métodos

929
01:23:33,600 --> 01:23:38,199
acciones que todo objeto de otras clases hijas

930
01:23:38,199 --> 01:23:42,039
sí o sí dentro de este programa tienen que desarrollar,

931
01:23:42,119 --> 01:23:45,899
tienen que implementar, porque si no, te bloqueo que seas hija

932
01:23:45,899 --> 01:23:49,979
de la clase persona en este caso. Eso para la etiqueta

933
01:23:49,979 --> 01:23:53,840
abstracta en el método. Y para la etiqueta abstracta en la clase, lo que estamos diciendo

934
01:23:53,840 --> 01:23:57,779
es, como tienen métodos no implementados, no vas a poder instanciar

935
01:23:57,779 --> 01:24:00,800
un objeto de esta clase, como hemos visto antes en la clase principal.

936
01:24:05,680 --> 01:24:12,020
¿Bien? ¿Sí? Bueno, fijaros, las clases abstractas

937
01:24:12,020 --> 01:24:16,000
tienen características, tienen métodos desarrollados

938
01:24:16,000 --> 01:24:19,760
y métodos abstractos. Cajón desastre, nos permite tener

939
01:24:19,760 --> 01:24:23,640
de todo. Alguien que sea hijo de una clase

940
01:24:23,640 --> 01:24:28,039
abstracta, la clase alumno, por ejemplo, tendrá esos atributos

941
01:24:28,039 --> 01:24:31,640
disponibles, podrá utilizar por herencia directamente

942
01:24:31,640 --> 01:24:35,520
los métodos que no sean abstractos y que estén desarrollados y estarán obligados

943
01:24:35,520 --> 01:24:40,039
a implementar aquellos que en la clase de padres hayamos

944
01:24:40,039 --> 01:24:43,600
utilizado la clase abstracta. Si queremos dar

945
01:24:43,600 --> 01:24:47,539
un pasito más y considerar

946
01:24:47,539 --> 01:24:51,359
una clase en las cuales, bueno, vamos a decir una clase de momento

947
01:24:51,359 --> 01:24:55,840
en las cuales todos sus métodos nos obliguen a las clases hijas

948
01:24:55,840 --> 01:24:59,560
a desarrollarlos, es decir, que todos sus métodos sean abstractos

949
01:24:59,560 --> 01:25:04,500
y en principio no dispongan de atributos, lo que desarrollamos

950
01:25:04,500 --> 01:25:08,460
es una interfaz. Una clase abstracta puede tener

951
01:25:08,460 --> 01:25:12,380
métodos desarrollados y métodos abstractos. Una interfaz solamente

952
01:25:12,380 --> 01:25:16,479
tendrá métodos abstractos. Vamos a crear una interfaz aquí

953
01:25:16,479 --> 01:25:19,720
en el proyecto. Mirad, nos venimos por aquí,

954
01:25:20,340 --> 01:25:24,340
venimos a New y típicamente nos venimos siempre aquí a clase, pero

955
01:25:24,340 --> 01:25:28,140
fijaros cómo nos da la opción también de, bueno, nos da muchas opciones por aquí

956
01:25:28,140 --> 01:25:31,960
y una de ellas es la de interfaz, le damos aquí al interfaz

957
01:25:31,960 --> 01:25:35,119
vamos a darle un nombre, vamos a poner

958
01:25:35,119 --> 01:25:40,159
yo que sé, que deciros, trabajador

959
01:25:40,159 --> 01:25:45,439
bueno, aquí me define un interfaz

960
01:25:45,439 --> 01:25:50,760
y vamos a, esto es un interfaz, vamos a hacer intentos de hacer cosas

961
01:25:50,760 --> 01:25:54,420
que no nos deje, por ejemplo, vamos a definir un public

962
01:25:54,420 --> 01:25:59,359
void fichar, pues el trabajador tiene que fichar

963
01:25:59,359 --> 01:26:02,939
y para fichar, cogemos y decimos

964
01:26:02,939 --> 01:26:05,420
system.out.println, lo que sea, ¿vale?

965
01:26:05,500 --> 01:26:12,279
system.out.println, fichando

966
01:26:12,279 --> 01:26:16,340
y que dice, se me queja, y hay que ver que nos dice

967
01:26:16,340 --> 01:26:20,560
mirad, a la que voy, la que me interesa

968
01:26:20,560 --> 01:26:23,819
es este removeMethodBody, dice, quita el método

969
01:26:23,819 --> 01:26:29,779
ya lo pongo aquí, y ya me deja

970
01:26:29,779 --> 01:26:33,180
fichar y

971
01:26:33,180 --> 01:26:37,939
cobrar también, mal vamos si no cobramos, si fichamos y trabajamos

972
01:26:37,939 --> 01:26:41,779
y no cobramos, pues esto otro método, fijaros que en el interfaz

973
01:26:41,779 --> 01:26:45,460
en el momento que en uno de los métodos he intentado meter código, no me ha dejado

974
01:26:45,460 --> 01:26:49,199
en cambio lo que me permite es definir

975
01:26:49,199 --> 01:26:54,100
diferentes métodos que todos ellos

976
01:26:54,100 --> 01:26:58,220
serían métodos en verdad abstractos, como se meten

977
01:26:58,220 --> 01:27:00,680
de hecho

978
01:27:00,680 --> 01:27:03,439
bueno, vamos a ponerle

979
01:27:03,439 --> 01:27:04,399
abstract incluso

980
01:27:04,399 --> 01:27:07,359
le apetece que no lo ponga

981
01:27:07,359 --> 01:27:09,119
no lo permite sin ponerlo, pero bueno

982
01:27:09,119 --> 01:27:10,180
vamos a ponérselo incluso

983
01:27:10,180 --> 01:27:13,000
¿Cómo hemos

984
01:27:13,000 --> 01:27:15,020
definido que una clase sea

985
01:27:15,020 --> 01:27:16,960
hija de una clase padre?

986
01:27:17,159 --> 01:27:18,600
Pues hemos utilizado el stents

987
01:27:18,600 --> 01:27:21,579
para los interfaces tenemos otra etiqueta

988
01:27:21,579 --> 01:27:22,600
en la clase

989
01:27:22,600 --> 01:27:25,060
vamos a decir hija de momento, aunque

990
01:27:25,060 --> 01:27:27,239
el tema hijo y padre está relacionado con la herencia

991
01:27:27,239 --> 01:27:29,899
y no con los interfaces, que es la etiqueta implement.

992
01:27:31,260 --> 01:27:33,760
Y aquí es donde ponemos el nombre del interfaz.

993
01:27:33,880 --> 01:27:36,979
Hemos dicho que el interfaz se llamaba trabajador.

994
01:27:37,300 --> 01:27:40,300
Entonces decimos, implementa el interfaz trabajador.

995
01:27:41,560 --> 01:27:44,060
Y en el momento, aparte de la herencia que hemos dicho

996
01:27:44,060 --> 01:27:49,840
que implementa un interfaz, lo que nos obliga es que metamos

997
01:27:49,840 --> 01:27:51,960
los métodos que no están implementados.

998
01:27:51,960 --> 01:27:55,739
fijaros como me obliga a meter el método fichar

999
01:27:55,739 --> 01:27:59,520
y el método cobrar. ¿Qué es lo que hemos conseguido con un interfaz?

1000
01:27:59,600 --> 01:28:03,199
Pues hemos firmado un acuerdo, como habíamos hecho antes

1001
01:28:03,199 --> 01:28:07,939
en la parte de la herencia para los métodos que eran abstractos

1002
01:28:07,939 --> 01:28:12,100
de la clase persona, al ponerlo abstracto este método y no poner su código

1003
01:28:12,100 --> 01:28:16,159
firmamos un acuerdo ahí para que las clases

1004
01:28:16,159 --> 01:28:19,819
hijas obligatoriamente tuvieran que implementar esos métodos, el despedir

1005
01:28:19,819 --> 01:28:34,619
A través de la herencia. Si lo que definimos es una interfaz, los interfaces se parecen a las clases abstractas un poquito en tanto en cuanto define un conjunto de métodos que son todos abstractos, no nos deja implementar ninguno.

1006
01:28:34,619 --> 01:28:58,020
Es decir, es un acuerdo puro y duro en el cual se definen una serie de métodos abstractos, no desarrollamos ninguno, en ninguno decimos cómo se tiene que comportar alguien que pretenda ser un trabajador, pero sí decimos que todo aquel que implemente el interfaz trabajador tendrá dentro de su código que meter este método y desarrollarlo, de la misma forma que tiene que hacer con el método cobrar.

1007
01:29:02,159 --> 01:29:06,000
Entonces ahora el alumno hereda de la clase persona lo que herede,

1008
01:29:06,619 --> 01:29:10,000
si tiene la clase persona algún método abstracto lo tiene que desarrollar

1009
01:29:10,000 --> 01:29:16,579
y dice que implementa la clase trabajador, el interfaz trabajador,

1010
01:29:16,579 --> 01:29:19,539
con lo cual tiene obligatoriamente que desarrollar todo esto.

1011
01:29:20,220 --> 01:29:25,920
Imaginamos que tenemos un proyecto grandote y se pretende que todo aquel

1012
01:29:25,920 --> 01:29:29,520
que sea considerado en un momento dado un trabajador, es decir,

1013
01:29:29,520 --> 01:29:33,060
implemente esta interfaz, desde diferentes sitios del código

1014
01:29:33,060 --> 01:29:36,220
se le podrá llamar a un método fichar y un método cobrar.

1015
01:29:37,340 --> 01:29:40,939
Un alumno, que en un momento dado puede ser un trabajador, si no le pongo esto

1016
01:29:40,939 --> 01:29:45,399
y le implemente este, no estoy firmando un acuerdo con nadie, pues podría coger

1017
01:29:45,399 --> 01:29:49,579
y no implementar el método cobrar. Y si luego desde clases por ahí terceras

1018
01:29:49,579 --> 01:29:52,159
alguien dice, como es un alumno y el

1019
01:29:52,159 --> 01:29:57,380
diseño general, un requisito general del proyecto es que

1020
01:29:57,380 --> 01:30:01,359
sea capaz de cobrar, pues dice, pues vale, pues si me han dicho que los alumnos

1021
01:30:01,359 --> 01:30:04,979
en el diseño general del proyecto pueden cobrar, voy a llamar al método cobrar.

1022
01:30:05,180 --> 01:30:09,420
Y resulta que si no le he obligado a través de una firma que he hecho ahí

1023
01:30:09,420 --> 01:30:13,420
con una interfaz a que lo implemente, he podido, yo que soy

1024
01:30:13,420 --> 01:30:17,199
el programador de esta clase en particular, no desarrollarlo. Entonces coge y no me compila

1025
01:30:17,199 --> 01:30:21,279
el programa por otros lados. En cambio, si he llegado al acuerdo de que los

1026
01:30:21,279 --> 01:30:24,739
alumnos puedan llegar a ser trabajadores,

1027
01:30:24,739 --> 01:30:27,899
pues lo que hago es implementar el interfaz

1028
01:30:27,899 --> 01:30:30,699
trabajador que no dice cómo hacer nada

1029
01:30:30,699 --> 01:30:33,880
pero me obliga a que los alumnos tengan aquí

1030
01:30:33,880 --> 01:30:36,479
un código para que pueda ser llamado

1031
01:30:36,479 --> 01:30:39,579
a través del método cobrar o a través del método fichar. Entonces aquí

1032
01:30:39,579 --> 01:30:42,460
pondremos qué es lo que tiene que pasar cuando un alumno

1033
01:30:42,460 --> 01:30:44,899
pues tiene que cobrar, pues yo que sé, que le tienen que dar una pasta

1034
01:30:44,899 --> 01:30:48,779
como debería ser. Entonces estos

1035
01:30:48,779 --> 01:30:51,720
son los interfaces. Mirad, sobre los

1036
01:30:51,720 --> 01:30:54,619
interfaces, otra cosa más. Vamos a definir un segundo

1037
01:30:54,619 --> 01:30:56,619
interfaz, aquí

1038
01:30:56,619 --> 01:31:03,989
yo que sé, vamos a llamarlo vacaciones

1039
01:31:03,989 --> 01:31:06,090
pues oye, vacaciones está bien

1040
01:31:06,090 --> 01:31:09,359
y definimos

1041
01:31:09,359 --> 01:31:11,659
un método public abstract

1042
01:31:11,659 --> 01:31:13,359
void

1043
01:31:13,359 --> 01:31:14,079
que sea

1044
01:31:14,079 --> 01:31:16,520
viajar

1045
01:31:16,520 --> 01:31:19,380
si intentara meter código aquí

1046
01:31:19,380 --> 01:31:21,420
por ser una interfaz, no me dejaría

1047
01:31:21,420 --> 01:31:23,119
simplemente digo que

1048
01:31:23,119 --> 01:31:24,899
todo aquel que

1049
01:31:24,899 --> 01:31:27,500
quiera implementar el interfaz

1050
01:31:27,500 --> 01:31:33,619
vacaciones que se esté obligando en su cabecera a través del interfaz vacaciones tendrá que hacer

1051
01:31:33,619 --> 01:31:41,699
un desarrollo del método viajar y luego pues vamos a poner otro método publicastrat void disfrutar

1052
01:31:41,699 --> 01:31:46,880
vale pues también si oye si coge vacaciones olvídate de irte a aburrirte tienes que irte a

1053
01:31:46,880 --> 01:31:54,600
disfrutar decimos cómo es el código cualquiera de estos dos métodos 2 3 4 5 20 o 1 no porque

1054
01:31:54,600 --> 01:32:06,359
Porque es una interfaz. Y además, fijaros que aquí, aunque sea un poco pesado, cuando estamos de vacaciones también tenemos que fichar.

1055
01:32:06,579 --> 01:32:13,079
No sé buscar un contexto real en el que tengamos que fichar, pero también vamos a poner fichar aquí en vacaciones.

1056
01:32:13,739 --> 01:32:18,399
Alguien que implemente el interfaz vacaciones tiene que viajar, disfrutar y fichar.

1057
01:32:18,520 --> 01:32:22,979
Y alguien que implemente el interfaz trabajador tiene que fichar y cobrar.

1058
01:32:22,979 --> 01:32:26,520
bueno, venimos aquí a la clase alumno

1059
01:32:26,520 --> 01:32:29,600
que hereda de la clase persona y ya está implementando

1060
01:32:29,600 --> 01:32:32,560
trabajador y ponemos aquí una coma y decimos

1061
01:32:32,560 --> 01:32:35,119
que también implementa el interfaz vacaciones

1062
01:32:35,119 --> 01:32:38,319
ha dejado de compilarme, ¿por qué? pues porque

1063
01:32:38,319 --> 01:32:41,359
vacaciones tiene aquí, firma un contrato con el

1064
01:32:41,359 --> 01:32:44,319
interfaz vacaciones que tenemos que tener

1065
01:32:44,319 --> 01:32:47,479
código desarrollado para estos tres métodos y resulta

1066
01:32:47,479 --> 01:32:50,439
oye, pues que no, que es que ahora mismo no tengo

1067
01:32:50,439 --> 01:32:53,359
tengo fichar, cobrar, que son los de trabajar. Fichar coincide

1068
01:32:53,359 --> 01:32:56,579
con el trabajar, pero vacaciones tiene aquí definidos

1069
01:32:56,579 --> 01:32:58,460
dos que todavía no están implementados.

1070
01:32:59,380 --> 01:33:02,319
Entonces, vengo aquí y me dice

1071
01:33:02,319 --> 01:33:05,600
que añada los métodos

1072
01:33:05,600 --> 01:33:08,319
no implementados. Aparecen aquí

1073
01:33:08,319 --> 01:33:11,079
disfrutar, viajar, con el override, porque estoy

1074
01:33:11,079 --> 01:33:13,939
sobrescribiendo desde la interfaz y ya me compila.

1075
01:33:16,229 --> 01:33:18,970
¿Y a dónde he querido llegar al meter dos interfaces?

1076
01:33:19,390 --> 01:33:21,869
Pues, ¿qué os decía antes de la herencia?

1077
01:33:22,010 --> 01:33:37,630
Una clase en Java, hay algún lenguaje que lo gestiona como sea, hace yo creo recordar, Java solamente permite herencia desde una clase padre. ¿Por qué? Pues porque en las clases padres podemos tener métodos con el mismo código.

1078
01:33:37,630 --> 01:33:52,689
Entonces se produce una situación de que si llamamos a ese método no va a saber de qué clase padre si hereda E2 coger el método, el comportamiento que tiene que tener a la hora de ejecutarse para desarrollar ese método.

1079
01:33:53,029 --> 01:34:06,630
En cambio, la implementación, si os fijáis, más allá de la herencia esta que os decía de algunos métodos comunes para todas las clases, desde la clase Object que está en la parte de arriba del árbol de todas las clases en Java.

1080
01:34:06,630 --> 01:34:22,050
Pero, en cambio, la implementación sí me permite implementar dos interfaces diferentes y podríamos decir, pero claro, si tienes el mismo método definido en dos interfaces, ¿cuál de los dos interfaces considera?

1081
01:34:22,050 --> 01:34:39,949
Pero, claro, los interfaces, que es el caso, el interfaz trabajador tiene fichar y el interfaz vacaciones tiene fichar. Es decir, se da esa situación que nos impedía la herencia múltiple en Java.

1082
01:34:39,949 --> 01:34:55,470
Pero como fichar no lo tenemos desarrollado de cómo se tiene que comportar, no tenemos ningún problema. Hemos firmado por dos lados que la clase alumno va a tener que implementar, va a tener que desarrollar el método fichar, lo hemos firmado por dos lados.

1083
01:34:55,470 --> 01:34:57,470
pero como no tenemos compromiso

1084
01:34:57,470 --> 01:34:59,390
de comportarnos de ninguna de las formas

1085
01:34:59,390 --> 01:35:00,930
desde ninguno de los dos interfaces

1086
01:35:00,930 --> 01:35:03,470
el único método

1087
01:35:03,470 --> 01:35:05,510
fichar que de verdad desarrollamos

1088
01:35:05,510 --> 01:35:07,210
es decir, el comportamiento no tiene

1089
01:35:07,210 --> 01:35:08,970
ambigüedades, es este, por mucho

1090
01:35:08,970 --> 01:35:11,270
que este fichar se nos esté

1091
01:35:11,270 --> 01:35:12,909
obligando a tenerlo desarrollado

1092
01:35:12,909 --> 01:35:15,189
desde dos interfaces distintos, en cambio

1093
01:35:15,189 --> 01:35:17,449
cobrar solamente desde uno, pero no me importa

1094
01:35:17,449 --> 01:35:19,489
el código es único, no hay ambigüedades

1095
01:35:19,489 --> 01:35:20,590
oye, pues te dejo

1096
01:35:20,590 --> 01:35:23,130
que implementes más de una interfaz

1097
01:35:23,130 --> 01:35:27,270
¿Sí? ¿Se entiende?

1098
01:35:31,739 --> 01:35:32,640
¿Alguna cosilla por ahí?

1099
01:35:39,529 --> 01:35:40,090
¿No?

1100
01:35:42,130 --> 01:35:47,569
Pues, bueno, el tema, como comentabais, el tema 7 es bien largo,

1101
01:35:48,710 --> 01:35:51,930
pero las ideas así principales que os quería contar eran un poco estas.

1102
01:35:52,409 --> 01:35:58,869
La sobrecarga, la encasulación, la sobrescritura, las clases abstractas,

1103
01:35:58,930 --> 01:36:01,569
los interfaces, que no es cosa de poco.

1104
01:36:01,850 --> 01:36:05,630
Luego, hasta que consiguierais digerir un poquillo todo esto que os he contado hoy,

1105
01:36:06,449 --> 01:36:19,430
Vais a tener que echar algún ratín. Si no tenéis alguna duda por ahí en particular, yo en principio no os quería contar mucho más por hoy, por no marearos más tampoco en exceso.

1106
01:36:19,430 --> 01:36:59,989
No sé si tenéis alguna duda de todo lo que hemos visto, de alguna otra cosa. Hay dos situaciones. Un poco el concepto entre clase, padre e interfaz.

1107
01:36:59,989 --> 01:37:15,250
Pues lo que os he comentado, la clase padre te permite tener desarrollado algunos métodos y algunos abstractos, algunos que le obligas a firmar el contrato de tienes que implementarlo.

1108
01:37:15,250 --> 01:37:39,069
Las interfaces no tienes desarrollado ninguno. Es así. Y luego, la herencia, claro, la herencia te resulta muy útil porque puedes utilizar ya código que tienes disponible en la clase padre, mientras que a la hora de implementar los interfaces tienes que desarrollar obligatoriamente los métodos.

1109
01:37:39,069 --> 01:37:45,949
pero tienes el inconveniente de que la herencia es única

1110
01:37:45,949 --> 01:37:53,050
entonces si tú te ves en la situación de que el alumno en verdad en su definición general

1111
01:37:53,050 --> 01:37:56,810
pues tiene que tener las características que tienen las personas

1112
01:37:56,810 --> 01:38:02,010
pero además quieres obligar a que cumpla todo lo que tienen que hacer los trabajadores

1113
01:38:02,010 --> 01:38:22,210
En las vacaciones, pues tienes que elegir uno como obligatoriamente, uno como clase padre y el resto como interfaces, porque como no nos permite herencia múltiple, si nos permite herencia múltiple, nos olvidábamos de este implements y poníamos esto aquí, poníamos estas clases abstractas y las desarrollábamos.

1114
01:38:22,210 --> 01:38:48,039
Pero como no es posible hacer herencia desde diferentes clases, obligatoriamente tienes que hacerlo así. ¿Cuál puedes utilizar de, yo qué sé, en este caso, a ver, a ver, claro, por ejemplo, según el criterio que utilizábamos antes, decíamos, ¿un alumno es una clase de persona?

1115
01:38:48,039 --> 01:39:05,939
Y decíamos, sí, ¿os acordáis para la composición y la herencia? ¿Un alumno es una clase de trabajador? Sí. ¿Un alumno es una clase de vacaciones? Pues vacaciones, quedaría un poco raro la herencia de vacaciones, ¿sabes? También, porque no responde un poco a esta pregunta que nos identifica la relación de herencia.

1116
01:39:05,939 --> 01:39:21,340
En definitiva, tendrías que elegir una de ellas como clase padre, aquella que te proporcione más código que utilizar desde los métodos que tiene desarrollados y las otras tendrías que utilizarlas como interfaces.

1117
01:39:21,340 --> 01:39:29,779
No recuerdo exactamente cómo lo argumentan en el código. Si me das una pista, a lo mejor te puedo...

1118
01:39:32,800 --> 01:39:46,119
El concepto en líneas generales, si ahora un poco después de ver el concepto que os cuento, al leerlo de nuevo en el tema no lo entiendes,

1119
01:39:46,119 --> 01:39:52,439
pues pon en el foro una pregunta e intento aclarártelo, no sé, dentro de lo que sea capaz te lo intento aclarar, ¿vale?

1120
01:39:52,439 --> 01:40:07,180
Pero un poco la idea de base es esta, la herencia es única y te permite tener a tu disposición los métodos desarrollados y te obliga a implementar los abstractos.

1121
01:40:08,039 --> 01:40:16,239
Los interfaces directamente tienes que desarrollar todos y eso sí te permite definir diferentes interfaces,

1122
01:40:16,239 --> 01:40:36,140
Te permite definir diferentes firmas de, me comprometo a que si soy un alumno e implemento esta interfabia, te voy a disponer de estos métodos desarrollados para que desde otras zonas de código sean capaces de utilizarlos, porque si no he firmado ese contrato, compilaría la clase alumno directamente, aunque no tenga alguno de ellos, como es lógico.

1123
01:40:36,140 --> 01:40:44,520
Pero en el momento que pongo esto, ya no me va a compilar, a no ser que tenga todos esos métodos que son candidatos a ser llamador desde clases terceras desde el programa.

1124
01:40:44,520 --> 01:40:51,659
ya te digo, un poco con lo que os he contado

1125
01:40:51,659 --> 01:40:54,659
que vamos, desde mi punto de vista es como enfocar

1126
01:40:54,659 --> 01:40:56,239
la clase abstracta y las interfaces

1127
01:40:56,239 --> 01:40:59,760
si vuelves a releer el tema y no entiendes cosas

1128
01:40:59,760 --> 01:41:02,720
ponme una consulta ahí en el foro e intento aclararla

1129
01:41:02,720 --> 01:41:05,199
porque no me acuerdo, francamente no me acuerdo

1130
01:41:05,199 --> 01:41:08,699
como lo describe en el tema, esta parte

1131
01:41:08,699 --> 01:41:19,800
vale, bueno pues nada

1132
01:41:19,800 --> 01:41:22,539
si no me preguntáis nada más, vamos cerrando

1133
01:41:22,539 --> 01:41:25,239
os subo la

1134
01:41:25,239 --> 01:41:27,319
tutoría esta por si la queréis echar un ojillo

1135
01:41:27,319 --> 01:41:29,300
si os aburrís mucho y tenéis otro rato

1136
01:41:29,300 --> 01:41:31,159
para verla y bueno

1137
01:41:31,159 --> 01:41:33,300
para los compañeros que no hayan podido asistir a la

1138
01:41:33,300 --> 01:41:33,779
tutoría

1139
01:41:33,779 --> 01:41:37,039
la dejo ahora subiendo

1140
01:41:37,039 --> 01:41:39,079
y bueno la tendréis, si no se me olvida

1141
01:41:39,079 --> 01:41:41,140
como la semana pasada algún día y me lo tenéis que

1142
01:41:41,140 --> 01:41:43,220
recordar, luego esta noche o mañana por la mañana

1143
01:41:43,220 --> 01:41:45,239
os la pongo ya disponible el enlace

1144
01:41:45,239 --> 01:41:46,060
en el aula virtual

1145
01:41:46,060 --> 01:41:51,300
Bueno, pues buena tarde a todos

1146
01:41:51,300 --> 01:41:52,760
Venga, hasta luego