Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 19-02-24 - 1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 26 de febrero de 2024 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues lo último que hemos visto, como bien recordáis, es la herencia y sus implicaciones, ¿vale? 00:00:00
Entonces, ¿la herencia qué era? 00:00:13
Pues es la posibilidad de relacionar unas clases con otras mediante una relación del tipo, esto es esta otra cosa. 00:00:18
Un alumno es miembro del instituto, un cliente temporal es cliente, un gato es animal. 00:00:27
Entonces, si yo tengo entidades distintas, pues como gato, perro, cliente temporal, empleado temporal, empleado plantilla, 00:00:37
tengo diferentes entidades 00:00:48
y por tanto tengo que hacer clases distintas 00:00:50
pero identifico 00:00:52
que todas comparten algo 00:00:54
pues entonces ahí identifico 00:00:56
una relación de herencia, puedo identificarla 00:00:58
y trabajar haciendo el diseño de mis clases 00:01:00
completamente independientes unas de otras 00:01:02
claro, como hemos dicho muchas veces hay muchos 00:01:04
diseños posibles, pero la idea 00:01:06
es hacerlos lo más eficiente 00:01:08
que se pueda 00:01:10
entonces si yo identifico que hay clases 00:01:11
que comparten cosas 00:01:14
como empleado temporal, empleado plantilla 00:01:15
Comparten cosas, aunque algunas son distintas 00:01:18
Pues identifico que lo comparten 00:01:21
Me puedo hacer una superclase que coge lo común 00:01:22
Empleado, por ejemplo 00:01:26
Y las otras dos heredan todo lo común de esa 00:01:27
Y añaden lo suyo 00:01:31
Entonces, el haber establecido esa jerarquía 00:01:33
Una superclase de las cuales heredan 00:01:38
Tiene algunas ventajas 00:01:40
¿Qué ventaja? 00:01:42
¿Qué ventaja en realidad? 00:01:45
Pues sobre todo la que más podemos ver 00:01:46
la que más podemos visualizar es 00:01:48
que ahora ya cuando yo tenga un almacén 00:01:49
de empleados, un array de empleados 00:01:52
una colección, un conjunto de empleados 00:01:54
los puedo 00:01:56
meter todos juntos 00:01:57
porque todos son empleados 00:01:59
¿vale? todos son empleados 00:02:01
los puedo meter todos juntos en el mismo array 00:02:03
eso es lo que hemos visto 00:02:05
nosotros de forma palpable 00:02:07
que es nuestra ventaja 00:02:08
que los puedo meter todos en el mismo array 00:02:10
en realidad, porque si yo tengo una referencia 00:02:12
empleado E 00:02:15
esa referencia se puede llenar en un momento dado 00:02:16
con un empleado temporal, porque hereda 00:02:19
pero también se puede rellenar en otro 00:02:20
momento dado con un empleado plantilla 00:02:23
porque hereda, entonces eso me da 00:02:25
una flexibilidad 00:02:27
yo declaro la referencia 00:02:28
de una superclase 00:02:31
pero luego puedo meter en ella lo que me interese 00:02:32
entonces eso hace que el código 00:02:35
sea un poquito más eficiente 00:02:39
porque si yo 00:02:40
cambio algo 00:02:43
del empleado temporal 00:02:44
lo cambio solo en la clase 00:02:46
empleado temporal, no en la superclase 00:02:49
esa era más o menos 00:02:51
la idea 00:02:53
con esa idea ya vimos unos cuantos ejemplos 00:02:53
para ver eso como se podía utilizar 00:02:57
como se podía utilizar 00:02:59
de manera que nos facilitara las cosas 00:03:01
entonces la idea es que más o menos eso 00:03:02
pues lo tengáis en la cabeza 00:03:05
medio claro, entonces de ahí ya vino 00:03:07
todo el rollo del polimorfismo 00:03:09
de la sobrescritura de métodos 00:03:11
del instance of de todo ese rollo 00:03:13
que vimos ya a través de los ejercicios 00:03:15
¿vale? 00:03:17
bueno, pues entonces la herramienta de la herencia está muy bien 00:03:20
para hacer un diseño jerárquico 00:03:23
pero 00:03:25
se queda corta 00:03:27
ya lo previmos 00:03:28
en su momento, se queda corta 00:03:31
porque la herencia es 00:03:33
simple, en Java al menos 00:03:35
es simple, una clase 00:03:37
solo puede heredar de otra 00:03:39
solo puede heredar de otra 00:03:40
entonces, a lo mejor hay entidades 00:03:42
que son dos cosas a la vez 00:03:46
¿vale? por ejemplo 00:03:47
un diseño de clases 00:03:50
de un instituto 00:03:52
pues habría profesores interinos, profesores 00:03:53
de plantilla, alumnos 00:03:56
personal de secretaría 00:03:58
hay de todo 00:03:59
entonces uno tiene que decidir cómo organiza 00:04:01
esas clases, cómo las organiza 00:04:04
entonces si me terencia mejor 00:04:06
entonces pues a ver 00:04:08
un profesor interino 00:04:10
es profesor 00:04:12
con lo cual hereda de profesor 00:04:14
pero también es 00:04:16
también puede ser 00:04:18
poder representar otro papel 00:04:19
¿vale? 00:04:22
poder representar otro papel porque es 00:04:23
miembro del equipo directivo 00:04:26
por ejemplo, entonces hay una super clase que es 00:04:27
directivo que tiene 00:04:30
las características de los miembros del equipo directivo 00:04:32
entonces ese profesor interino 00:04:34
tiene que coger todo lo de 00:04:36
profesor y tiene que coger 00:04:38
todo lo de equipo directivo 00:04:40
¿Cómo lo hace? No puede 00:04:42
O es una cosa o es la otra 00:04:45
Es una limitación muy grande 00:04:46
Entonces 00:04:48
¿Hacemos que entonces profesor herede de equipo directivo 00:04:50
Y así profesor interino 00:04:54
A través de profesor hereda de equipo directivo? 00:04:55
No, porque estamos inventando 00:04:58
Esa relación, no todos los profesores 00:04:59
No todos heredan de equipo directivo 00:05:01
Entonces 00:05:04
Que la herencia sea simple 00:05:04
Es una limitación 00:05:06
Bueno, pues vamos a través de un ejemplo 00:05:09
motivar el tema de las interfaces que es muy sencillo 00:05:11
y son cuatro chorradas, nada más 00:05:13
bueno pues esto que 00:05:15
vamos a contar ahora 00:05:30
como no tengo 00:05:32
pizarra 00:05:34
si, pizarra tengo 00:05:40
es verdad, lo que no tengo es con que usarla 00:05:43
que todos los fines de semana se me voy a comprar 00:05:44
vale, pues 00:05:48
esto que vamos a 00:05:50
ver ahora se llama 00:05:53
interfaces 00:05:54
¿Vale? No lo confundáis 00:06:03
Con las interfaces gráficas 00:06:05
De usuario, eso es otra cosa 00:06:07
¿Vale? Eso es otra cosa, una interfaz gráfica 00:06:08
De usuario, ¿sabes lo que es? 00:06:11
Una forma de comunicarse con un programa 00:06:12
A través de ventanas, a través de gráficos 00:06:15
No a través de consola, ¿vale? 00:06:17
Esto es otra cosa, no lo confundáis 00:06:19
Esto que vamos a ver ahora son 00:06:20
Interfaces de Java, pero no gráficas 00:06:22
Interfaces de Java 00:06:25
Bueno, pues venga 00:06:27
Vamos a suponer que 00:06:28
En un ejemplito sencillo 00:06:31
Que es lo más fácil de entender 00:06:34
Pues por ejemplo con empleados 00:06:36
Vamos a poner aquí 00:06:38
Ejemplo interfaces 00:06:42
Empleados 00:06:43
Bueno pues resulta 00:06:51
Que en esta empresa 00:07:01
Para la que vamos a hacer esta aplicación 00:07:03
De gestión de los empleados de la empresa 00:07:05
Hay dos tipos de empleado 00:07:07
Empleado plantilla 00:07:09
Y empleado temporal 00:07:11
Lo más fácil de entender 00:07:11
vale, pues entonces si hay dos tipos de empleado 00:07:13
con información distinta 00:07:16
hay que hacer dos clases 00:07:18
porque son dos entidades 00:07:20
distintas que hemos identificado 00:07:22
empleado plantilla, empleado temporal 00:07:24
pero efectivamente después de hacer 00:07:26
el análisis de las propiedades 00:07:28
que caracterizan a cada empleado 00:07:30
hemos visto que muchas cosas son comunes 00:07:32
entonces como hemos visto 00:07:34
que muchas cosas son comunes hemos dicho 00:07:36
vale, pensamos, vamos a hacer 00:07:38
una clase empleado y que los dos 00:07:40
heredan de ella. Hasta aquí 00:07:42
el mismo proceso mental que con la herencia. 00:07:44
El mismo. 00:07:47
Estamos en la fase de diseño y decidimos 00:07:48
eso. Decidimos hacer 00:07:51
una superclase. 00:07:52
Decidimos 00:07:59
hacer una superclase empleado 00:08:00
con las propiedades comunes 00:08:02
que puedan ser, por ejemplo, 00:08:08
todos los empleados 00:08:15
sean de plantilla, sean de no sé qué, 00:08:16
tienen NIF, nombre y sueldo. 00:08:18
Entonces, como todos tienen NIF, nombre y sueldo, pues esto lo ponemos en empleado, silencio, y si hacemos lo habitual, pues haríamos un GET y un SET, que ya no lo sabemos de memoria, y habitualmente incorporaríamos también un constructor con parámetros para facilitar e instanciar el objeto ya con sus tres datos, etc. 00:08:28
Bueno, pues esta superclase se ha hecho simplemente para unificar 00:09:00
Unificar todo lo que tienen en común los empleados de plantilla 00:09:07
Y los empleados temporales, por ejemplo 00:09:11
Pues venga, entonces 00:09:14
Ahora ya haríamos 00:09:17
Vale, el empleado plantilla, pues por ejemplo 00:09:20
Necesita 00:09:36
De él necesitamos saber 00:09:37
Fecha de ingreso 00:09:40
Entonces pues yo que sé, podríamos poner aquí 00:09:42
Date 00:09:46
Pues de Java útil, Java time 00:09:59
De donde, Java útil 00:10:02
Por ejemplo 00:10:03
Pero vamos 00:10:05
Esto es solo para ver un ejemplo de diseño 00:10:07
No vamos a utilizar estas clases ni nada 00:10:10
Solo 00:10:11
Pues nada, aquí incorporaríamos solamente 00:10:12
El getDLSet 00:10:15
de la propiedad que falta 00:10:17
bueno, espera 00:10:19
nos falta el extens 00:10:20
aquí diríamos 00:10:22
oye, que este empleado 00:10:25
de plantilla es empleado 00:10:26
también, entonces tiene las 00:10:29
tres propiedades de empleado y además 00:10:30
tiene una fecha de ingreso 00:10:33
propia solo de los de plantilla 00:10:34
pues nada, pondríamos los get y set 00:10:36
vale, no hago 00:10:39
no voy a hacer todos los constructores y todo 00:10:50
Porque esto no es, no vamos a trabajar con ellos 00:10:52
Es solamente para ver el diseño que nos quedaría 00:10:55
Si incorporamos interfaces 00:10:57
Entonces, bueno 00:10:58
No pongo el constructor con parámetros 00:10:59
Entonces, en esta fase de diseño 00:11:02
En la que estamos 00:11:05
Hemos identificado que también tenemos 00:11:06
Empleados temporales 00:11:08
Vale 00:11:10
Pues este empleado temporal sería también 00:11:20
Empleado 00:11:23
Vale, y el empleado temporal 00:11:27
pues bueno, añade yo que sé, cualquier propiedad 00:11:33
nos da igual, pues el empleado 00:11:35
temporal 00:11:37
perdón, no te he oído 00:11:37
ala, venga 00:11:41
le ponemos la fecha en la que 00:11:43
se acaba, por poner 00:11:45
algo 00:11:47
fecha fin de contrato 00:11:47
ya está 00:11:53
y el get y el set que le falta 00:11:57
bueno 00:12:06
y llegados a este punto 00:12:13
pues bueno, ya uno podría hacer una aplicación 00:12:17
de gestión con un main 00:12:18
en el cual trabaje con objetos empleado 00:12:20
y claro, tendrá que haber 00:12:23
establecido unos requisitos, ¿qué va a hacer mi aplicación? 00:12:26
pues mi aplicación con los empleados va a hacer 00:12:29
pues esto, lo otro, ¿qué pueden hacer los empleados? 00:12:31
pues los empleados temporal 00:12:35
y plantilla, cualquier empleado 00:12:37
por ejemplo, ¿qué funcionalidad pueden tener todos ellos? 00:12:40
pues generar nómina, por ejemplo 00:12:43
generar nómina, bueno pues entonces 00:12:46
Entonces ese método lo podríamos poner aquí, un método public string generar nómina, ¿vale? Entonces como la nómina de los empleados temporales y de plantillas es distinta, se genera de forma distinta, en la clase empleado lo dejaríamos así, ¿vale? 00:12:49
Ese es un diseño que estamos haciendo dentro de todos los posibles. 00:13:17
Entonces, al dejarlo así, abierto, porque generar nómina depende del tipo de empleado, 00:13:19
al dejarlo así lo convertimos en un método abstracto. 00:13:26
Entonces, al convertirlo en un método abstracto, lo identificamos así, ¿vale? 00:13:30
Y al ser un método abstracto, automáticamente la clase se nos convierte en clase abstracta. 00:13:46
y no pasa nada 00:13:53
porque se convierta en clase abstracta 00:14:01
silencio los de atrás 00:14:03
lo que pasa al convertirse en clase abstracta 00:14:05
simplemente es 00:14:09
que, que implicaciones tiene 00:14:11
que hayamos convertido empleado en clase abstracta 00:14:13
que implicaciones tiene 00:14:15
Moisés 00:14:17
no lo sabes 00:14:18
estas partes 00:14:21
pues estas partes son unas partes muy importantes 00:14:24
porque te voy a aseminar de ellas en dos semanas 00:14:27
Diego, estas partes de herencia 00:14:28
¿qué implicación tiene haberla convertido en abstracta? 00:14:32
la única que tiene 00:14:37
a ver, Daniel 00:14:39
¿qué implicación tiene haber convertido esta clase en abstracta? 00:14:40
que ya no se puede 00:14:50
¿ya no se pueden? 00:14:50
no, que ya no se pueden crear objetos empleados 00:14:54
cuando no era abstracta 00:15:00
Yo podría instanciar un objeto empleado 00:15:03
y también un objeto empleado de plantilla 00:15:05
y también un objeto empleado temporal. 00:15:07
Podría instanciar de los tres tipos. 00:15:09
Entonces, un objeto empleado genérico 00:15:11
yo podría instanciarlo. 00:15:13
Si yo quiero tener un objeto que sea un empleado 00:15:15
y que no tenga los datos adicionales 00:15:17
ni de plantilla ni de temporal, podría. 00:15:19
Al hacerla abstracta, 00:15:22
ya no se pueden instanciar objetos empleados. 00:15:24
No se pueden. 00:15:26
Yo no podría hacer nunca un new empleado. 00:15:27
Aunque tenga constructor aquí, los tiene. 00:15:30
pero en realidad nunca voy a poder hacer un new empleado 00:15:33
porque es abstracta 00:15:36
el que tenga los constructores 00:15:37
ahora mismo ya para lo único que vale 00:15:40
es que desde las herederas 00:15:41
yo los puedo llamar con super 00:15:43
para servirme de ellos 00:15:45
para hacer los propios constructores de las herederas 00:15:47
es para lo único que valen ahora esos constructores 00:15:49
para que las herederas 00:15:52
los usen con super para construir 00:15:53
los suyos propios llamando al de arriba 00:15:55
y ahorrándose código 00:15:57
pero ya no valen para nada más 00:15:58
porque esta clase se ha convertido en abstracta y no se puede instanciar 00:16:00
entonces que no se puedan instanciar objetos de esta clase 00:16:03
no pasa nada 00:16:05
porque me está sirviendo a nivel de código 00:16:07
como plantilla 00:16:10
me está sirviendo como plantilla 00:16:11
para ahora las herederas 00:16:13
trabajar como si hubiera hecho un corta y pega 00:16:16
lo de arriba hasta abajo 00:16:21
entonces me está sirviendo como plantilla de código 00:16:22
y todo lo que herede de ahí es como haber hecho un copia y pega 00:16:24
entonces una clase abstracta 00:16:27
me sirve 00:16:29
me es útil en tiempo de desarrollo 00:16:30
de escritura de código, me sirve para unificar 00:16:32
código, lo que yo ponga ahí 00:16:34
es como si lo estuviera tecleando directamente 00:16:36
en las herederas, me vale para eso 00:16:38
una clase abstracta 00:16:40
pero nunca voy a instanciar de ella 00:16:42
en tiempo de ejecución, esa clase no 00:16:44
existe, no vale para nada, en tiempo de ejecución 00:16:46
nunca voy a poder instanciar objetos en pleno 00:16:49
¿vale? pero para 00:16:50
lo que es la escritura de código me es muy útil 00:16:52
porque yo en las herederas 00:16:54
ya tengo todo lo de la superclase abstracta 00:16:56
¿vale? 00:16:59
bueno, pues entonces 00:17:00
la clase abstracta 00:17:02
al fijarme este método 00:17:04
ahora que ocurre en las herederas 00:17:06
al haber fijado yo este método 00:17:08
así abstracto 00:17:11
automáticamente se me ha puesto rojillo 00:17:11
aquí 00:17:14
en las herederas que antes no estaba 00:17:15
¿por qué? 00:17:18
claro, ahora ya 00:17:21
si el método de la superclase es abstracto 00:17:22
y tú heredas 00:17:25
tienes que darle cuerpo a ese método 00:17:26
tienes que dárselo obligatoriamente 00:17:29
Si tú heredas de una clase abstracta con métodos abstractos, lo tienes que decir. 00:17:30
Entonces, esa es otra utilidad de la clase abstracta, que está obligando, forzando a sus herederas, 00:17:36
está forzando a que se comprometan en un comportamiento. 00:17:43
Dile, vale, tú hereda de mí, yo este método lo dejo en blanco porque no sé cómo lo vas a hacer, 00:17:48
pero te obligo a que especifiques cómo vas a hacerlo. 00:17:54
¿vale? te obligo a que lo especifique 00:17:57
si tiene sentido, tiene sentido en el diseño 00:18:00
de clases, que si tú quieres ser empleado 00:18:02
vale, tú sé empleado 00:18:04
pero entonces dime cómo vas a 00:18:06
generar la nómina, dímelo, porque si no 00:18:08
no seas empleado, tiene sentido 00:18:10
que el diseño funcione así 00:18:12
bueno, pues efectivamente 00:18:13
empleado plantilla 00:18:15
pues 00:18:17
sobrescribiría 00:18:18
obligatoriamente 00:18:22
el método generar nómina 00:18:23
con lo que fuera 00:18:26
con lo que fuera 00:18:28
aquí nos da un poco igual 00:18:31
vale 00:18:38
ojo eh, esto 00:18:47
y lo mismo 00:18:49
el empleado 00:18:52
temporal 00:18:53
tiene que sobrescribir esto 00:18:55
vale 00:18:58
pues nada 00:19:02
sobrescribiría también 00:19:04
su generar nómina 00:19:08
bueno pues nada, la aplicación 00:19:10
ahí ya está funcionando, uno 00:19:17
hace su main con los requisitos que haya que hacer 00:19:19
mete los métodos en las 00:19:21
clases de empleado temporal, empleado 00:19:23
plantilla para que hagan 00:19:25
las funcionalidades que tienen que hacer, ya 00:19:27
lo que sea, lo que la aplicación me pida hacer con estos 00:19:29
empleados, vale 00:19:31
luego la aplicación va creciendo 00:19:33
aparece 00:19:37
uy he puesto dos return 00:19:39
y aparece otro tipo de empleado 00:19:40
empleado 00:19:46
vamos a llamarle empleado externo 00:19:48
empleado externo es un empleado que te viene 00:19:49
de una empresa que te lo has subcontratado 00:19:52
no es temporal tuyo, pero lo has subcontratado tú 00:19:54
es un empleado externo 00:19:55
rápidamente vamos a suponer que hacemos un empleado externo 00:19:57
por aquí 00:20:00
y me sobra un punto y coma 00:20:00
efectivamente 00:20:04
tenemos aquí el empleado externo 00:20:05
que también es un empleado 00:20:18
se tiene que caracterizar 00:20:20
por su nombre, nif y sueldo 00:20:23
también es un empleado, pues no pasa nada 00:20:24
yo lo incorporo 00:20:26
lo incorporo a mi jerarquía 00:20:28
¿vale? este me ha llegado 00:20:30
como 00:20:32
mantenimiento 00:20:32
de la aplicación, la aplicación 00:20:35
estaba funcionando, lleva ya un año funcionando 00:20:38
y ahora en mi empresa se incorpora 00:20:40
esta posibilidad, bueno pues yo 00:20:42
mantengo la aplicación incorporándole 00:20:44
esto, digo no pasa nada, me hago 00:20:46
otra nueva entidad, empleado externo que también 00:20:48
hereda de empleado, pues muy bien 00:20:50
¿vale? 00:20:52
hereda de empleado tendrá pues por ejemplo 00:20:54
su propiedad adicional 00:20:56
Nombre de la empresa por la que viene 00:20:57
Por ejemplo, yo que sé 00:21:01
Cualquier chorrada, no nos importa 00:21:02
Y también necesita generar su nómina 00:21:05
Porque si era de empleado 00:21:09
Todos los empleados tienen que generar su nómina 00:21:10
Pues venga, nómina externa 00:21:13
Por ejemplo 00:21:25
Vale, bueno, aquí en condiciones normales 00:21:26
Pues haríamos el get y el set 00:21:36
Vamos a hacerlo para que no parezca que 00:21:37
Que pasamos de ellos 00:21:39
vale, pues 00:21:44
ahora 00:21:46
resulta que aparece una nueva capacidad 00:21:48
de la empresa, resulta que 00:21:50
la empresa pues dice, a ver 00:21:52
una funcionalidad nueva, yo tengo 00:21:53
la potestad de despedir 00:21:56
despedir 00:21:58
y cuando despida tengo que 00:22:00
hacer una acción concreta, por ejemplo 00:22:01
generar finiquito, vale 00:22:04
pues es una nueva funcionalidad de la aplicación 00:22:05
generar finiquito 00:22:08
vale, pero eso, quienes lo hacen 00:22:09
solamente lo hacen los empleados 00:22:12
temporales y externos 00:22:14
porque no puedo despedir a los de plantilla 00:22:16
entonces ahí ya 00:22:18
entra algo que tengo que ver 00:22:20
cómo lo incorporo 00:22:22
de manera que quede bonito, que quede claro 00:22:23
que quede un diseño decente en la aplicación 00:22:26
entonces 00:22:28
se traduce en que tengo que meter ahí 00:22:29
un método nuevo, un comportamiento 00:22:32
nuevo, pero sólo 00:22:34
para dos entidades, para empleado externo 00:22:35
y temporal 00:22:38
entonces bueno, vale 00:22:39
Pues yo podría decir, bueno, pues esa funcionalidad nueva, 00:22:43
generar finiquito, la pongo en empleado externo dentro 00:22:46
y la pongo en empleado temporal dentro. 00:22:50
Y ya está. 00:22:53
Y en empleado plantilla no la pongo. 00:22:53
Vale, bueno, sería una solución. 00:22:56
Por un lado estamos poniendo el mismo método, 00:22:59
aunque sea con cuerpo distinto, el mismo método, 00:23:03
el mismo nombre, lo estamos poniendo en dos clases distintas. 00:23:05
Entonces eso ya nos suena como a que, oye, 00:23:09
tú no puedes unificar esto 00:23:10
de alguna manera con herencia o algo así 00:23:12
tenemos esta herramienta 00:23:14
que queremos usarla precisamente para eso 00:23:17
para unificar todo lo que 00:23:18
compartan diferentes clases 00:23:21
no podríamos, pero claro que tenemos un problema 00:23:22
que no podemos poner 00:23:25
generar finiquito en empleado 00:23:26
porque sería un mal sitio 00:23:28
porque entonces se le daría 00:23:31
generar finiquito los tres tipos 00:23:33
hombre, podría 00:23:34
decir, vale, no pasa nada, lo pongo ahí 00:23:36
y el empleado plantilla simplemente 00:23:38
ese método nunca lo va a llamar 00:23:40
vale, nunca lo va a llamar, pero es que 00:23:42
queda un diseño horrible, porque entonces tú tienes 00:23:44
el que esté usando estas clases 00:23:46
verá empleado plantilla y dirá, anda, tiene un método 00:23:48
general finiquito, ¿y por qué tiene un método general finiquito? 00:23:50
entonces eso ya es una aplicación fea 00:23:52
no debería tener ese método 00:23:54
ese método solo deberían tener los objetos 00:23:55
empleado plantilla, empleado temporal y empleado externo 00:23:57
entonces 00:24:00
como que no acabamos de ver claro 00:24:01
cómo incluir eso 00:24:03
esa funcionalidad que solo afecta 00:24:06
a dos de nuestras tres entidades 00:24:08
claro, aquí la solución sería 00:24:11
hombre, y si yo me hago otra superclase 00:24:14
otra superclase 00:24:17
que sea empleado despedible 00:24:18
por ejemplo, yo que sé 00:24:20
entonces, empleado 00:24:22
temporal heredaría 00:24:24
de empleado normal y de empleado despedible 00:24:26
empleado plantilla 00:24:28
solo de empleado normal 00:24:30
y empleado externo heredaría 00:24:32
de empleado normal 00:24:34
Y de empleado despedible 00:24:36
Eso sería lo ideal 00:24:38
Pero no podemos 00:24:39
Porque cada clase solo puede heredar de otra 00:24:41
No puede heredar de dos 00:24:44
Entonces la solución ideal sería esa 00:24:45
Hacer dos plantillas 00:24:47
La plantilla empleado tal y como la tenemos 00:24:49
Y la plantilla empleado despedible 00:24:51
Y que luego 00:24:54
Nuestras tres entidades 00:24:55
Empleado, plantilla, temporal y externo 00:24:57
Elijan de quien heredan 00:25:00
Y si quieren heredar de las dos 00:25:02
Pues de las dos 00:25:03
Esa es la solución ideal 00:25:04
Y así se queda, cada entidad se queda 00:25:05
Si necesita de las dos, se queda con las dos 00:25:08
Si necesita de una sola, se queda con una 00:25:10
Esa sería la solución ideal, pero no podemos 00:25:12
Porque, como hemos dicho muchas veces 00:25:13
En Java no podemos ir a dar de dos 00:25:15
Vale, pues entonces viene 00:25:17
El truco, el parche 00:25:18
De las interfaces 00:25:21
Vale, pues me voy a hacer una cosa 00:25:22
Que se llama interfaz 00:25:25
Que una interfaz en realidad 00:25:27
Como si fuera una clase 00:25:31
Con todos los métodos abstractos o vacíos 00:25:33
¿Vale? 00:25:36
Una interfaz 00:25:38
La podéis ver 00:25:38
Como una clase 00:25:39
Que tiene todos sus métodos abstractos 00:25:41
Eso sería 00:25:44
Vamos a escribirlo aquí 00:25:46
Para que viéndolo se nos quede más 00:25:48
Es una clase 00:25:50
Con todos los 00:25:58
Métodos abstractos 00:26:00
¿Vale? 00:26:04
Bueno, así hasta cierta versión 00:26:07
Luego ya se permite una 00:26:08
Luego ya se van incorporando cosas 00:26:09
Que las iremos que nosotros también diciendo 00:26:11
¿Vale? Pero en origen, su esencia viene de ahí. 00:26:13
Una interfaz es una clase que tiene todos los métodos abstractos. 00:26:17
¿Vale? 00:26:20
Y las clases normales de Java lo que hacen es heredar de ella, 00:26:22
pero en este caso no se llama heredar. 00:26:29
En este caso se llama implementar. 00:26:31
Lo que hacen es implementarla. 00:26:33
Es decir, dan cuerpo a sus métodos. 00:26:36
Entonces, esta es la idea. 00:26:40
Pues, entonces, aquí en nuestra aplicación podríamos incorporar. 00:26:45
Vamos a incorporar ahora una interfaz empleado despedible. 00:26:49
Empleado despedible, para que recoja el comportamiento de los 00:26:55
empleados que pueden ser despedidos. 00:26:59
Pues, uno haría aquí una interfaz. 00:27:02
Entonces, despedible. 00:27:07
Despedible. 00:27:19
Vale, entonces, ¿cómo se programa, 00:27:22
cómo se declara una interfaz? 00:27:25
pues uno cambia el class, la palabra class la cambia por esta, ¿vale? 00:27:26
La cambia por esa, ese es el primer requisito, 00:27:31
la palabra class se cambia por esa, ¿vale? 00:27:35
Entonces de una interfaz como tiene todos sus métodos abstractos, 00:27:42
salvo los matices que se han incorporado después que ya incorporamos, 00:27:46
ya incorporaremos, como tiene todos los métodos abstractos, 00:27:51
de una interfaz no se pueden instanciar objetos tampoco, 00:27:55
no se pueden instanciar. 00:27:57
Una interfaz vale solo para heredarla o implementarla. 00:27:59
Esto se llama implementarla. 00:28:03
Solo vale para eso. 00:28:04
Entonces, como no permite que se instancien objetos de ella, 00:28:06
en una interfaz no podemos declarar propiedades. 00:28:10
No podemos. 00:28:13
¿Vale? 00:28:14
Yo no puedo poner aquí cosas como esta. 00:28:16
Por ejemplo, el compilador ya se me queja y me dice, 00:28:20
no, esto es una interfaz, no es una clase. 00:28:24
Luego, no puede tener propiedades. 00:28:27
O sea, si esto fuera una clase, ya sí que podría, puede tener su propiedad nombre, pero no es una clase, es una interfaz, entonces no puede. 00:28:29
El sentido de esto es, como nunca vas a instanciar objetos de esto, pues no puedes tener propiedades. 00:28:43
Si tú quieres una clase de la que vayan a heredar otros y que también tenga propiedades, elige una clase, elige una clase abstracta si quieres, pero no elijas una interfaz. 00:28:49
porque una interfaz no puede tener 00:28:59
propiedades, lo que sí que puede 00:29:01
es tener 00:29:04
propiedades estáticas 00:29:05
¿vale? eso sí que puede 00:29:07
que además 00:29:12
tienen que ser 00:29:13
constantes, esto sí puede 00:29:15
parecer una interfaz 00:29:25
propiedades que son estáticas 00:29:26
y que además no pueden cambiar 00:29:28
de valor una vez que las has 00:29:31
inicializado, que será el 00:29:32
el modificador 00:29:35
final, si recordáis. El modificador 00:29:37
final, cuando se le ponía una propiedad, 00:29:39
significa que esa propiedad, una vez 00:29:41
que reciba valor, que tiene 00:29:43
que recibirlo en el momento de declararse, 00:29:45
ya no 00:29:48
va a cambiar nunca de valor, no se puede cambiar. 00:29:49
Bueno, pues 00:29:52
las interfaces pueden tener 00:29:53
propiedades estáticas. 00:29:54
Eso sí. 00:29:57
Entonces, para guardar información 00:29:59
genérica, entonces 00:30:01
yo podría usar en cualquier 00:30:02
programita mía, empleado despedible, 00:30:05
En este caso, por ejemplo, la funcionalidad de generar finiquito, pues a lo mejor el finiquito se va a generar para todos ellos a partir de un porcentaje. 00:30:07
Imaginaos que entonces su sitio para guardarlo a lo mejor podría ser aquí. 00:30:20
Entonces, variables static final sí puede tener, pero propiedades de ningún otro tipo. 00:30:29
No puede tener propiedades de ningún otro tipo. Esa es la primera condición de las interfaces. 00:30:34
vale 00:30:38
¿qué tiene una interfaz dentro? 00:30:41
tiene métodos vacíos 00:30:43
eso es lo que tiene 00:30:45
en nuestro caso es una interfaz empleado despedible 00:30:46
para hacer una especie de plantilla 00:30:49
de empleado despedible, pues le pondríamos un método 00:30:50
por ejemplo, generar 00:30:53
finiquito, pues yo que sé 00:30:55
y este método estaría así 00:30:57
entonces, como ya se asume 00:31:10
que en las interfaces todos los métodos 00:31:12
son vacíos, aquí ni se pone 00:31:14
el abstract, ni se pone nada, en una interfaz 00:31:16
No se pone el astra en el método vacío 00:31:18
No se pone 00:31:20
Propiedades 00:31:21
Estatic 00:31:34
Y final 00:31:38
¿Vale? Eso por un lado, aquí 00:31:40
No se pone el astra 00:31:42
Otra cosa 00:31:44
Los métodos de las interfaces 00:31:54
Por definición y por 00:31:56
Narices, son public 00:31:58
Porque las interfaces 00:32:00
Están pensadas, como luego ya 00:32:02
Vamos a ver y vamos a creernos 00:32:04
con más facilidad están pensadas 00:32:06
para que las implementen de cualquier 00:32:08
parte, para dar una especie de patrón 00:32:10
de funcionamiento y que las implementen de cualquier parte 00:32:12
entonces por definición y por obligación 00:32:14
son public, todos los 00:32:16
métodos de las interfaces son todos public 00:32:18
entonces como eso es así 00:32:20
ni siquiera hay que ponerlo 00:32:22
es que no se puede, lo puedes poner y no pasa nada 00:32:23
lo puedes poner 00:32:26
y no se te va a quejar 00:32:27
pero es que en este caso poner public 00:32:31
y no ponerlo en los métodos de una interfaz 00:32:34
es lo mismo 00:32:36
porque los métodos son siempre 00:32:37
public independientemente de que se ponga 00:32:40
el modificador o no 00:32:42
vale, aunque no esté el modificador 00:32:45
que es lo habitual, que no aparezca el modificador 00:33:01
son siempre public 00:33:03
vale, pues una interfaz es algo así 00:33:05
luego ya se incorpora 00:33:11
posteriormente, que ya lo incorporaremos 00:33:13
para verlo como ejemplo 00:33:15
la posibilidad de darles un cuerpo 00:33:16
por defecto 00:33:19
y la posibilidad de meter métodos 00:33:20
estáticos, pero bueno, eso lo 00:33:23
ponemos luego para no liar 00:33:25
entonces, ¿cuál es 00:33:27
la motivación de una interfaz? generar una especie 00:33:29
de patrón de comportamiento 00:33:31
es decir, yo soy empleado despedible 00:33:33
y el que me 00:33:35
implemente, tiene que 00:33:37
implementar este comportamiento 00:33:38
y este, y este, y este, porque podría haber un montón 00:33:41
de métodos vacíos, podría haber un montón 00:33:43
entonces, una interfaz es como una especie 00:33:44
de compromiso de funcionamiento 00:33:47
una serie de acciones, esta, esta 00:33:49
esta, esta, esta, acciones, métodos 00:33:51
Y el que implementa esa interfaz, lo que hace ya es decidir cómo se concreta ese comportamiento. 00:33:53
Luego, a nivel semántico de significado, una interfaz está asociada a un comportamiento, solo tiene métodos. 00:34:03
Sin embargo, la herencia, como la hemos visto, es más genérica. 00:34:10
Cuando nosotros hacíamos aplicaciones con animales, perros y gatos, el animal tenía cosas, tenía identidad. 00:34:13
y luego el perro le añadía alguna otra 00:34:20
y el gato le añadía alguna otra 00:34:23
pero el animal en sí ya tenía cosas 00:34:25
¿vale? 00:34:27
no tenía solamente comportamiento y métodos 00:34:29
también tenía descripción 00:34:31
entonces la herencia es más genérica 00:34:32
una superclase dentro de la herencia 00:34:35
una superclase 00:34:37
tiene una descripción suya, es algo 00:34:38
es algo y también hace algo 00:34:41
pero una interfaz solamente 00:34:43
hace algo, no es nada 00:34:45
porque ser está asociado 00:34:47
a que haya propiedades que te describen 00:34:49
si no tienes propiedades que te describen 00:34:51
no eres nada, pero si puedes 00:34:53
hacer algo, hacer algo son los métodos 00:34:55
pues entonces la interfaz solamente 00:34:57
tiene métodos, es decir 00:34:59
solamente recoge la idea 00:35:01
de un comportamiento 00:35:03
solamente recoge la idea de un comportamiento 00:35:05
no de una identidad, de yo tengo 00:35:07
mi nombre, tengo mi nif, tengo mi 00:35:09
no recoge la idea de identidad 00:35:11
por eso los nombres de las 00:35:12
interfaces de la máquina virtual de Java 00:35:16
muchas veces tienen nombres 00:35:19
que están asociados a un comportamiento 00:35:21
por ejemplo, yo la he llamado a propósito despedible 00:35:24
porque despedible 00:35:26
está asociado a que te pueden despedir 00:35:28
la interfaz comparable 00:35:30
como ya veremos, está asociada a que te pueden comparar 00:35:31
muchos nombres acaban en el hable 00:35:34
de los interfaces 00:35:36
porque están asociadas a cosas que se pueden hacer 00:35:37
tirable 00:35:40
pintable 00:35:42
lo que sea 00:35:44
suelen ser los nombres habituales de las interfaces 00:35:45
Significan lo que se puede hacer 00:35:48
Pintar, tirar 00:35:50
Sin embargo, las superclases normales de herencia 00:35:51
Pues son animal, empleado 00:35:55
No es solo lo que pueden hacer 00:35:56
Sino también lo que son 00:35:58
Tienen su nombre 00:35:59
Efectivamente 00:36:00
Sustantivos o calificativos 00:36:03
Bueno, pues 00:36:07
Entonces, ahora 00:36:11
Una vez que hemos decidido tener esta interfaz 00:36:13
Pues ahora ya 00:36:16
Nuestra aplicación se convierte 00:36:17
en que empleado 00:36:20
plantilla no es despedible 00:36:22
con lo cual empleado plantilla se queda así 00:36:24
hereda de empleado y punto pelota 00:36:25
silencio 00:36:27
pero empleado temporal 00:36:29
es un empleado 00:36:31
pero también puede ser despedido 00:36:33
entonces se tiene que quedar con las dos cosas 00:36:36
vale, pues 00:36:38
hereda de empleado 00:36:40
y ahora hay que indicar que implementa 00:36:41
la interfaz despedible 00:36:44
y como se indica, pues no pasa 00:36:45
nada después del extends 00:36:48
uno pone implements 00:36:49
que es la palabra clave 00:36:52
para decir que una clase 00:36:53
implementa una interfaz 00:36:55
¿vale? y ya está 00:36:57
entonces empleado temporal 00:37:06
hereda de empleado 00:37:08
luego se queda con todo lo que tiene empleado 00:37:09
propiedades y métodos 00:37:12
y además 00:37:14
implementa empleado despedible 00:37:15
entonces al implementar empleado despedible 00:37:18
está obligada 00:37:20
a dar cuerpo 00:37:22
a todos los métodos 00:37:24
Vacíos de empleado despedible 00:37:26
Está obligada 00:37:28
Por eso se nos ha puesto aquí rojo 00:37:29
Porque nos ha dicho, uy, si implementas de empleado despedible 00:37:33
Pues vas a tener que implementar 00:37:36
Generar finiquito 00:37:38
Pues no pasa nada 00:37:39
Ala 00:37:41
Genero finiquito 00:37:42
Pues cualquier cosa 00:37:45
Voy a poner algo 00:37:48
¿Vale? 00:37:52
Este diseño 00:37:55
Es un poquito más fiel 00:37:58
A lo que es la realidad 00:38:00
yo voy identificando 00:38:01
las diferentes 00:38:04
entidades que me van saliendo 00:38:05
tengo empleados, solo algunos 00:38:08
se les puede despedir, pues solo algunos 00:38:10
se adhieren a la posibilidad 00:38:12
de ser despedidos, no todos se adhieren 00:38:14
y así se pueden ir incorporando cosas 00:38:16
empleado externo 00:38:18
le pasaría igual, empleado externo era de empleado 00:38:20
pero también puede ser despedible 00:38:23
pues entonces 00:38:25
no pasa nada, implementa empleado despedible 00:38:32
y entonces no le queda más remedio 00:38:34
que 00:38:36
sobrescribir esto 00:38:38
pues lo que fuera 00:38:41
se supone que lo haría 00:38:43
de una manera distinta al otro 00:38:45
se supone 00:38:47
yo ahora del código que hago dentro de los métodos 00:38:48
me estoy despreocupando, me da igual lo que haya dentro 00:38:55
cada uno tendría su propia forma 00:38:57
de generar finiquitos, se supone 00:38:59
y la suerte de las interfaces 00:39:00
es que se puede heredar 00:39:06
de tropecientas a la vez 00:39:08
a lo mejor 00:39:10
aparte del comportamiento despedible 00:39:12
pues hay otro comportamiento 00:39:14
o otra cosa que pueden tener 00:39:16
en común, no todos los empleados 00:39:18
que sea, pues yo que sé, aparte de despedir a un empleado 00:39:20
¿qué se le puede hacer? 00:39:22
Felicitarle, felicitable 00:39:24
pues entonces se podría ver una interfaz empleado felicitable 00:39:25
y entonces uno puede implementar 00:39:29
todas las que quiera separadas por comas 00:39:31
entonces 00:39:33
empleado externo, extens, empleado 00:39:34
eso sí que solamente puede dar de una 00:39:37
después del extens solo puede haber una, sí o sí 00:39:38
solo puede haber uno, pero luego 00:39:40
después del implements puede haber 00:39:42
tropecientas separadas por comas 00:39:44
uno puede implementar todos los 00:39:46
comportamientos o interfaces 00:39:48
que necesite 00:39:50
y luego tendrá que dar código 00:39:52
a todos ellos 00:39:54
¿vale? 00:39:55
entonces de esta manera pues tenemos 00:39:58
muchísimas más posibilidades para hacer 00:40:00
diseños un poquito 00:40:02
más claros, más 00:40:04
pidedignos 00:40:06
¿y ahora qué pasa? 00:40:07
¿qué implicaciones tiene haber hecho esto de aquí? 00:40:11
por ejemplo, si nos hacemos 00:40:17
nuestro main 00:40:18
constructores 00:40:19
ay, que no lo ha llamado bien 00:40:23
a ver, refactors 00:40:29
vale, ahora ¿qué ocurre? 00:40:33
pues exactamente igual que 00:40:45
con la herencia que ya hemos visto, que yo puedo tener 00:40:46
aquí un array con todos 00:40:48
mis empleados 00:40:51
o una referencia suelta 00:40:51
para no meter un array, si yo tengo aquí una 00:40:56
referencia suelta en e 00:40:58
Está claro, ya lo sabemos 00:40:59
Que en E podemos meter 00:41:01
Un empleado plantilla 00:41:02
Eso ya lo sabemos 00:41:04
Pero en E podríamos 00:41:07
Meter también un empleado temporal 00:41:09
Eso es lo de la herencia que hemos visto 00:41:11
Y en E podríamos 00:41:13
Meter también 00:41:15
Un empleado externo 00:41:16
¿Vale? En E cae cualquiera de estas cosas 00:41:18
Y si fuera una RAI 00:41:28
A cualquier porcentaje de la RAI cabría 00:41:30
Entonces si yo hago ahora E punto 00:41:31
Pues generar nómina 00:41:33
pues ya sabemos lo que significa esto 00:41:35
que 00:41:38
al método generar nómina que se llama 00:41:39
dependerá de qué tipo de objeto sea 00:41:42
si es 00:41:44
empleado plantilla 00:41:46
¿por qué estamos así? 00:41:47
pues se llamará 00:41:51
generar nómina de empleado plantilla 00:41:52
¿que no? ¿que es empleado temporal? 00:41:53
pues se llamará al generar nómina 00:41:58
de empleado temporal, esto ya lo sabemos 00:42:00
¿vale? 00:42:02
es lo de herencia 00:42:03
¿vale? pues con las interfaces es similar 00:42:04
resulta que yo tengo 00:42:07
uy, tengo un montón de empleados que voy a despedir 00:42:09
venga, voy a meterlos 00:42:11
a todos en un array 00:42:13
por ejemplo, pues yo me puedo 00:42:14
hacer un array 00:42:17
lo voy a poner abajo, venga 00:42:18
voy a 00:42:36
el new, me falta 00:42:37
y la end 00:42:39
vale, por ejemplo, vamos a despedir 00:42:41
a 20, vamos a despedir a 20 00:42:44
pueden, a 20 00:42:46
pueden ser tanto 00:42:48
temporales como externos 00:42:49
con lo cual el array 00:42:51
¿de qué lo hacemos? de temporales, de externos 00:42:53
puede ser de cualquiera de los dos tipos 00:42:56
pues yo lo hago 00:42:58
de empleado despedible 00:43:00
pero claro, lo que cae dentro 00:43:01
de esas referencias no puede ser empleado 00:43:03
despedible porque es que no se puede instanciar 00:43:05
ahora ya dentro de esa referencia puede caer 00:43:07
cualquier cosa 00:43:10
cualquier cosa, por ejemplo 00:43:10
en la posición 0 00:43:14
yo puedo meter 00:43:16
un nuevo 00:43:17
Empleado, plantilla no 00:43:20
Plantilla, si yo pongo 00:43:22
Este, me diría 00:43:24
No, no puedes 00:43:26
¿Por qué? Porque empleado plantilla no 00:43:28
Implementa esta, no la implementa 00:43:30
Entonces no puedes, esto no podríamos 00:43:32
Pero esto de abajo 00:43:34
Pues si podemos 00:43:38
Un temporal si que podemos meterle 00:43:41
Y también podríamos ponerle un externo 00:43:43
En cualquiera de esas posiciones 00:43:53
Podríamos ponerle un externo en cualquiera de ellas 00:43:57
Porque todas implementan empleado despedible 00:43:59
Todas lo implementan 00:44:03
Entonces esto funciona igual que la herencia 00:44:04
Y ahora imaginaos que llamamos a despedir 0 00:44:07
A este que llamamos al generar finiquito 00:44:12
Bueno pues se estará llamando 00:44:15
En este caso a generar finiquito del temporal 00:44:19
Del método que hay en el temporal 00:44:23
Pero si llamamos a este 00:44:25
Pues estaremos llamando 00:44:34
A generar finiquito, pero en la versión 00:44:37
Del externo, ¿vale? 00:44:39
O sea, esto es igual que la herencia 00:44:41
Exactamente igual 00:44:42
Efectivamente 00:44:44
Efectivamente 00:44:47
El tipo de dato 00:44:49
A la hora de declararlo es la interfaz 00:44:52
Luego tu instancia es cualquiera de los que lo implementan 00:44:54
Cualquiera de los que lo implementan 00:44:57
¿Vale? 00:44:58
Vale, pues venga, nos... 00:45:00
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
26 de febrero de 2024 - 18:52
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
45′ 02″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
171.55 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid