Saltar navegación

Interfaces - 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 23 de enero de 2026 por Stefano C.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis, me autorizáis a grabar vuestras voces, ¿vale? 00:00:00
Nosotros hemos visto en episodios anteriores las clases abstractas. 00:00:09
Hemos visto que son clases que pueden incluir algunos métodos del que yo indico el prototipo, 00:00:14
pero sin indicar la implementación, sin indicar el cuerpo. 00:00:25
Yo digo que estas clases van a tener este método, sé cómo se utilizará este método, sé qué parámetros tendrá y sé qué devolverá, pero no sé cómo se hará, ¿vale? 00:00:29
Como es abstracto, la clase es abstracta y por lo tanto no es instanciable, no puedo crear un objeto de esa clase abstracta, no puedo hacer una new de esta clase abstracta, ¿vale? 00:00:42
cualquier clase que herede 00:00:54
que haga un extens de esta clase abstracta 00:00:57
pues tendrá necesariamente que implementar 00:01:01
todos los métodos abstractos de la clase padre 00:01:04
o declararse abstracta a su vez 00:01:09
¿vale? 00:01:13
yo podría extender una clase abstracta 00:01:14
con otra clase abstracta 00:01:17
donde añado más métodos abstractos 00:01:18
voy a hacer 00:01:21
Entonces el hijo de la segunda clase abstracta tendrá que implementar todos los métodos de la primera y todos los métodos de la segunda. 00:01:22
Pero la clase abstracta sigue siendo una clase, o sea que una parte de ella puede ser concreta. 00:01:31
Yo puedo poner algunos métodos que sí implemento allí, algunos constructores que sí implemento allí, 00:01:40
Y algunos métodos que me dejo abstractos. Es un híbrido. Tiene partes implementadas y partes no implementadas. 00:01:47
Cuando yo haré un hijo, cuando tengo una clase, una subclase, pues lo que tengo que hacer es implementar necesariamente los métodos abstractos y los métodos concretos los heredo. 00:01:57
En ese punto puedo decidir si usar directamente esos, si sobreescribirlos, overwrite completamente, 00:02:11
o hacer un overwrite, que es lo que se suele hacer, que como primera línea reúsa el método de mi padre, 00:02:20
o sea, hace esa cosa como si fuera un padre, y luego añade más cosas propias del hijo. 00:02:26
como por ejemplo un método de inscripción 00:02:33
un toString es 00:02:38
asumible que lo que haga 00:02:39
es un toString del padre 00:02:42
super.toString 00:02:43
entonces escribe toda la situación del padre 00:02:45
y a eso le añade 00:02:48
lo propio del hijo 00:02:50
los parámetros propios del hijo 00:02:51
¿dudas? 00:02:54
vale, ahora 00:02:56
puede ser 00:02:57
que haya situaciones 00:03:00
extremas en el 00:03:02
mi clase abstracta solo tenga métodos abstractos, ¿vale? Nosotros hemos visto clases que no 00:03:04
tienen ningún método abstracto, hemos visto clases que tienen algún método abstracto 00:03:12
y alguno no, ¿vale? Podría ser que haya una situación en la que yo defino solo métodos 00:03:16
abstractos. No te digo en ningún caso, oye, mira, este método es así y se hace de esta 00:03:22
forma, porque todos los métodos que estoy haciendo, sustancialmente, tendrán que ser 00:03:27
implementado por mis hijos, no por mí. En ese caso, lo que estoy definiendo no es una propia clase, 00:03:33
pero es un contrato, es un esquema en el que yo te digo, te informo de cuáles tienen que ser los métodos 00:03:43
métodos que va a implementar la clase hija. Te voy a decir, mira, cualquier clase que 00:03:55
implemente mi clase, que extienda mi clase, que herede de mi clase, tendrá necesariamente 00:04:02
que tener el método calcula área que le paso este parámetro, el método calcula perímetro 00:04:09
que no le paso parámetro, el método no sé qué, no sé cuánto. Te estoy haciendo un 00:04:15
listado de lo que podrá hacer cualquiera de las clases que heredan de estas clases abstractas. 00:04:19
Al darse cuenta de eso, Java dice, vale, vamos a hacer así. Ponemos, las clases abstractas tal y 00:04:29
como hemos visto hasta ahora siguen existiendo y son las clases donde yo tengo un poco de clase 00:04:39
desarrollada y un poco de clase 00:04:46
que se me queda así abstracta 00:04:48
y que implementaré en mis hijos. 00:04:50
Pero en el caso en el que quiera 00:04:52
hacer uno de estos contratos, 00:04:54
quiero decir, oye, mirad, 00:04:56
todos los hijos, entre comillas, 00:04:58
que van a tener 00:05:00
relación con este contrato 00:05:01
tendrán que implementar todos estos 00:05:04
métodos sin implementar ninguno. 00:05:06
En vez de hacer 00:05:09
una clase, la voy 00:05:10
a llamar interfaz. 00:05:12
¿Vale? 00:05:15
¿Tenéis una idea de que es una interfaz, no necesariamente informática, aunque se usa mucho en informática, en general, una interfaz de usuario, una interfaz de la televisión? 00:05:15
¿Qué es una interfaz? 00:05:30
Algo como muy visual para el humano, en el que es accesible para el público. 00:05:32
¿Pero para qué sirve? 00:05:42
Es, digamos, una estructura, un mecanismo que permite a alguien interactuar con otro alguien. 00:05:48
La interfaz de la televisión, hago para decir, o del móvil, o qué sé yo, 00:05:59
pues a los infinites son una serie de puntos, de botones, 00:06:04
que permiten a un usuario interactuar con el sistema operativo. 00:06:07
Tú me das una serie de opciones que yo puedo pinchar o puedo seleccionar para que tú hagas algo. 00:06:11
Si algo está en la interfaz, lo puedo hacer. 00:06:18
Si algo no está en la interfaz, no. 00:06:22
Si vosotros pensáis al Windows, el Windows tiene una serie de botoncitos, el botón de inicio, el botón de icono, el botón de no sé qué. 00:06:27
y esos son los comandos 00:06:35
que os permite hacer por debajo 00:06:37
Linux transformará 00:06:39
esta interfaz de Windows 00:06:41
esta interfaz de usuarios 00:06:43
en comandos para el kernel 00:06:44
del sistema operativo para que haga lo que 00:06:47
tiene que hacer 00:06:49
entonces tengo una interfaz de usuario 00:06:50
los botoncitos es bonito 00:06:53
en Linux esta interfaz 00:06:54
de usuario existe 00:06:57
pero muchas veces luego te la saltas 00:06:58
y te vas directamente a la interfaz 00:07:01
textual 00:07:03
que es el CMD, el PowerShell, ¿vale? 00:07:03
De Windows, pues en Linux se usa mucho más 00:07:08
y allí lo que haces es otra forma de interactuar, 00:07:11
es otra interfaz que en vez de botoncitos 00:07:14
tienes comandos largos así, 00:07:17
que tanto gustan a los frígidos de Linux, 00:07:20
pero a pocos a los que les gusta Windows, 00:07:23
porque es más fácil darle a un botón 00:07:25
que escribir un comando así, ¿vale? 00:07:27
Pero son interfaces iguales. 00:07:28
Una es una interfaz gráfica, 00:07:30
Una es una interfaz textual. Es siempre un puente entre alguien que quiere usar algo más y usa esto. ¿Qué será una interfaz aquí? Pues lo mismo. Es crear un puente, un menú de, oye, mira, la clase que implementará esta interfaz, pues podrá hacer estas cosas. 00:07:32
Cualquier clase que tú me digas que implementa esta interfaz, 00:07:57
tendrá estos métodos y tú los vas a utilizar. 00:08:00
¿Cómo? Pues está escrito aquí. 00:08:03
Está el menú, están los prototipos de los métodos que vas a poder utilizar. 00:08:05
Entonces, con los prototipos de los métodos, tú sabes cómo utilizarlo. 00:08:11
Está la cálcula área que te va a dar un double, tú sabes cómo usarlo. 00:08:14
Está la cálcula perímetro que te va a dar un int, pues tú sabes cómo utilizarlo. 00:08:18
¿Vale? Cualquier clase que implemente esta interfaz tendrá que implementarlo y por lo tanto tú podrás llamar estos métodos sobre esta interfaz. 00:08:21
Te estoy definiendo cómo se usa la clase. 00:08:31
Estoy haciendo un contrato que dice cualquier clase que cumpla con este contrato podrá hacer estas cosas, tendrá estos comportamientos. 00:08:36
pero en abstracto 00:08:44
porque no sé cómo se hace 00:08:47
no sé cómo lo va a hacer 00:08:49
yo sé que va a calcular su perímetro 00:08:52
triángulo 00:08:54
cuando implementará la interfaz 00:08:55
geometría 00:08:57
pues seguramente tendrá 00:08:59
cálculo a perímetro y cálculo a área 00:09:01
¿cómo se hace? no lo sé 00:09:03
quien implemente triángulo lo tendrá que implementar 00:09:04
pero sé que tendrá estas dos opciones 00:09:07
¿se entiende? 00:09:09
es una clase abstracta 00:09:13
pero con todo abstracto, ¿vale? 00:09:15
Y entonces deja de ser una clase, entre comillas, 00:09:18
y se transforma en una interfaz, ¿vale? 00:09:21
Es un concepto similar a una clase abstracta, 00:09:24
es decir, un molde que define una estructura formal de métodos 00:09:26
para una clase, aunque no especifica su código, ¿vale? 00:09:30
Se quedan siempre abstractos. 00:09:35
Sirven para implementar un mecanismo similar a la herencia múltiple 00:09:38
con otros lenguajes orientados a objetos en Java. 00:09:41
Hemos dicho que Java hereda solo de una clase, de una clase, se abstracta uno. 00:09:44
Puedo hacer extends de una sola clase. 00:09:51
Sin embargo, de las interfaces, puedo implementar todas las interfaces que me da la gana. 00:09:54
Entonces, si yo siempre podré tener un clase no sé qué, extend no sé cuánto, 00:10:00
implements, que es la palabra que sirve para implementar las interfaces, 00:10:06
y cuántas interfaces me da la gana. 00:10:12
No sé qué, coma no sé cuánto, coma no sé cuánto. 00:10:15
De esta forma yo, heredar como tal y heredar métodos E, 00:10:18
pues lo haré de una sola clase. 00:10:22
Si no digo nada, lo haré de objeto. 00:10:24
Pero luego, firmar contratos diciendo que mi clase va a implementar 00:10:26
este método, este método, este método, 00:10:31
podrá hacer estas cosas, esta cosa, esta cosa, 00:10:33
crear la interfaz de mi clase, crear lo que pueda hacer mi clase, 00:10:34
Pues eso de allí lo puedo hacer con cuantos contratos me da la gana. 00:10:39
Puedo firmar cuantos contratos me da la gana. 00:10:44
Puedo implementar tantas interfaces cuanto me dé la gana. 00:10:46
¿Dudas? 00:10:51
Ok. 00:10:53
Se parecen al caso de Stata, pero a diferencia de estas, todos sus métodos son obligatoriamente abstractos. 00:10:55
Y como todos son abstractos, no ponemos el abstracto. 00:11:01
¿Vale? Cuando yo declaro una interfaz, 00:11:04
hace falta que ponga este método de abstracto, este método de abstracto, lo sé que son abstractos, son todos 00:11:07
abstractos. ¿Vale? Mientras en una clase normal 00:11:11
los métodos por defecto son concretos 00:11:15
y si lo quiero abstracto lo indico, en una interfaz 00:11:19
todos los métodos por defecto son abstractos. Por lo tanto, no lo indico. 00:11:23
¿Sí? Por lo tanto, no hay que escribir abstracto 00:11:28
en ningún sitio porque se sobreentiende que todos lo son. 00:11:33
dudas, entonces declaran utilizando la palabra interface en lugar de class, o sea public interface 00:11:36
nombre de mi interfaz, vale, abro llave, pongo todos los prototipos abstractos pero sin poner abstract 00:11:48
de los métodos que implementa esta interfaz, cierro y ya, lista la interfaz, cuando otra clase 00:11:57
implements la interfaz 00:12:06
que he creado, pues tendrá 00:12:08
que implementar todos los 00:12:10
métodos que yo he declarado dentro 00:12:12
de mi interfaz. 00:12:14
¿Dudas? 00:12:16
Sí. 00:12:18
¿Con esto conseguimos 00:12:19
que cuando acercamos el programa 00:12:22
nos salga como una pantallita para 00:12:24
interactuar con botones o no tiene nada que ver? 00:12:26
No tiene nada que ver. 00:12:28
El ejemplo que he hecho antes de interfaz es para que 00:12:29
entendáis el concepto de interfaz que estoy 00:12:31
creando. Pero esta no es una interfaz gráfica. 00:12:33
es una interfaz entre objetos vale como la televisión te proporciona a ti una 00:12:36
serie de opciones para que tú interactúe con ellas pues mi objeto proporcionará 00:12:42
una serie de métodos para que otros objetos interaccionen con él vale pero 00:12:46
estos métodos no son visuales la cuadra botoncitos y cosas y lo veremos en tercer 00:12:50
trimestre en gráfica de user interface 00:12:56
Entonces, para crear una clase que escriba código para los métodos de una interfaz, 00:13:00
se usa la palabra implements en vez de extends. 00:13:09
Entonces, yo puedo crear una interfaz poniendo public interface, nombre de la interfaz, bla 00:13:12
bla bla. 00:13:18
Si otra persona crea una clase que quiere implementar esa interfaz, pues lo que hago 00:13:19
es public class 00:13:24
cocodrilo 00:13:26
implements 00:13:28
animal. 00:13:30
Si la interfaz se llama animal. 00:13:32
¿Sí? 00:13:35
Entonces, se extiende 00:13:36
en otra clase, abstractas o no, 00:13:38
se implementan 00:13:40
interfaces. 00:13:41
¿Tú das? 00:13:44
¿Qué quería decir yo? 00:13:47
¿Qué se me ha quedado? 00:13:49
Ah. 00:13:51
Muchas interfaces 00:13:53
tienen un nombre 00:13:54
que acaba en able. 00:13:56
Comparable. 00:13:59
Serializable. 00:14:03
¿Vale? Porque sustancialmente 00:14:05
es como decir, si tú implementas 00:14:07
esta 00:14:09
interfaz, adquieres 00:14:09
la posibilidad de compararte 00:14:13
con otro. Comparable. 00:14:15
Adquieres la posibilidad de 00:14:17
serializarte, mandarte por internet. 00:14:19
Serializable. 00:14:21
Entonces, no es normal, hay otras distintas, pero veremos muchos, veremos que existe la 00:14:22
posibilidad de decir que cuando tú creas una interfaz o implementas una interfaz de 00:14:33
las bien conocidas, pues éstas serán interfaz que acaban en able. 00:14:38
También si ves un nombre de una clase o interfaz que acaba en able, pues planteas la posibilidad 00:14:45
que probablemente es una interfaz. Pero bueno, no es una regla escrita en la pieza. 00:14:50
Se pueden declarar referencias a objetos cuyo tipo sea una interfaz en lugar de una clase. 00:14:56
¿Qué quiere decir? Si yo tengo la interfaz animal, que ya hemos llamado, animal, animal, animal, ¿vale? 00:15:05
puedo hacer 00:15:18
animal x 00:15:21
es igual a new cocodrilo 00:15:22
tengo 00:15:25
class cocodrilo 00:15:30
implement animal 00:15:32
puedo hacer animal x 00:15:33
es igual a new cocodrilo 00:15:36
si, es lo que dice aquí 00:15:37
puedo crear una referencia 00:15:41
a un objeto cuyo tipo sea 00:15:44
un interfaz, o sea animal x 00:15:46
vale, pero luego 00:15:49
dentro tendré que poner un new cocodrilo 00:15:50
puedo poner new animal 00:15:52
hacer animal 00:15:54
x es igual a new animal 00:15:57
¿por qué no? 00:15:58
porque como no podía hacerlo 00:16:05
con la clase abstracta, tampoco lo puedo hacer con la interfaz 00:16:06
¿por qué? porque todos sus métodos son abstractos 00:16:09
no puedo crear 00:16:11
una instancia de una interfaz 00:16:12
puedo crear referencias 00:16:14
de tipo interfaz 00:16:17
pero no puedo crear 00:16:18
no puedo crear 00:16:20
objetos 00:16:22
con interfaz 00:16:23
Y, a partir de allí, todo lo que sabemos del polimorfismo de la parte de clases de estratos se aplica también a la interfaz. 00:16:25
Aquí yo puedo hacer un array de animales y poner dentro cocodrilos y gatos y perros y luego recorrer animales y hacerlos todos hacer su sonido, porque está en animal está el método hacer sonido, pero el perro, el gato lo habrá implementado como miau, 00:16:36
El perro lo habrá implementado claramente como bau, porque es italiano, ¿vale? 00:17:00
Y el cocodrilo lo habrá implementado como... 00:17:08
Es una grande pregunta, en que en italiano hasta tenemos una canción, 00:17:13
que os cantaría, pero no, porque eso no ha grabado. 00:17:20
Pero podéis buscarla, el cocodrilo come fa, ¿eh? 00:17:23
Mucho en eso no que lo sabe. 00:17:26
Muy bien 00:17:28
Esta forma de proceder 00:17:30
Tiene sentido para definir un objeto 00:17:33
En función de un tipo más genérico 00:17:35
Para utilizar mecanismos como el polimorfismo 00:17:37
Su principal función es establecer 00:17:40
Y estabilizar las interfaces 00:17:43
Prototipos de métodos de una clase 00:17:45
Que está por desarrollar 00:17:47
Y así coordinar varios equipos de trabajo 00:17:50
¿Qué quiere decir esta frase? 00:17:52
Una cosa importante 00:17:53
Con esto de la interfaz 00:17:54
Yo puedo organizar equipos de trabajo sin tener listo lo que voy a tener listo en un futuro, 00:17:56
pero sin bloquear los equipos de trabajo, no puedo seguir adelante. 00:18:06
O sea, si yo pillo una interfaz, la interfaz animal, y se la doy tanto a los desarrolladores de animales 00:18:12
como al desarrollador 00:18:18
de parque natural 00:18:20
¿vale? 00:18:22
el desarrollador de parque natural 00:18:23
interactuará con los animales 00:18:25
usando su interfaz 00:18:28
podrá hacer con los animales 00:18:30
lo que la interfaz dice 00:18:32
que pueden hacer los animales 00:18:34
sin saber luego cómo lo hacen 00:18:35
no se han implementado todavía los métodos 00:18:38
pero yo sé que puedo hacer 00:18:40
un array de animales y pedirle 00:18:42
que coman, pedirle que corran 00:18:44
pedirle que hagan su sonido. ¿Vale? Cuando luego el otro equipo de trabajo habrá generado cocodrilo 00:18:46
que implementa animal, gato que implementa animal y perro que implementa animal, yo dentro de mi 00:18:55
parque natural podré utilizar gato, perros y cocodrilos metidos en arrays utilizándolos con 00:19:01
referencias de animal. Está claro que no podré hacer lo que hace un gato de verdad, pero podré 00:19:09
Podré utilizar los datos como anual. 00:19:14
¿Se entiende? 00:19:18
Eso es muy importante. 00:19:19
Porque si lo hago bien, estoy definiendo los puntos de contacto entre módulos, 00:19:21
los puntos de contacto, las interfaces entre objetos, 00:19:26
los mensajes que se pueden mandar los objetos, 00:19:30
las acciones que pueden hacer los objetos, 00:19:32
o que un objeto puede pedir a otro objeto. 00:19:35
Las defino sin implementar cómo se hace, 00:19:37
pero defino qué se hace en una interfaz 00:19:40
Y a este punto puedo paralelizar el desarrollo en varios equipos de trabajo. 00:19:44
¿Dudas? 00:19:51
Yo lo que entiendo de interfaz es como que estás separando las clases abstractas 00:19:52
para no mezclar los métodos abstractos dentro de una clase abstracta. 00:19:57
Y los pones en una interfaz y no sé si en una práctica ya vas a usar ambas cosas 00:20:02
o separas los métodos. 00:20:08
Sí y no. 00:20:10
¿Vale? No necesariamente. 00:20:11
O sea, el concepto de clase abstracta sigue existiendo. 00:20:14
A lo mejor tú, cuando nosotros hacemos el vehículo, a lo mejor moverse es abstracto porque cada vehículo se mueve distinto. 00:20:16
Pero velocidad máxima o, no sé, calcula velocidad máxima, imagínate. 00:20:29
Pues eso a lo mejor lo puedes calcular independientemente de qué vehículo sea. 00:20:35
Porque hay una velocidad máxima que es la constante de la luz. 00:20:40
No sé. 00:20:42
Me voy por la rama. 00:20:44
Pero a lo mejor hay cosas que se aplican a todos los vehículos y eso lo implementas ahí. 00:20:44
Hemos hecho algunos ejemplos que hemos desarrollado la cosa allí directamente en la clase abstracta y otras cosas en vez que no. 00:20:49
Pero esas cosas van juntas y yo quiero que estén en el mismo bloque, en la misma clase. 00:20:59
Entonces necesito una clase abstracta, no lo puedo hacer con una interfaz. 00:21:05
Lo digo porque podrías separarlo e igualmente tendrías el mismo resultado. 00:21:08
Lo puede hacer, pero no. 00:21:11
Porque a lo mejor yo no quiero que se pueda crear clases 00:21:13
que tengan la parte de la interfaz sin tener lo que he hecho en la clase abstracta. 00:21:18
Si yo te creo una clase abstracta, cuando tú la extendes, 00:21:25
te traes la parte abstracta que tendrás que implementar, 00:21:28
pero te estás también heredando lo concreto. 00:21:31
Si yo lo he separado en una interfaz, 00:21:35
tú podrías implementar la interfaz sin extender la otra clase. 00:21:37
Entonces, te he dado la posibilidad de implementar lo que tenías que implementar sin haberte llevado el extra. 00:21:41
Pero si yo no quiero que eso pueda pasar, si yo quiero que todo lo que implementen estos métodos abstractos 00:21:49
también tenga este método concreto que se hace así, como por ejemplo el constructor, 00:21:54
para que conte cuántos animales he creado, pues entonces no lo puedo hacer en el extra. 00:21:59
no es que son 00:22:06
o esto o esto 00:22:09
son dos mecanismos 00:22:10
tres, clases concretas 00:22:13
clases abstractas e interfaces 00:22:15
que son 00:22:16
parecidos, son similares 00:22:18
se pueden, cooperan 00:22:21
y hay algunos casos en que necesito una cosa 00:22:22
o una cosa no, las clases abstractas 00:22:25
son más raras que las interfaces 00:22:27
es más probable 00:22:29
encontrar interfaces y hacer lo que dices tú 00:22:31
que me lo separe 00:22:33
cuando quiero añadir un cierto comportamiento 00:22:34
implemento una interfaz y cosas así 00:22:36
que las clases abstractas 00:22:38
pero no es que 00:22:40
las clases abstractas te dan esta posibilidad 00:22:41
de decir en paquete 00:22:44
porque estoy hablando por objetos, cuando modelizo el objeto 00:22:46
pues quiero que todo lo que 00:22:48
representa el objeto y todo lo que esté 00:22:50
relacionado con el objeto esté en la misma clase 00:22:52
entonces le estoy midiendo 00:22:55
cosas concretas que se hace así 00:22:56
con cosas abstractas que dime tú 00:22:58
cómo se hace 00:23:00
entonces es una 00:23:02
filosofía distinta 00:23:03
Estos son términos, más que de programación pura, de diseño. 00:23:05
Entonces, es lo que yo quiero poder hacer con estas clases. 00:23:10
Lo que yo quiero que las clases hijas, las subclases, 00:23:14
quieran hacer con respecto a las otras. 00:23:20
En el constructor también hay mucha diferencia. 00:23:25
En el constructor de una clase de una interfaz, creo que no se puede hacer. 00:23:31
creo que no se puede 00:23:35
implementar un constructor 00:23:38
en un encendido, ahora 00:23:40
lo debería comprobar, pero diría que no 00:23:41
¿vale? ahora de todas formas 00:23:44
al final de esto hay un par de transparencias 00:23:46
de que diferencia hay entre interfaz 00:23:48
de clases abstractas y a lo mejor 00:23:50
allí descubrimos algo 00:23:52
¿vale? 00:23:53
vale, esto es siempre sobre este tema 00:23:59
aquí ¿vale? el equipo que tiene que 00:24:01
utilizar objetos que 00:24:03
implementen dicha interfaz, basta con que 00:24:05
declara en su código una referencia 00:24:07
dicha interface, ¿vale? 00:24:09
O interfaz. 00:24:12
Aunque no está todavía compilada, 00:24:13
ninguna de las clases que la implementa. 00:24:15
O sea, yo trabajo 00:24:17
con la interfaz, cuando 00:24:18
trabajo en mi código, lo que hago 00:24:21
es crear referencias a esta interfaz, 00:24:23
me da igual qué clase esté dentro. 00:24:25
¿Ok? Entonces puedo 00:24:28
trabajar en paralelo 00:24:29
mientras otro está implementando 00:24:31
clases que implementan 00:24:33
estas 00:24:35
interfaces que luego 00:24:35
serán las que utilizaré de verdad 00:24:38
yo en mi parque 00:24:39
natural estoy trabajando con animales 00:24:42
en un futuro 00:24:44
alguien implementará perro 00:24:47
y entonces cuando llamo cosas 00:24:48
sobre animales pues lo ejecutará este perro 00:24:50
creará gatos 00:24:53
y entonces trabajará con gatos 00:24:54
creará lince pues trabajaré también con las lince 00:24:56
pero desde mi 00:24:58
programa, desde la perspectiva 00:25:00
del parque natural estoy trabajando con animales 00:25:02
los equipos que creen clases 00:25:04
que implementan dicha interfaz están a su vez 00:25:10
desacoplados de los 00:25:12
equipos que la utilizan y pueden escribir 00:25:14
sus códigos independientemente 00:25:16
tengo una independencia 00:25:18
un desacoplamiento que es interesante 00:25:20
dentro del mundo de la informática 00:25:22
porque me evita 00:25:24
vínculos, me evita dependencias 00:25:26
y por lo tanto puedo paralelizar 00:25:28
cuanto más paralelizo, más puedo avanzar 00:25:30
rápidamente 00:25:32
Cuanta más codependencia tengo entre dos módulos o dos bloques, peor es el desarrollo porque hasta que él no ha hecho esta parte no puedo seguir adelante. 00:25:33
Si fuera necesario que exista un objeto real detrás de una referencia o una interfaz que todavía no se ha programado el otro equipo, se podría utilizar un objeto mock. 00:25:43
mock es como falso 00:25:55
es como 00:25:57
de mentira 00:25:57
y es una técnica que se hace 00:26:02
a lo mejor yo tengo que probar mi mecanismo 00:26:04
pero no lo puedo probar porque tengo solo referencias 00:26:07
animal y necesito 00:26:09
un objeto que haga algo 00:26:11
pues me implemento una clase 00:26:13
yo que implementa 00:26:15
animal pero que hace solo 00:26:17
métodos mock 00:26:19
que dice el animal 00:26:20
está hablando cuando hace su sonido 00:26:22
el animal se está moviendo cuando 00:26:24
podamos mover. No está haciendo 00:26:26
de verdad las cosas, pero me está 00:26:28
mandando mensajes para ver 00:26:30
si esto funciona. Cuando yo llamo las cosas 00:26:32
pues me da un retorno de 00:26:34
un son básico falso 00:26:36
que no es real. A lo mejor 00:26:38
hay un método que debería 00:26:40
acceder a una base de datos. Si todavía no está 00:26:42
lista toda esa parte allí, pues simplemente 00:26:44
me devuelve datos falsos como si lo hubiese 00:26:46
pillado de una base de datos. 00:26:48
Pero me devuelve siempre los mismos métodos en vez 00:26:50
de ir a acceder a un 00:26:52
acceso a la base de datos. ¿Entiendes? Son todos mecanismos para poder programar en equipos 00:26:54
desacoplados y poder ir en paralelo. Un ejemplo concreto de una interfaz que será vuestro íncubo 00:27:01
en los próximos días es la interfaz Comparable. Sirve para dotar de un orden natural a los 00:27:10
objetos de una clase determinada. Por ejemplo, imaginaos que yo tengo 00:27:20
la clase gato, muchos gatitos, con dentro sus propios 00:27:24
atributos de gato, ¿vale? El nombre del gato, 00:27:28
la raza del gato, la guapura del gato, que siempre es 10, 00:27:32
porque son los animales más bonitos, pues, ¿qué se le va a hacer? 00:27:35
Ahora, imaginaos que yo quiera ordenar los gatos, 00:27:40
¿vale? Como es una cosa que creo yo, 00:27:44
yo tengo que definir cuál es el concepto 00:27:48
de orden de gato. ¿Cómo se ordenan los gatos? 00:27:52
¿Se ordenan por nombres? ¿Se ordenan por guapura? ¿Se ordenan por raza? 00:27:55
No lo sé. No tienes que decir tú. Como yo he creado 00:28:00
este objeto, que puede ser gato, puede ser otra cosa, puede ser coche. 00:28:04
¿Cómo ordeno los coches? ¿Vale? Pues tengo que 00:28:08
definir cómo se ordenan los coches. Para eso 00:28:12
pues implemento 00:28:15
la clase, la interfaz 00:28:17
comparable. Todas 00:28:20
aquellas clases que implementan 00:28:21
la interfaz comparable 00:28:23
adquieren la capacidad 00:28:25
de poder comparar 00:28:28
dos objetos de esa clase 00:28:29
y decir, este viene antes 00:28:31
que este. 00:28:33
¿En base a qué? En base a la definición 00:28:35
de orden que yo definiré 00:28:38
en comparable. 00:28:40
¿Está claro? 00:28:42
O sea, si yo digo los números 00:28:44
pensad en la clase number que existe 00:28:45
o la clase integer 00:28:48
la hemos usado, integer.parts.int 00:28:50
que representa los enteros 00:28:52
vosotros me sabéis ordenar 00:28:55
el integer o el objeto integer 3 00:28:56
y el objeto integer 5 00:28:59
¿cuál viene antes? 00:29:01
3, ¿por qué? 00:29:02
porque el orden de los números los tenemos aquí 00:29:04
pero cuando voy a comparar 00:29:07
dos mochilas 00:29:09
¿viene antes esta mochila de aquí 00:29:11
o esta mochila de aquí? 00:29:13
No sé. Hay dos opciones. O no hay un orden y entonces no implemento comparable y no puedo establecer cuál viene antes. O implemento comparable, me dirá que tengo que implementar el método compareTo, que es el método que está dentro de comparable, solo como productivo. 00:29:14
es abstracto, lo tengo que implementar yo, y dentro de la implementación de este de aquí, 00:29:42
tengo que pillar estas dos mochilas y decidir cuál viene primera y cuál viene segunda, 00:29:47
en base a lo que yo he decidido que es el orden. Para mí el orden puede ser el color. Lo paso a 00:29:52
hexadecimal, miro cuál es el que viene antes, en base a eso, pues si viene antes o una otra. 00:30:02
si pillo negro, que es 0, 0, 0, 0, 0 00:30:10
y otra mochila que es blanca, que es 00:30:17
negro viene antes que blanco 00:30:19
porque es un número hexadecimal más bajo 00:30:21
lenguaje de marcas 00:30:24
pero no, digo, no 00:30:27
lo quiero ordenar por 00:30:33
capacidad 00:30:35
pues capacidad 00:30:36
entonces miro esto de aquí, esto tiene 00:30:40
13 litros, este tiene 12 litros, pues 00:30:42
este viene antes que este. 00:30:44
Lo quiero ordenar por 00:30:49
nombre de la marca. Pues esta aquí es 00:30:51
marca, no tengo ni idea. Esa es marca 00:30:53
otra marca, pues 00:30:54
viene antes que O, por lo 00:30:58
tanto viene antes el de, no sé su 00:31:01
marca, que el de otra marca. 00:31:02
¿Se entiende? 00:31:06
¿Quién define esto? Yo. ¿Por qué? 00:31:06
Porque soy yo el que crea esa clase. 00:31:09
He creado esta clase, he definido 00:31:11
que va a poder ser comparable, 00:31:13
o sea, que yo puedo pillar dos objetos 00:31:15
entre ellos y puedo comparar quién viene 00:31:17
antes y quién viene después, porque luego 00:31:18
los quiero ordenar, dame una definición 00:31:20
de orden. 00:31:23
Es parecido este problema 00:31:24
a cuando veíamos el equals. 00:31:26
¿Verdad? Que nosotros decíamos, tengo 00:31:29
dos objetos, pues tengo que definir 00:31:30
la relación de identidad. ¿Cuándo estos 00:31:33
dos objetos son iguales? ¿Cuando tengan el mismo 00:31:35
DNI? ¿Cuando tengan el mismo DNI 00:31:36
en nombre? ¿Cuando tengan el mismo...? 00:31:38
¿Sí? Pues aquí es lo mismo. 00:31:41
Cuando comparo dos objetos, ¿cómo se comparan estos señores? 00:31:43
Se comparan en base a su nombre, su color, su... 00:31:47
Pero el concepto fundamental es que cuando yo quiero comparar, 00:31:52
quiero que mis objetos sean comparables, 00:31:56
lo que hago es implementar, public class, ya habíamos dicho, 00:32:00
implements comparable. 00:32:04
Esto me fuerza a implementar el método compareTo. 00:32:07
Compertur necesita dos elementos 00:32:11
Por un lado, el objeto 00:32:19
Que es un objeto de los dos que voy a comparar 00:32:22
¿Vale? 00:32:27
Tú me pasas, me dices, compáralo a este señor 00:32:28
Vale, ok, perfecto 00:32:32
Lo voy a comparar con este objeto de aquí 00:32:33
¿Vale? 00:32:35
Es el segundo objeto 00:32:36
¿Cuál es el primero? 00:32:37
Sobre el que se llama método 00:32:43
es decir? No, ese es el segundo. ¿Cómo hago referencia al objeto sobre el que se ha llamado 00:32:44
el método? This. O sea, que este método de aquí está haciendo una comparación entre 00:32:58
this y el objeto. Entonces, aquí dentro, en la implementación del compareTo, yo tendré 00:33:04
dos opciones. Acceder a this.nombre y a objectO, ¿no? O.nombre para comparar los nombres. 00:33:15
o a dis.color y a o.color para comparar los colores, o a las dos cosas. 00:33:24
Aquí tengo que compararlo solo según un factor. 00:33:32
Yo podría decir que se ordenan como primer factor según el color, 00:33:36
y si dos tienen el mismo color, según la capacidad. 00:33:40
Lo codifico. 00:33:44
Tened en cuenta, pero, que aquí yo estoy comparando un dis, 00:33:47
que en mi ejemplo era un gato 00:33:53
con un objeto. 00:33:55
El gato tiene nombre 00:33:58
y tiene raza y tiene 00:33:59
guapura, ¿no? 00:34:01
Pero objeto no. 00:34:03
Objeto no tiene nombre. Si yo hago 00:34:05
o.nombre no me funciona. 00:34:07
Entonces, ¿qué tendré que hacer? 00:34:09
Pero yo tengo 00:34:19
un disk que seguramente es un gato, porque estoy 00:34:20
dentro de gato. Y un objeto. 00:34:22
¿Qué hago con este objeto? 00:34:24
Os lo mimo si queréis. 00:34:26
Downcasting. 00:34:40
Eso ha sido porque lo han animado muy bien, ¿verdad? 00:34:42
Downcast. Lanzar casting. 00:34:46
Muy bien. Tengo que hacer un downcasting, o sea, pillar... 00:34:51
Por un lado tengo el disc que es un gato. 00:34:55
Ahora tengo un objeto O. 00:34:57
Este objeto O tendré que hacer un downcasting a gato, si puedo. 00:34:59
¿Vale? Y a este punto... 00:35:04
Tened en cuenta que si yo intento comparar un gato y le paso como parámetro aquí un cocodrilo, 00:35:07
pues tiene que explotar algo, porque gatos y cocodrilos no se pueden comparar. 00:35:15
¿Qué viene antes? ¿3 o K? 00:35:20
¿3 como entero o K como letra? 00:35:24
Vale, entonces, además, la interfaz comparable me dice, 00:35:33
oye mira, tengo este método, lo tienes que implementar así, no es que hay que ponerle gato, 00:35:38
no, tiene que ser int compareObject.Dentro harás un, si yo, una, como se dice, un instance of gato, 00:35:44
pues entonces da un cast a gato y haz lo que tienes que hacer, si no explota. Vale, y además 00:35:58
de decirme el método que tengo que implementar, me describe cómo se implementa. O sea, cuando yo 00:36:05
implemento con Parable y tengo que implementar este método, tengo que cumplir esta regla. Tengo 00:36:13
que dar un número negativo si this es menor que o. Si en el orden viene antes this y luego o, 00:36:21
el resultado tiene que ser negativo 00:36:34
si son iguales 00:36:36
a nivel de orden 00:36:40
por ejemplo tienen el mismo color entonces son iguales 00:36:42
hasta si son objetos distintos pero 00:36:44
a nivel de ordenación da igual si viene 00:36:46
uno antes, pues tendré que devolver 00:36:48
cero 00:36:50
y si this viene después 00:36:51
de o 00:36:54
pues entonces tengo que dar 00:36:56
un número positivo 00:36:58
este número positivo puede ser 00:36:59
o simplemente menos uno cero 00:37:02
y 1. Suficiente. 00:37:03
Pero si yo devuelvo siempre 00:37:06
menos 1, 0 y 1, 00:37:07
no sé cuánto distintos son. 00:37:09
Imaginaos siempre 00:37:14
con los colores. Si yo tengo 00:37:15
negro y blanco estando al extremo, 00:37:17
son muy distintos. 00:37:19
Pues, y imaginamos que 00:37:21
this sea negro y o 00:37:23
sea blanco, pues entonces 00:37:25
como this viene antes que o, 00:37:27
me devolvería menos 1. 00:37:29
Y ahora tengo 00:37:31
this que es negro y 1 00:37:32
que es gris, ¿qué me devolvería? 00:37:35
Siempre menos uno. Porque dices 00:37:41
negro, viene antes que el gris. Por lo tanto, siempre 00:37:44
menos uno. O sea, que sea muy cerca, 00:37:47
que sea un gris muy oscuro, sea un gris muy claro, o sea 00:37:50
blanco, siempre me devuelve menos uno. No sé a qué distancia 00:37:52
están. No sé cuánto distinto son. 00:37:55
¿Lo sé ordenar? Sé que negro viene antes que gris, 00:37:58
pero no sé cuánto antes. 00:38:02
Si en vez me busco otra forma, por ejemplo, hago 00:38:04
una resta entre 00:38:07
el número 00:38:09
en esta decimal 00:38:10
y el otro número en esta decimal. 00:38:13
Los restos. 00:38:16
Entonces, cuando hago 0, 0, 0 00:38:17
que es negro menos un gris, 00:38:19
me dará un valor negativo, 00:38:21
pero más pequeño, 00:38:24
o sea, más grande, 00:38:25
que si hago 0 00:38:26
menos el blanco, 00:38:29
que es el máximo número que tengo que hacer. 00:38:32
O sea, 0 menos gris 00:38:33
me dará menos 50 00:38:35
hago para decir, y 0 menos 00:38:37
blanco me dará menos 00:38:39
5.000. Entonces sé que hay una 00:38:41
diferencia. Los dos son negativos, sé 00:38:43
quién viene antes y quién después, pero además 00:38:45
me da una indicación de cuánto antes 00:38:47
o después llega. ¿Se entiende? 00:38:49
Esto depende 00:38:53
de cómo lo hago. No me lo dice aquí. 00:38:53
No me dice, oye, mira, tienes que 00:38:55
decir cuánto antes y cuánto después. 00:38:57
No. A mí lo importante es que siga 00:38:59
esta regla. Lo que está diciendo 00:39:01
es que dependiendo de cómo lo digo, 00:39:03
de cómo lo hago, puede tener 00:39:05
más o menos información 00:39:07
este número negativo. 00:39:08
O positivo. 00:39:11
¿Vale? 00:39:13
Es muy recomendable 00:39:13
que con perturbe 00:39:15
sea consistente 00:39:16
con igual. 00:39:17
O sea, 00:39:20
si yo tengo 00:39:21
dos objetos 00:39:22
pero me está de vez, 00:39:25
si tengo dos objetos 00:39:26
que igual 00:39:27
se me dice true, 00:39:28
pues también 00:39:31
con perturbe 00:39:32
tiene que estar cero. 00:39:33
¿Ves? 00:39:37
No. 00:39:37
No es necesario. 00:39:38
Pero si dos objetos son el mismo objeto, su comparable, o sea, su convertu, tiene que dar cero. 00:39:40
Si son el mismo objeto, no puede ir uno antes que otro. 00:39:49
Ahora, si dos objetos como convertu dan cero, podrían no ser iguales. 00:39:52
Por ejemplo, mis mochilas negras. 00:39:59
Tengo dos objetos que son mochilas negras, son distintas, pues a nivel de convertu no hay uno que viene antes que otro, pero no son el mismo objeto. 00:40:01
Por lo tanto, equals daría false. 00:40:10
¿Entiendes? 00:40:15
Esto es una cosa que tenéis que considerar. 00:40:17
Si implementáis comparable, tenéis que toquetear también equals. 00:40:18
Y definir que si dos objetos son equals, cuando dos objetos son equals, pues comparable tiene que devolverse. 00:40:23
Ejemplo. 00:40:33
¡Ejemplo! 00:40:39
¡Uy, ejemplo animal! 00:40:40
Fíjate tú, no me acordaba que aquí era un ejemplo de un animal. 00:40:42
Pues, public interface animal, ¿vale? Convoida habla, ¿cómo no? 00:40:45
Public class perro, implementa animal, ¿vale? 00:40:49
Fijaos que es una interfaz, ¿vale? 00:40:53
Entonces, esto quiere decir que tengo que implementar necesariamente habla. 00:40:55
Entonces, hago guau, ¿vale? 00:40:59
Este es español. 00:41:01
Y luego tengo gato, que como animal hace miau, ¿sí? 00:41:04
Entonces, ¿cómo lo uso? 00:41:07
Puedo crear un animal con dentro un perro, un animal con dentro un gato y hacer dog.habla cat.habla. 00:41:09
Puedo crear un array de animales con dentro ponerle un gato y perro tranquilamente. Luego 00:41:19
hago que hablan todos y le paso el array de animales. Entonces este es un método que hablen 00:41:27
todos con un array de animales. Lo que hace es recorrer el array y llamar el habla. Aquí no 00:41:32
necesita hacer downcasting ni nada por 00:41:40
porque usa 00:41:42
polimorfismo 00:41:45
y entonces cuando yo lo llamaré 00:41:47
sobre un animal.habla 00:41:50
aun si un animal es de tipo animal 00:41:52
se usará el habla 00:41:54
de la instancia 00:41:56
de ese objeto, no de la 00:41:58
referencia a ese objeto, entonces 00:42:00
usará o gato o perro 00:42:02
si es un gato o si es un perro 00:42:04
si lo he definido como un gato 00:42:06
dudas, para complicar 00:42:07
un poco las cosas 00:42:17
existen los métodos 00:42:18
default en una interfaz 00:42:20
que es un método default 00:42:23
como en una clase abstracta 00:42:24
los métodos son 00:42:27
normales, pero puedo definir 00:42:28
algunos abstractos 00:42:31
en una interfaz los métodos son 00:42:32
abstractos, pero puedo definir 00:42:34
algunos concretos 00:42:36
entonces 00:42:37
si esta es una interfaz animal 00:42:42
que tiene void habla, este es un método abstracto 00:42:44
¿vale? pero puedo definir 00:42:47
un default void correr, ¿qué me está diciendo? Mira, oye, 00:42:48
todos los animales pueden hablar y correr. 00:42:52
Todos. Porque cuando implementan un animal, estos son los métodos que tiene. 00:42:56
Te voy a dar una implementación 00:43:00
por defecto que tú puedes usar o no. 00:43:05
Si quieres, esta ya la tienes, 00:43:09
pero si luego la quieres especificar 00:43:12
en tu animal, pues lo puedes hacer. 00:43:16
Entonces, por ejemplo, puedo tener un perro 00:43:18
que solo implementa habla 00:43:19
y tiene corre por defecto 00:43:21
pasada, 00:43:24
y puedo implementar un gato que 00:43:25
implementa habla y que 00:43:27
sobreescribe en un cierto sentido 00:43:29
corre. Entonces, cuando luego 00:43:31
lo llamaré sobre un perro, 00:43:33
usará la implementación 00:43:36
por defecto. 00:43:38
Cuando lo llamo sobre el gato, 00:43:40
usará la del gato. 00:43:42
¿La interfaz animal no sería posible en una clase abstracta porque está combinando o es lo mismo? 00:43:46
Es lo mismo. 00:43:52
Pero es lo que decía antes. 00:43:54
Mientras una clase abstracta es una clase que deja abstracto algún método, 00:43:56
la interfaz es, defino todo abstracto y puedo concretar alguno. 00:44:02
Es filosofía un poquito distinta. 00:44:08
La diferencia fundamental es que una clase abstracta solo puede heredar una, 00:44:10
Mientras la interfaz, puedes implementar cuanto sea la gana. 00:44:16
Y acordaos que está también el concepto de ISEP. 00:44:24
Cuando tú creas, cuando tú extendes otro elemento, otra clase, tú eres una diversa clase. 00:44:29
Para crear jerarquía como tú quieras. 00:44:36
Tienes las dos herramientas, al fin y al cabo son muy parecidas. 00:44:39
Y ahora llegamos a ver posibles diferencias. 00:44:42
Pero la esencia fundamental, básica e importante, es que de clases abstractas puedes extender una sola, 00:44:45
de clases de interfaces puedes implementar cuantas quieras. 00:44:53
Es una forma de hacer algo parecido a la herencia múltiple en Java. 00:44:58
No. Es parecido a una clase abstracta. 00:45:03
Sí, no sé si formalmente lo es, debería ser, ¿vale? 00:45:22
No te pide que te lo sacore porque usará su implementación por defecto. 00:45:39
Que, repito, vispa sí, es muy parecido a hacer una clase abstracta donde esto es un método normal, esto es un método abstracto. 00:45:46
¿Sí? El problema es que si tú eres gato y quieres extender felino, ahora tienes un problema si esta es una clase strata, porque no puedes extender también animal, ¿sí? 00:45:52
Y entonces puedes hacer esta trampa de aquí y haces extendo felino e implementa animal. 00:46:09
¿Listo? ¿Dudas? 00:46:17
Clases, estas son las interfaces, ¿vale? 00:46:24
¿Qué problemas, o sea, qué aspectos tenemos que tener en cuenta cuando vamos a mirar clases abstractas y interfaces y qué relaciones tienen? 00:46:28
Juegan en la misma liga, porque son muy parecidas, tienen cosas que no es fácil decir, uso esto, uso otro, cosas por el estilo. 00:46:40
La cosa principal y importante que penséis es que si tengo que extender, si estoy obligado a extender ya una, pues todas las demás tienen que ser interfaces. 00:46:50
Eso es una cosa que me... 00:47:01
Cuando yo tengo que decir, quiero hacer algo de ese estilo, ¿qué hago? ¿Una clase abstracta o una clase interfaz? 00:47:02
En base a eso, tendría que pensar, oye, mira, la clase que luego he heredado aquí, ¿ya he heredado de otras clases o no? 00:47:11
Porque si quiero ir a otra clase, tengo que ir por interfaz de seguro. 00:47:18
Si no, no lo puedo pensar. 00:47:22
Entonces, ¿qué puntos tengo en mente cuando tengo que comparar o pensar si usar una clase abstracta o una interfaz? 00:47:24
Primero, el propósito. 00:47:32
Una clase abstracta se utiliza para proporcionar una estructura básica para una jerarquía de clases. 00:47:34
Mientras que una interfaz se utiliza para definir un contrato que debe cumplirse por una clase que implementa la interfaz. 00:47:42
¿Qué quiere decir? 00:47:51
Cuando se usan clases y clases abstractas y conceptos de herencia, yo estoy creando un árbol de herencia. 00:47:52
Estoy creando clases que tienen que ver una con otra. 00:47:58
Las interfaces suelen ser algo un poco más independiente. 00:48:03
Las interfaces no entran en esta construcción jerárquica que me estoy creando para mi contexto de mi problema, ¿vale? 00:48:07
Yo creo las personas, luego los alumnos, los profesores, todas estas son clases que entran dentro del problema escuela que estoy gestionando, ¿vale? 00:48:15
Entonces, persona la hago abstracta y luego uso solo profesores y alumnos como concretizaciones de esta clase abstracta, 00:48:24
pero están relacionadas entre ellos de esta jerarquía que tienen, etcétera, etcétera, ¿vale? 00:48:33
O empleado, o profesor, o lo que sea, ¿vale? 00:48:39
La clase, la interfaz, no está en esta construcción. 00:48:43
Está un poco más al margen. 00:48:49
Cuando tú dices comparable, ¿vale? La interfaz comparable que permite luego comparar alumnos o comparar profesores, ¿esto dónde la pondríais en esta jerarquía? 00:48:51
A un lado, es como al lado, ¿vale? Un profesor puede implementar comparable, un alumno puede implementar comparable, una persona podría implementar comparable, no lo sé, ¿vale? 00:49:03
si quisiera poder comparar estas cosas. 00:49:13
Como una cosa un poquito al margen, 00:49:16
no está en esta estructura de definición de problema, 00:49:18
del contexto del problema que estoy creando. 00:49:23
Entonces, cuando lo que quiero crear 00:49:25
es un elemento de esta construcción, 00:49:27
es algo que modeliza las entidades 00:49:29
que están trabajando dentro de mi contexto del problema, 00:49:33
pues posiblemente usaría una clase abstracta. 00:49:39
Si en vez de ser algo que puedas reutilizar en otros contextos o en contextos distintos, pues es más intérprete. 00:49:41
¿Sí? Entonces, ¿qué propósito tiene esta nueva cosa que voy creando? 00:49:48
Vaya esto, pues, clases abstractas e intérpretes. 00:49:54
Implementación de métodos. 00:49:58
Una clase abstracta puede proporcionar una implementación para algunos de sus métodos, 00:49:59
mientras que las clases que la heredan deben implementar los métodos restantes. 00:50:03
Por otro lado, en una interfaz, los métodos son solo declaraciones y no tienen una implementación, a menos que no se utilice el método de Paul. 00:50:08
Esto quizás es más débil, porque dice más o menos lo mismo. 00:50:15
Pero tú lo piensas así y dices, ¿qué quiero hacer yo? 00:50:19
¿Me sale mejor pensar que esto es una clase con métodos implementados y alguno que no puedo implementar, que dejaré como abstracto? 00:50:24
o es más bien un contrato 00:50:33
un algo que yo digo, todos los que 00:50:36
implementan esto tienen que cumplir 00:50:37
con estas cosas y además como 00:50:40
bonus 00:50:42
alguno de estos te doy una 00:50:43
definición estándar 00:50:45
por defecto que normalmente 00:50:48
se hace así, pero que si tú quieres 00:50:49
lo haces como tú quieras y si no pillas 00:50:52
la que tú quieras, ¿vale? 00:50:53
como filosofía es un poquito distinta 00:50:55
una es 00:50:57
me centro en lo que puedo hacer 00:50:59
y dejo para hacer lo que no puedo 00:51:02
y otra es 00:51:04
clarifico lo que se tiene que poder 00:51:05
hacer y a lo mejor te doy 00:51:08
alguna solución ya hecha. 00:51:10
Filosóficamente es un poquito distinto. 00:51:13
Como diseño es un poquito distinto. 00:51:15
Herencia 00:51:20
lo que es más importante y más clave. 00:51:20
Una clase puede extender 00:51:23
solo una clase abstracta pero puede implementar 00:51:25
múltiples interfaces. Esto significa 00:51:27
que una clase puede heredar la característica 00:51:28
de varios contratos diferentes 00:51:31
al implementar múltiples interfaces. 00:51:32
Entonces, lo que decíamos antes, si yo ya estoy forzado a extender una cosa, si yo soy alumno y ya seguramente tengo que extender persona, si quiero darle más cosas, pues tengo que crear interfaces, no puedo crear una clase abstracta. 00:51:35
Si quiero crear evaluable, que me permite, que tiene el método hacer un examen y que así puede, todos los objetos que sean evaluables pueden hacer un examen, pues no lo puede hacer como clase astrata, porque si alumno ya extiende personal, no podría extender también evaluable como clase astrata. 00:51:50
Tendrá que ser una interfaz. 00:52:16
Entonces, a veces tengo constricciones necesarias. Si tengo las dos posibilidades, porque alumnos todavía no heredan nada, pues lo pienso. Y si es posible, yo iría hacia... Si tenéis la posibilidad, si no está claro, iríais hacia clase astrata o interfaz. 00:52:20
interfaz. Porque así no me pillo 00:52:40
los dedos y mañana me doy cuenta que tengo 00:52:45
que extender. 00:52:47
Y también variables. 00:52:50
Las variables en una clase abstracta 00:52:53
pueden ser estáticas o no estáticas. 00:52:55
Mientras que en una interfaz 00:52:58
solo pueden ser 00:52:59
estáticas o finales. 00:53:01
O sea, constantes. 00:53:04
Esto también es otra cosa importante. 00:53:05
Cuando yo defino 00:53:08
las variables en una clase abstracta 00:53:08
son variables del propio objeto, 00:53:11
que luego heredará quien estén de este objeto. 00:53:13
Sin embargo, en una interfaz, las variables no son del objeto, 00:53:16
solo son variables estáticas, o sea, de la clase. 00:53:21
Entonces, allí también es una pista para ver si uso clase abstracta o no, o interfaz. 00:53:26
La interfaz solo, sustantivamente, me trabaja sobre los métodos, 00:53:32
mientras la clase abstracta, perdón, la interfaz solo sobre los métodos, 00:53:36
Mientras se explota, me puede también jugar sobre algunas características propias de este objeto que no es técnico. 00:53:39
Vamos a ver si está funcional, que no tengo la fuerza de algo. 00:53:50
Entonces la vemos en luz o en base, porque esta cosa aquí os hace daño, ¿vale? 00:53:56
¡Duda! 00:54:05
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
1
Fecha:
23 de enero de 2026 - 14:04
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
54′ 17″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
455.39 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid