Saltar navegación

20260123 InterfacesTeroria - 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 25 de enero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

flojerías, bueno 00:00:00
esto es una pizarra, sí 00:00:01
vale, bueno pues vamos 00:00:03
a un concepto más relacionado con la herencia 00:00:05
que es 00:00:08
básico en cualquier diseño 00:00:09
en cualquier aplicación mínimamente 00:00:11
compleja y sobre 00:00:13
la que se sustenta 00:00:15
cualquier paquete que usemos, como el de 00:00:17
colecciones, que es 00:00:19
el siguiente que veremos, o las 00:00:21
excepciones, o las interfaces gráficas 00:00:23
cualquier cosa 00:00:26
todos esos paquetes que nosotros 00:00:27
ya usaremos para hacer nuestras cosas 00:00:29
se sustentan sobre esta idea 00:00:31
de interfaces 00:00:32
que es lo que vamos a 00:00:34
incorporar a otra que es 00:00:37
nada 00:00:39
a nivel de incorporación de detalles 00:00:40
de código es nada, son cuatro cosas 00:00:43
es sobre todo una cuestión de entender 00:00:45
por qué aparecen, por qué las usamos 00:00:47
¿vale? 00:00:49
bueno, pues a ver 00:00:51
lo que es la herencia, la motivación 00:00:52
de por qué apareció la herencia 00:00:55
en esta vida 00:00:57
la tenemos, ¿no? 00:00:58
¿Por qué? 00:01:03
Es interesante la idea. 00:01:04
Venga, me ha tocado. 00:01:06
Para... 00:01:10
Para... 00:01:11
Una frase rápida. 00:01:13
Para poder utilizar datos 00:01:15
de otras clases. 00:01:17
Bueno, poder utilizar datos no me gusta, 00:01:20
porque no es la idea. 00:01:23
Los datos tú los utilizas cuando instancias un objeto. 00:01:24
Ahí utilizas datos. 00:01:27
No exactamente. 00:01:29
Claro, eso es la herencia 00:01:29
Crear una clase a partir de otras 00:01:35
¿Pero por qué? 00:01:37
¿Por qué? 00:01:38
Vale, que eso podríamos resumirlo en 00:01:47
Reutilizar código 00:01:49
¿Verdad? 00:01:51
Para automatizar sería la palabra 00:01:52
No, no automatizamos nada 00:01:54
No estamos automatizando nada 00:01:56
Para reutilizar código 00:01:58
Lo que tú has dicho viene a ser reutilizar código 00:02:01
¿Vale? 00:02:03
entonces 00:02:03
y además de 00:02:05
reutilizar código 00:02:07
en sí 00:02:09
¿para qué otra cosa nos ha servido? 00:02:10
¿cuál ha sido otra motivación 00:02:15
fundamental? 00:02:16
claro 00:02:19
va por ahí, por el polimorfismo 00:02:20
es decir, tú tienes un montón 00:02:22
de datos, un montón 00:02:24
de objetos en tu aplicación 00:02:26
que no son lo mismo en realidad 00:02:28
uno es alumno de FP 00:02:30
alumno de la ESO 00:02:32
alumno de infantil, no son lo mismo, con lo cual 00:02:34
no los puedes crear, declarar como la misma clase 00:02:38
porque son distintos, no son lo mismo, son clases distintas, pero 00:02:42
comparten, como tú decías, mucha información, entonces efectivamente 00:02:46
desde el momento en que todos identificas que todos 00:02:49
son alumno, alumno ESO es alumno, alumno FP es 00:02:53
alumno, alumno infantil es alumno, cuando identificas 00:02:58
que todos son alumnos 00:03:02
automáticamente puedes 00:03:04
decir, vale, pues entonces 00:03:06
si todos puedo yo decir que son 00:03:07
alumno, es porque la idea de 00:03:09
alumno existe 00:03:11
luego habrá cosas que tengan 00:03:13
los alumnos, porque esa idea existe y que por tanto 00:03:15
la tengan todos los demás 00:03:18
y luego ya cada uno tendrá 00:03:19
lo suyo específico 00:03:21
entonces 00:03:23
el diseñarlo 00:03:25
de esa manera, como 00:03:28
tres clases que son 00:03:29
distintas, pero todas 00:03:32
heredan de la misma y todas 00:03:34
comparten lo que tiene la superclase 00:03:35
automáticamente 00:03:38
tiene la ventaja 00:03:39
del polimorfismo 00:03:41
que decía él, y es que ahora yo ya 00:03:44
puedo trabajar 00:03:46
con instancias de esos 00:03:47
objetos por igual, todas ellas llamarán 00:03:49
a los mismos métodos, métodos que están 00:03:52
en la superclase, todas ellas 00:03:53
pueden estar en 00:03:56
el mismo array, yo las puedo tratar a todas 00:03:58
por igual, y si todos tienen 00:04:00
el método matricular 00:04:01
pues el alumno FP 00:04:03
se puede matricular, el alumno infantil 00:04:05
se puede matricular y el alumno 00:04:07
de la ESO se puede matricular 00:04:10
¿vale? porque todos son alumnos 00:04:12
yo los trato por igual, a todos les llamo 00:04:13
el método matricular 00:04:15
pero cada uno va a ejercer ese 00:04:16
método de una manera distinta, cada uno lo va a ejercer 00:04:19
de una forma distinta 00:04:21
¿vale? entonces todos comparten 00:04:22
las llamadas a los métodos, todos 00:04:26
los trato por igual, todos los meto 00:04:27
en la misma caja, en el mismo array 00:04:29
y el mismo lista enlazada 00:04:31
los meto a todos por igual 00:04:33
pero cada uno se comporta internamente 00:04:35
de forma distinta, aunque yo los trate 00:04:37
desde arriba por igual 00:04:39
eso lo podemos hacer gracias a la herencia 00:04:40
¿vale? 00:04:43
bueno, pues esto como herramienta 00:04:45
entonces de diseño que luego facilita 00:04:47
el desarrollo de una aplicación 00:04:49
está muy bien, pero se nos 00:04:51
ha quedado un poco coja 00:04:53
os habréis 00:04:55
dado cuenta si vosotros empezáis a pensar 00:04:57
en situaciones de 00:04:59
a gestionar, pues de 00:05:01
cualquier cosa que haya que gestionar, de inventarios 00:05:03
de gestionar un taller 00:05:05
mecánico, gestionar una empresa de personal 00:05:07
si os ponéis a pensar en situaciones 00:05:09
pues veréis que con la 00:05:10
relación de herencia no se 00:05:13
puede reflejar todo 00:05:15
primero porque la herencia 00:05:16
en Java es una herencia 00:05:19
simple, entonces recordad 00:05:21
que en Java cada clase 00:05:23
solo puede 00:05:27
heredar de otra 00:05:29
Entonces, tú puedes ser una cosa 00:05:30
Pero no puedes ser otra 00:05:35
No puedes ser otra a la vez 00:05:36
¿Vale? 00:05:38
Entonces, bueno, eso tiene cierto sentido real 00:05:40
Yo soy empleado 00:05:43
Temporal 00:05:45
¿Vale? Soy empleado 00:05:46
Y ya está, pero soy empleado solamente 00:05:48
Soy empleado temporal 00:05:51
Y soy empleado y no soy nada más 00:05:52
Ni puedo ser nada más en esta jerarquía mía 00:05:55
De clases 00:05:57
¿Vale? Pues entonces, eso realmente se queda 00:05:57
un poco corto, porque luego a lo mejor puede 00:06:01
haber otras cosas 00:06:03
en la aplicación como 00:06:04
eres empleado que ficha 00:06:07
eres empleado que ejerce 00:06:09
de jefe, eres empleado 00:06:11
que hace no sé qué 00:06:13
es decir, en mi aplicación puede haber 00:06:14
una cosa, que para entendernos 00:06:17
y que quede claro, que se llamen roles 00:06:19
a lo mejor tú eres 00:06:21
un empleado, pero hay diferentes 00:06:24
papeles que puedes jugar 00:06:26
y en un momento dado puedes jugar uno 00:06:27
o a lo mejor puedes jugar otro 00:06:30
entonces tú no eres solamente una cosa 00:06:32
también 00:06:35
tú te puedes definir 00:06:36
por lo que haces, por los roles 00:06:39
¿vale? 00:06:41
y que puedes tener muchos 00:06:43
entonces esto amplía un poquito más 00:06:45
nuestras posibilidades de diseñar la aplicación 00:06:47
bueno, pues para meter esto en Java 00:06:49
para reflejar esto en Java 00:06:51
aparece una cosa que se llama 00:06:52
interfaces 00:06:55
entonces, ¿la interfaz qué es? 00:06:56
una interfaz es una clase 00:06:58
es como si fuera una clase abstracta pura, solamente tiene métodos vacíos. 00:07:00
Eso es una interfaz. 00:07:11
Se declara con la palabra interfaz, así. 00:07:12
Es como si fuera una clase, pero en lugar de poner class, se pone interfaz. 00:07:19
¿Qué nombre le da uno? 00:07:26
Pues bueno, el nombre que le dé la gana. 00:07:29
Normalmente las interfaces están asociadas 00:07:31
No es que sea obligatorio 00:07:34
Pero es la idea, para eso se usan 00:07:35
Están asociadas a funciones, comportamientos, roles 00:07:38
Papeles que uno puede jugar en la aplicación 00:07:43
Por eso sus nombres suelen acabar en hable 00:07:46
Pues soy movible, soy expulsable 00:07:49
Soy titulable 00:07:53
Es decir, cosas que yo puedo hacer 00:07:54
Suelen estar asociadas a eso 00:07:57
Por ejemplo, estamos gestionando coches, en vuestras bases de datos de coches, de bases de datos, pues no sé qué relación tendrá 00:07:58
Pero imaginaos que tenéis un taller mecánico que tiene coches, motos, carros de caballos, carruajes 00:08:10
uno podría hacer un diseño en el cual 00:08:23
todos ellos 00:08:26
hereden de vehículo 00:08:27
muy bien, todos hereden de vehículo 00:08:29
esa parte ya la tenemos controlada 00:08:31
en vehículo pondremos 00:08:34
todo aquello que tienen 00:08:36
todos los vehículos, el coche 00:08:37
la moto, el carromato, lo pondremos 00:08:39
todo, los métodos 00:08:42
que esté claro cómo van a 00:08:44
funcionar los ponemos en la superclase 00:08:46
lo que no esté claro 00:08:48
porque dependerá de cada ejemplo 00:08:49
esos los ponemos como vacíos 00:08:51
con lo cual el vehículo se convierte 00:08:55
en abstracta y ahora ya 00:08:57
cada subclase los rellena 00:08:58
con su contenido específico 00:09:01
esa parte ya la sabemos 00:09:02
pero luego puede haber más cosas 00:09:03
que haya que meter en la aplicación de alguna manera 00:09:06
que tengan que quedar reflejadas 00:09:08
por ejemplo 00:09:10
el taller mecánico tiene 00:09:11
su parte que define, tengo coches, carromatos 00:09:13
todos son vehículos 00:09:16
pero también gestiono ventas, hago cosas 00:09:18
Bueno, pues esos cacharros de ahí 00:09:21
Esos coches, esas motos 00:09:23
Además de ser vehículos 00:09:24
Además puede que necesiten ser vendidos o no ser vendidos 00:09:26
Ser alquilados o no ser alquilados 00:09:30
Es decir, desempeñar una función 00:09:32
Y cada una de ellas la que toque en cada momento 00:09:34
Entonces, por ejemplo 00:09:37
Uno podría hacer una interfaz vendible 00:09:39
Que se llamara vendible 00:09:42
Entonces tendríamos 00:09:43
La estructura que hemos hecho antes 00:09:53
Pues tendríamos vehículo 00:09:56
y de vehículo hereda 00:09:58
el coche 00:10:03
y la moto 00:10:05
¿vale? 00:10:08
aquí ya con las propiedades que sean 00:10:10
con los métodos que sean, lo que sea 00:10:12
pues coche, pues lo que fuera 00:10:14
pues mostrar datos, pintarlo 00:10:16
cambiar ruedas, moto 00:10:18
pues ponerle lo que fuera 00:10:20
lo que sea 00:10:22
luego tenemos la parte de ventas de la aplicación 00:10:23
entonces 00:10:26
puede ser 00:10:27
que los coches sean vendibles 00:10:31
se puedan vender pero las motos no, ese taller 00:10:32
solo arregle motos y no las venda, solamente 00:10:34
venda coches, entonces aquí 00:10:36
tenemos un problema 00:10:38
porque, jolines, el método 00:10:39
vender solo aplica 00:10:43
para coche, para moto no 00:10:45
vale 00:10:46
podríamos en coche poner un método 00:10:48
específico suyo que fuera vender 00:10:51
tendríamos solamente 00:10:52
el pequeño problema de que este método 00:10:56
solo estaría aquí, lógicamente 00:10:58
aquí no puede estar porque la moto no puede ser vendida 00:11:00
y yo no podría ponerlo aquí en la superclase 00:11:02
como método abstracto 00:11:05
no podría, porque si lo pongo 00:11:07
aquí en la superclase como método abstracto 00:11:09
moto se ve 00:11:11
obligada a implementarlos 00:11:13
entonces ya el diseño empieza a ser un poco 00:11:14
raro, entonces ya empieza a ser 00:11:17
feo, entonces 00:11:19
me conviene separar partes, es decir, a ver 00:11:21
esta es mi parte 00:11:23
de lo que son, coche es vehículo 00:11:25
moto es vehículo, ya lo tengo todo hecho 00:11:27
ahora, ¿qué es lo que pueden 00:11:29
hacer, este puede ser vendido 00:11:31
meter eso aquí, por lo que acabo 00:11:33
de decir, ya me estropea el diseño 00:11:35
me lo hace un poco feo, porque ¿qué lo hago? 00:11:37
¿lo pongo aquí en abstracto? no porque me obliga 00:11:39
vale, pues entonces no lo pongo 00:11:41
aquí para que esta no se vea obligada 00:11:43
pero si no lo pongo aquí, tengo el problema 00:11:45
de que un objeto coche 00:11:47
no puede llamar a vender 00:11:49
perdón, un objeto coche 00:11:53
si está declarado como vehículo 00:11:55
que será lo normal, que esté 00:11:57
declarado como vehículo, aunque esté instanciado 00:11:59
como coche, pues no puede llamar 00:12:01
a vender, tengo que hacer el casting 00:12:03
¿verdad? porque el compilador 00:12:04
me dice, perdona, pero esto está declarado 00:12:07
como vehículo, yo no puedo 00:12:09
llamar al método vender porque aquí no está 00:12:11
entonces tendríamos que hacer el casting 00:12:13
¿vale? soluciones hay 00:12:15
pero son feas, mejor si hacemos un diseño 00:12:17
más bonito 00:12:19
bueno, pues entonces, yo podría hacer 00:12:19
muy bien, saco todo esto de vender 00:12:23
de la idea de ser 00:12:25
la saco, ahora me voy a la hacer 00:12:27
¿vale? la herencia 00:12:29
sería ser que soy las interfaces serían que hago pues lo voy a sacar a la parte del que hago me 00:12:31
hago una interfaz vendible porque las cosas que yo tenga por aquí algunas serán vendibles y otras no 00:12:38
pues me hago una interfaz vendible que va por libre no tiene nada que ver con la clase vehículo está 00:12:44
de aquí empieza con la palabra clave interfaz vale y aquí ya pongo el método o los métodos 00:12:50
pueden ser muchos, que van a tener 00:13:00
que ejecutar todos 00:13:02
aquellos que quiera yo que se 00:13:04
adquieran, que se adscriban a este comportamiento 00:13:06
por ejemplo 00:13:08
pues el método vender 00:13:10
vale, la interfaz es una clase 00:13:11
abstracta como si 00:13:20
fuera una clase abstracta pura 00:13:22
puede tener uno 00:13:24
o muchos métodos, pero todos 00:13:26
los que tenga serán 00:13:28
abstractos 00:13:30
vale, con el matiz de método por defecto 00:13:31
que os digo ahora, pero eso lo digo después 00:13:34
Os estoy mintiendo cuando os digo 00:13:35
que todos son abstractos, pero no pasa nada. 00:13:38
Luego ya arreglo la mentira. 00:13:39
Pero en esencia es la idea de la interfaz. 00:13:42
La idea de la interfaz es que 00:13:44
tenga un montón de métodos vacíos. 00:13:45
Voy a vender. 00:13:48
Vendible. Cuando alguien es 00:13:49
vendible, ¿qué más nos interesa que nos haga? 00:13:51
Pues, por ejemplo, generar su factura. 00:13:54
¿Vale? Pues aquí se ponen 00:14:03
los métodos vacíos 00:14:04
que se supone que tiene que 00:14:06
implementar aquel 00:14:08
que quiera ser vendible 00:14:10
que todavía habrá que decidir 00:14:12
cómo hacer una para convertirse en vendible 00:14:14
esto se declara 00:14:16
y ya está 00:14:19
y se declara porque yo he identificado 00:14:19
que hay un comportamiento en mi aplicación 00:14:22
que va por ahí 00:14:25
que hay cosas que pueden ser vendibles 00:14:26
pues yo las recojo ahí 00:14:28
que podría no ser así 00:14:29
imaginaos que ahora mi aplicación aumenta 00:14:37
y yo en mi taller 00:14:41
incorporo otro 00:14:42
otro vehículo 00:14:44
que es un triciclo 00:14:46
vale 00:14:48
imaginaos que yo esto de las interfaces 00:14:52
lo he olvidado y no lo estoy usando 00:14:53
y paso de ello 00:14:56
resulta que 00:14:57
los coches y los triciclos pueden ser vendidos 00:14:59
los vehículos 00:15:02
no, pues con todo 00:15:04
esto que he dicho como si no existiera 00:15:06
pues tendría que hacer aquí también un vender 00:15:07
es decir 00:15:10
duplicarlo todo 00:15:12
quedaría como muy feo, de nuevo tendría el mismo 00:15:13
problema, si yo tengo un triciclo 00:15:15
instanciado como, declarado 00:15:18
como vehículo, que es la idea, que esté declarado 00:15:20
como la superclase 00:15:22
si yo ya me voy a vender, no voy a poder 00:15:23
voy a tener que hacer el casting 00:15:26
nada, mala solución 00:15:27
ir poniendo parches así, mala solución 00:15:29
bueno, pues cuál es la solución 00:15:32
hacer esta interfaz que acabo de decir 00:15:35
que recoja esas 00:15:37
cosas que tiene que hacer 00:15:40
cualquier entidad que yo quiero que sea vendible 00:15:41
y ahora 00:15:44
decir, vale 00:15:45
pues coche, que está 00:15:48
por aquí, cuando yo declare 00:15:50
coche, vale, cuando yo declare 00:15:54
coche, class coche 00:16:01
que herede de ese 00:16:04
de vehículo, pues yo no tengo 00:16:05
alternativa, lógicamente 00:16:07
este es vehículo 00:16:09
y ahora, además de heredar 00:16:12
de vehículo, yo digo 00:16:15
además de eso, tienes 00:16:17
que implementar 00:16:19
esto, tiene que adherirse 00:16:22
a este comportamiento 00:16:24
de aquí, porque es vendible 00:16:26
luego tiene que implementar 00:16:27
esto de aquí, pues entonces 00:16:30
¿qué añado después del stents? 00:16:31
después del stents añado 00:16:34
implement 00:16:35
la interfaz que sea 00:16:36
vendible 00:16:39
y ya abro 00:16:41
mis llaves y hago el código 00:16:44
¿vale? 00:16:45
entonces, una entidad 00:16:47
puede heredar 00:16:49
de otra entidad 00:16:51
solo de una y significa 00:16:52
yo soy eso 00:16:55
todo lo que tenga 00:16:56
que es todo su estado, su descripción 00:16:59
vehículo, pues su color 00:17:01
su marca, lo que sea 00:17:03
todo va a estar aquí 00:17:05
entonces heredar significa 00:17:06
coger propiedades, yo soy esto 00:17:09
está asociado al verbo ser, yo soy esto 00:17:11
vale, un segundo 00:17:13
pero además de ser tú algo 00:17:14
además de ser algo 00:17:16
tú haces cosas 00:17:18
bueno, pues esas cosas 00:17:20
si se pueden interpretar 00:17:22
como que son un rol 00:17:25
específico 00:17:27
como el rol de ser vendible 00:17:28
en lugar de esas cosas que haces tú 00:17:30
ponerlas todas aquí una detrás de otra 00:17:33
que queda un diseño patateo 00:17:34
como esas cosas están asociados 00:17:36
a un rol concreto, en este caso 00:17:38
ser vendible, pues lo sacas 00:17:40
aquí a una interfaz, donde pones 00:17:42
esas cositas 00:17:44
en vacío, obligatorio 00:17:45
y ahora dices, yo soy vehículo 00:17:48
y además 00:17:51
implemento esta interfaz 00:17:52
y además la implemento 00:17:54
entonces 00:17:56
desde el momento en que tú pones aquí 00:17:57
que implementas una interfaz 00:18:01
de nuevo el compilador te va 00:18:02
a obligar, como pasaba con las clases 00:18:05
abstractas, te va a obligar a decir, vale 00:18:07
muy bien, tú implementas vendible 00:18:09
pues por favor 00:18:11
dame código a esto 00:18:13
vale, tú le das 00:18:15
código a eso y ya está 00:18:17
esto es lo que en términos de desarrollo 00:18:18
de programación, esto es como si 00:18:25
fueran los términos de un contrato 00:18:27
aquí está, en la interfaz está el contrato 00:18:29
que es 00:18:31
esto es lo que tienes que hacer 00:18:32
el contrato 00:18:35
en general te compromete 00:18:36
a unos servicios 00:18:40
¿vale? pues eso es una interfaz 00:18:41
un contrato que te compromete 00:18:43
a que hagas esto 00:18:46
si tú 00:18:47
firmas ese contrato 00:18:49
y firmarlo es poniendo 00:18:51
implements la interfaz que sea 00:18:52
automáticamente tienes 00:18:54
que dar cuerpo, implementar 00:18:57
tú dentro de ti 00:18:59
esos métodos 00:19:00
a tu manera, como a ti te dé la gana 00:19:03
¿y esa interfaz 00:19:05
iría dentro de la clase vehículo? 00:19:07
no, es una clase aparte 00:19:09
o sea, solamente es que 00:19:11
claro, es otra clase más 00:19:12
vale, vale 00:19:14
tampoco puede ser 00:19:14
a lo largo de dos interfaces 00:19:17
Sí, entonces, la diferencia es que una clase puede implementar todas las interfaces que le den la gana. 00:19:19
Imaginaos que este taller mecánico mío, con los vehículos, con algunos sí, con otros no, 00:19:29
pues hay una actividad muy concreta que es la actividad de ir a exposición, exponible, llamémosla exponible. 00:19:36
Pues uno podría hacer aquí una interfaz 00:19:42
¿Vale? 00:19:44
Uno podría hacer aquí una interfaz que fuera 00:19:48
Exponible 00:19:50
Y en esa interfaz 00:19:52
Poner ahí dentro los métodos 00:19:56
Poner caseta 00:19:58
O yo que sé 00:20:00
O mostrar mensaje 00:20:02
Lo que fuera 00:20:04
¿Vale? Ese sería el contrato 00:20:04
Que tú tienes que satisfacer, que garantizar 00:20:08
Lo que tú tienes que hacer 00:20:10
Si eres exponible 00:20:11
¿vale? pues entonces 00:20:13
a lo mejor el coche 00:20:15
es vendible y además exponible 00:20:17
pues el coche tendría 00:20:19
implements vendible 00:20:21
coma exponible 00:20:22
como se implementa 200.000 00:20:24
heredar solo de una 00:20:26
tú solo eres una cosa 00:20:30
en Java solo eres una cosa, no puede ser más 00:20:32
tu esencia es una 00:20:35
pero lo que tú haces 00:20:37
los roles que tú tienes en una aplicación 00:20:39
como alumno, como coche 00:20:43
como pueden ser miles 00:20:46
¿vale? tú puedes implementar 00:20:47
200.000 interfaces 00:20:49
tantas como roles identifique tu aplicación 00:20:51
que tienen sentido 00:20:54
entonces pues triciclo 00:20:55
heredaría de vehículo pero a lo mejor implementaría 00:20:57
vendible, pero 00:20:59
fonible pues no la implementaría 00:21:01
¿vale? pues moto igual no implementa 00:21:03
ninguna de las dos 00:21:06
entonces de nuevo 00:21:07
es otra herramienta de diseño más 00:21:09
que facilita muchísimo 00:21:11
las cosas cuando el diseño 00:21:14
se ha planteado desde el principio 00:21:16
diseño horrible 00:21:17
todas mis clases son clases 00:21:19
separadas y ninguna relación entre ellas 00:21:22
ahí no hay polimorfismo 00:21:24
no hay nada, me complica mucho la vida 00:21:26
cada clase la hago todo lo suyo 00:21:28
ahí dentro, no puedo 00:21:30
meterlas juntas en colecciones 00:21:32
de cada clase tengo que 00:21:33
enterarme que métodos tiene 00:21:36
aquí si 00:21:37
yo tengo varias clases que implementan 00:21:40
vendible y ahora soy otra clase 00:21:43
de otro método, ah, me están pasando 00:21:45
un vendible, vale, me da igual 00:21:47
lo que me están pasando, me da igual que sea un coche, que sea una moto 00:21:49
me pasan un vendible, yo llamo a vender 00:21:51
y ya está 00:21:52
vale, si no, tendríamos que 00:21:53
hacer el método para versión 00:21:57
pásame coche, versión pásame triciclo 00:21:59
versión pásame no sé qué 00:22:01
así no, haces versión 00:22:02
pásame vendible, se acabó, como yo sé 00:22:04
que tiene un método vender 00:22:07
pues llamó a vender 00:22:08
y se acabó 00:22:09
¿no haría falta hacerle casting 00:22:11
a la hora de llamar a la empresa? 00:22:14
no, porque está aquí, es como si tú lo pones 00:22:16
en una clase abstracta 00:22:18
si está en la superclase 00:22:19
esta es como si fuera una superclase 00:22:22
abstracta, abstracta pura 00:22:24
¿vale? 00:22:28
entonces luego ya hay 00:22:30
detalles ya concretos de sintaxis 00:22:30
que ya son detallitos, pues como que 00:22:32
por defecto 00:22:34
los métodos son siempre 00:22:36
public, porque esto siempre está pensado 00:22:38
para un empaquetamiento, son diseños de paquetes 00:22:40
donde lógicamente las interfaces 00:22:42
se ponen en un paquete, las clases en 00:22:44
otras, entonces 00:22:46
los métodos 00:22:47
no se pone el public, porque 00:22:49
por defecto son siempre public, aquí no hace 00:22:52
falta ponerlo, no es como las clases abstractas 00:22:54
que la clase abstracta es como una clase 00:22:56
raruna, entonces ahí sí que lo 00:22:57
sigue todas las reglas, en la interfaz 00:23:00
aquí no pones nada 00:23:02
Ese método vender lo tenéis que meter en la subclase 00:23:03
En la subclase lo tienes que implementar 00:23:11
Obligatoriamente 00:23:13
Desde el momento en que tú pongas 00:23:14
Implements esto 00:23:18
Tienes que hacer esto de aquí 00:23:20
Porque yo estaba pensando que 00:23:23
Lo que hacía Interface 00:23:24
Era que tú hacías un método 00:23:26
En vehículo 00:23:28
Y luego lo podías meter en coche pero luego en motor 00:23:29
O sea el método ese vender 00:23:32
Yo lo podría hacer en vehículo 00:23:35
A ver 00:23:36
Si lo haces aquí en vehículo 00:23:40
Como abstracto, lo puedes, pero es que entonces 00:23:43
Bueno, como sea 00:23:45
Ya, pero el problema es que entonces lo va a tener alguien 00:23:47
Que no lo quiere 00:23:49
Cualquiera que herede de vehículo 00:23:50
Aquí el tema es dar flexibilidad 00:23:52
Hay muchas cosas que son vehículo 00:23:54
Y tienen que estar ahí 00:23:57
Porque hacen cosas de vehículo 00:23:58
Como pintarse, lo que sea 00:24:00
Pero claro 00:24:03
si pones aquí vender 00:24:05
también te queda aquí un vender 00:24:06
y eso no, eso solo 00:24:09
los que sean vendibles 00:24:11
¿vale? entonces al final 00:24:12
realmente las clases se relacionan 00:24:15
de una manera, de una jerarquía muy rara 00:24:17
tú heredas de algo pero luego 00:24:19
implementas un montón de cosas que a su vez 00:24:21
implementan otras cosas que no heredan de ti 00:24:22
porque en esta aplicación 00:24:25
podría haber otra jerarquía que no fueran vehículos 00:24:26
que fueran 00:24:29
empleados, y los empleados 00:24:31
pues aquí tratamos 00:24:33
con los empleados una trata de esclavos 00:24:35
y tú los puedes vender también, entonces el empleado 00:24:37
crearía de empleado 00:24:39
podría implementar vendible también 00:24:41
entonces pueden implementar 00:24:43
la interfaz, clases que 00:24:45
a su vez no heredan de la misma superclase 00:24:47
por supuesto, vale 00:24:49
y luego bueno 00:24:52
hay pequeños detalles ya de 00:24:58
sintaxis 00:25:00
ya de que son detalles 00:25:01
lo que nos importa es la idea 00:25:03
que bueno, que menciono un poco 00:25:05
Pues, por ejemplo, en las interfaces, por supuesto, no se pueden declarar propiedades porque la interfaz no es algo que se pueda instanciar. O sea, la interfaz no refleja un estado, no describe a nada. La interfaz está pensada solo para describir un comportamiento, un rol. Luego, aquí propiedades nunca se pueden poner. 00:25:07
Pues vendible 00:25:31
Int, vendedor 00:25:34
Propiedades como de cualquier 00:25:36
Como haces en cualquier otra clase 00:25:38
No, parámelos 00:25:39
Propiedades, campos, variables 00:25:44
Como quieras llamarlo, hemos llamado propiedades normalmente 00:25:46
Claro, solo métodos 00:25:48
¿Vale? Salvo 00:25:50
Contenido estático, sí 00:25:52
El contenido estático, sí 00:25:53
Algo estático, sí, porque el estático es como si fuera 00:25:55
Una variable global 00:25:58
entonces si tú quieres reflejar 00:25:59
una información asociada 00:26:02
al rol de vender 00:26:04
siempre y cuando sea común para todo el mundo 00:26:05
para todos los vendedores 00:26:09
para todas las cosas vendibles 00:26:10
que no te sea cada una lo suya 00:26:12
pues entonces lo puedes poner aquí como variable 00:26:14
estática 00:26:16
pero solo estático 00:26:17
admite esto y es una información 00:26:20
común que está ahí recogida 00:26:22
por si alguien no sabe dónde poner 00:26:25
una información común general 00:26:26
pues a lo mejor le pega ponerla aquí 00:26:28
pero no sería nada que describiera 00:26:29
específicamente a cada una 00:26:32
de las cosas vendibles, eso no 00:26:34
¿vale? entonces puede aparecer 00:26:36
ahí algo estático 00:26:38
que se llamaría con el nombre de la interfaz 00:26:40
vendible punto lo que fuera, pues por meter ahí 00:26:42
información, eso sí se puede 00:26:44
lo estático no se hereda, o sea cuando 00:26:45
uno pone implements 00:26:48
lo estático no se lo 00:26:49
queda 00:26:52
el que implementa, lo estático no se 00:26:52
queda, entonces imaginaos que hay una 00:26:56
variable estática x 00:26:58
aunque coche 00:27:00
implement vendible, yo no puedo 00:27:02
decir coche punto x 00:27:04
tendría que decir vendible punto 00:27:06
x, vale, lo estático 00:27:08
pertenece a la interfaz 00:27:11
solamente, no se hereda 00:27:12
y al igual que hay variables 00:27:14
estáticas puede haber propiedad 00:27:16
métodos estáticos 00:27:18
que trabajen con esas propiedades por si por 00:27:19
alguna razón, yo que sé, hay una utilidad 00:27:22
una utilidad general 00:27:24
con esta variable 00:27:26
una utilidad que a mí me interesa usar 00:27:28
que es absolutamente independiente 00:27:30
de los objetos 00:27:33
que está relacionada con este rol 00:27:34
pues yo que sé, pero no tiene que ver 00:27:37
con los objetos, pues la puedo meter ahí 00:27:39
y la llamaría con el nombre de la interfaz 00:27:40
vendible punto, la utilidad que fue 00:27:42
pero esa ni se le da ni nada 00:27:44
bueno, pues que lo sepáis, que puede haber contenido estático 00:27:46
ahí 00:27:49
que bueno, normalmente, salvo alguna constante 00:27:49
que me interese 00:27:53
a mí en toda la aplicación, es raro 00:27:55
que las interfaces tengan, usen 00:27:57
eso estático 00:27:58
¿Para los métodos? 00:28:00
¿A los métodos? Sí, claro 00:28:08
Sí, yo aquí los he puesto en vacío por 00:28:09
parámetros, devolver lo que sea 00:28:11
el método puede tener la cabecera que sea 00:28:13
vender podría tener aquí un objeto vendedor 00:28:15
lo que fuera, y devolver a lo mejor 00:28:18
dabble, que fuera el precio que te han dado 00:28:20
claro, claro, la cabecera puede ser cualquiera 00:28:22
¿Vale? El public es 00:28:23
lo que no aparece porque se asume por defecto 00:28:26
siempre. Una casi 00:28:27
última cosa, digo casi porque luego de 00:28:32
interfaces lo interesantísimo 00:28:34
viene cuando las convertimos en 00:28:36
interfaces funcionales. 00:28:38
Pero eso ya es una cosa muy complicada 00:28:40
pero maravillosa 00:28:42
que incorporamos un poco más adelante. 00:28:44
Por eso digo casi lo último 00:28:47
que os quiero decir de interfaces. 00:28:48
Es que desde no sé qué versión 00:28:51
se admite 00:28:52
meter aquí 00:28:54
una versión por defecto. 00:28:56
de los métodos 00:28:58
entonces si uno pone un default delante 00:29:00
de alguno de estos métodos 00:29:02
entonces le puede poner un cuerpo 00:29:03
y ahora esa es una 00:29:06
como si fuera una versión por defecto 00:29:08
entonces las subclases 00:29:10
si no implementan 00:29:12
ese método que 00:29:14
tenga versión por defecto, no están obligadas 00:29:16
se quedan con la versión por defecto 00:29:18
¿vale? 00:29:21
y las que 00:29:23
no estén implementadas 00:29:24
pues esas tienes que implementarlas sí o sí 00:29:26
entonces los default no se usan 00:29:28
mucho porque tienen 00:29:31
cierto peligro, porque si tú haces aquí una versión 00:29:33
por defecto 00:29:35
todas se lo quedan 00:29:35
y ni el compilador ni nadie te avisa 00:29:38
de que hay un método ahí que tienes que sobreescribir 00:29:41
entonces a lo mejor te estás quedando 00:29:42
con una versión por defecto 00:29:45
que luego alguien en otra clase 00:29:46
está llamando a ese método 00:29:48
y no hace exactamente lo que tú querrías 00:29:50
entonces tiene ese peligro 00:29:53
pero a cambio, ¿por qué se incorporó? 00:29:54
porque tiene una ventaja clarísima 00:29:56
y es que 00:29:58
te permite ampliar 00:30:00
código, escalar código 00:30:03
sin tocarte mucho las pelotas 00:30:04
porque yo empiezo aquí a añadir entidades 00:30:06
que todas van a ser vendibles 00:30:08
pero hombre 00:30:10
a lo mejor en algunas de ellas 00:30:12
hay métodos que no 00:30:14
que no quiero sobreescribir todavía 00:30:16
porque no lo sé o porque 00:30:18
pues hombre, si no hay versiones 00:30:20
por defecto en ninguno 00:30:22
cada uno que, pum, implemente 00:30:23
vendible, que se adhiera aquí 00:30:26
todos tienen que implementar el método 00:30:28
vender, todos, todos, todos 00:30:31
entonces el default 00:30:32
me permite que no 00:30:33
tengan que estar todas las clases 00:30:36
que implementan eso, pues poniéndolo 00:30:38
se quedan con su versión por defecto y ya está 00:30:40
pero hay que usarlo con cuidado 00:30:42
hay que tener cuidado en que todo 00:30:44
no genere 00:30:46
efectos extraños 00:30:48
que luego uno ejecuta 00:30:49
la aplicación, la aplicación no da ningún error 00:30:53
de ejecución, todo bien 00:30:54
pero los resultados no 00:30:56
uy, esto no tiene ninguna coherencia 00:30:58
ese es el problema más grave 00:31:00
pues eso se evita 00:31:02
con un diseño cuidadoso 00:31:05
bueno, pues esta es la idea 00:31:09
de interfaces 00:31:12
está claro, ¿no? 00:31:14
tienen la misma ventaja que tienen las superclases 00:31:19
que si algo 00:31:22
implementa una interfaz 00:31:23
lo puedes declarar 00:31:25
como 00:31:26
referencia de esa interfaz 00:31:27
pero bueno, eso vamos a verlo mejor 00:31:32
con un ejemplo 00:31:33
antes de 00:31:35
que nos 00:31:35
volvamos muy locos 00:31:38
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
25 de enero de 2026 - 17:39
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
31′ 44″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.47

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid