Saltar navegación

20250923-InterfacesFuncionales_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 24 de septiembre de 2025 por Raquel G.

31 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, pues vamos a repasar un poquito esto, ¿vale? 00:00:00
Vale, pues todos sabéis lo que es una interfaz, lógicamente en Java, ¿verdad? 00:00:05
Una interfaz viene a ser esencialmente una clase que su objetivo normalmente es darte métodos vacíos, 00:00:18
pero que de alguna manera te fijan 00:00:30
una plantilla de comportamiento 00:00:32
entonces te fijan como una especie de plantilla 00:00:33
con métodos vacíos 00:00:36
y luego ya 00:00:37
las clases que quieran lo implementan 00:00:39
entonces el no hacer 00:00:42
directamente la clase sino hacer 00:00:44
que las clases se implementen en una interfaz 00:00:46
permite de alguna 00:00:48
manera 00:00:50
propagar, informar 00:00:51
sobre el nombre de los métodos que va a llamar 00:00:53
esa clase sin necesidad de 00:00:56
dar la clase, porque el nombre de los métodos es en la 00:00:58
interfaz, entonces tú ofreces 00:01:00
la interfaz, todo el mundo 00:01:02
conoce los nombres de los métodos 00:01:04
llama esos métodos, ¿cómo se 00:01:06
van a hacer por dentro? ya 00:01:08
cada uno los hace como le da la gana 00:01:10
en función de la clase que quiera usar 00:01:11
para la implementación, pero al 00:01:13
envolver diferentes 00:01:15
clases bajo una sola interfaz 00:01:17
que implementa 00:01:20
esas clases, pues unifica 00:01:22
los nombres de los métodos, ese es el 00:01:23
objetivo, si hacemos 00:01:25
diferentes clases para acceder a una base 00:01:27
de datos SQL elite, una base de datos 00:01:30
Oracle, una base de datos 00:01:32
MySQL, hacemos 00:01:34
para cada una una clase por libre 00:01:36
pues cada clase 00:01:38
puede tener sus métodos con sus nombres 00:01:40
conectar base de datos 00:01:42
leer, que ahora de repente quiero hacer 00:01:44
la conexión con Oracle 00:01:46
esa clase no me vale, tengo que coger 00:01:48
otra clase y encima cambiar las llamadas 00:01:50
a los métodos porque esa clase, los métodos 00:01:52
se van de otra manera, eso es un desastre 00:01:54
para hacer código y sobre todo para compartirlo 00:01:56
y distribuirlo, lo metemos 00:01:59
todo bajo el paraguas de una 00:02:00
interfaz única, los 00:02:02
métodos tienen un nombre 00:02:04
y ahora ya las clases lo implementan 00:02:06
y por el hecho de implementar, todas 00:02:08
van a usar el mismo nombre de método 00:02:10
luego entonces 00:02:12
si yo cambio de base de datos, cambio la clase 00:02:13
que está debajo, pero mi código 00:02:17
que llama los métodos, ese código no cambia 00:02:19
que es lo que importa, no tengo que 00:02:20
recompilar la clase 00:02:22
Entonces ese es el concepto, de ahí viene el interés de usar interfaces en Java, ¿vale? Y por eso se inventaron. Luego ya a partir de ahí, a partir del concepto de interfaz ya llegaron un montón de pequeñas cosas, pues como por ejemplo que las interfaces no tienen por qué tener todos los métodos vacíos, pueden tener métodos con una implementación por defecto, ¿verdad? 00:02:24
Una interfaz 00:02:45
Pues 00:02:47
Si hacemos un proyectito 00:02:48
Repaso 00:02:53
Interfaces 00:02:56
Venga 00:02:58
Me he equivocado, quería hacer un paquete 00:02:59
Paquete 00:03:20
Vale, si hacemos ahora ya 00:03:23
Vamos a hacer una interfaz 00:03:31
Que no deja de ser 00:03:33
Pues cualquier cosa 00:03:35
Yo que sé 00:03:39
vale, una interfaz 00:03:40
simplemente en lugar de class 00:03:47
tiene interfaz delante, nada más 00:03:49
vale, entonces 00:03:51
está pensada, como decimos, para tener 00:03:53
métodos vacíos y que luego 00:03:55
nosotros cambiemos la clase que tiene debajo 00:03:56
en función de nuestros intereses, pero no cambia 00:03:59
el nombre del método, luego la clase 00:04:01
el programa principal 00:04:03
el principal, la aplicación principal que llama 00:04:05
los métodos, esa no cambia 00:04:07
aunque cambie mi implementación 00:04:09
bueno, pues 00:04:12
pues por ejemplo 00:04:13
este es un método de una interfaz 00:04:22
sin definir, recordad que por defecto son públicos 00:04:29
con lo cual no hay que poner el public porque por defecto son todos públicos 00:04:32
porque la interfaz precisamente está pensada 00:04:35
para homogeneizar 00:04:37
la distribución de código 00:04:40
entonces cuando tú distribuyes código lo distribuyes en paquetes 00:04:43
entonces tú importas los paquetes 00:04:46
Tu código principal no va a estar en el mismo paquete 00:04:48
Entonces vas a necesitar que sea público 00:04:51
Es que no hay otra 00:04:53
Por defecto, por el uso que se le da a las interfaces 00:04:54
Es que tienen que ser públicos 00:04:57
Si no, no tendrían ningún uso 00:04:59
Si yo me descargo un paquete de alguien 00:05:01
Y los métodos que tienen dentro no son públicos, ¿para qué me vale? 00:05:02
Entonces no hace falta ni que lo pongamos 00:05:05
En ese caso es el único caso en el cual 00:05:07
No hace falta poner el public 00:05:09
Vale 00:05:11
Bueno, pues entonces ya sabéis que esta 00:05:12
Interfase se implementa 00:05:15
Y quien implemente la interfaz 00:05:17
Tiene que dar cuerpo obligatoriamente 00:05:19
A ese método 00:05:21
La interfaz puede tener 00:05:22
Todos los métodos que le den la gana 00:05:25
Pero también puede tener métodos 00:05:27
Con implementaciones por defecto 00:05:29
¿Vale? 00:05:32
Por ejemplo, puede tener un método 00:05:33
Sí, pero tú lo puedes sobreescribir 00:05:35
Si quieres, pero eso no te hace falta 00:05:42
¿Vale? 00:05:43
Y métodos con implementaciones 00:05:56
Por defecto puede tener muchos 00:05:58
igual que métodos sin implementación puede tener muchos 00:05:59
también una interfaz 00:06:02
puede ofrecer y ya de paso 00:06:03
pues nos ofrece comportamiento 00:06:05
a lo mejor útil para cosas, puede ofrecer 00:06:08
métodos static, también 00:06:09
vale, una interfaz puede ofrecer 00:06:11
un método static, vale 00:06:15
no, no pasa nada 00:06:17
pero vamos, no hace falta 00:06:26
vale, entonces 00:06:27
los métodos static 00:06:35
pues nos permiten ser llamados a partir 00:06:38
de la implementación directamente 00:06:40
Entonces, bueno, nos ofrecen a lo mejor un código interesante 00:06:42
Pero no es un código de instancia, lógicamente 00:06:46
No es un código de objeto 00:06:49
Los métodos static, por tanto 00:06:50
Al no poder depender del objeto 00:06:54
Porque son static por definición 00:06:56
Los definimos directamente en la interfaz 00:06:58
¿Vale? Los definimos directamente aquí 00:07:01
No tiene sentido sobreescribirlos en la instancia 00:07:03
Porque sobreescribirlos en la instancia que lo implementa 00:07:07
perdón, sobreescribirlos en la clase 00:07:11
que lo implementa, solo tendría 00:07:13
sentido si ese método dependiera del 00:07:15
objeto, solo tendría sentido sobreescribirlo 00:07:17
ahí si va a depender del objeto 00:07:19
pero como es estático, no va a 00:07:20
depender del objeto, es imposible 00:07:23
pues entonces lo escribimos 00:07:24
en la interfaz 00:07:27
¿vale? entonces, bueno, en función 00:07:28
de nuestro diseño de código, pues 00:07:31
si nos interesa ofrecer aquí 00:07:32
algún código estático que no necesite que haya 00:07:34
instancias, lo ofrecemos y ya está 00:07:37
pues esto es una interfaz más o menos 00:07:38
en general y ya sabemos las particularidades 00:07:41
de su implementación, si alguien implementa 00:07:43
esto lo tiene que 00:07:45
implementar 00:07:46
no puedo hacerlo 00:07:47
no tengo que llamar a un objeto 00:07:49
no, si, puedes poner saludar 00:07:51
sí 00:07:53
vale 00:07:55
ahora 00:07:58
puede ocurrir que una interfaz 00:08:00
tenga solamente 00:08:05
un método abstracto 00:08:07
un método por definir 00:08:09
entonces si una interfaz tiene solo 00:08:11
un método por definir 00:08:14
en lugar de muchos, es lo que se llama 00:08:16
una interfaz funcional 00:08:18
¿vale? 00:08:20
esta lo sería, porque tiene solo 00:08:22
un método vacío, abstracto 00:08:24
puede tener 200.000 default y 200.000 static 00:08:26
pero solo tiene un abstracto 00:08:28
entonces 00:08:30
esto se conoce como una interfaz funcional 00:08:31
ya, se le da ese nombre 00:08:34
sin más 00:08:36
¿por qué? 00:08:37
Pues porque ahora los objetos de esta interfaz funcional se les ve, se les interpreta como comportamientos de este único método. 00:08:39
Entonces, cuando uno instancia, vamos a instanciar ahora una clase de esta interfaz funcional, 00:08:51
tiene que ofrecer un único comportamiento que es el del único método abstracto. 00:08:58
Entonces, una interfaz funcional se asocia a un método. 00:09:03
Luego ese es el primer salto que damos para entender que los métodos pueden ser datos. 00:09:09
Un método puede ser un dato. 00:09:15
¿Por qué un método puede ser un dato? 00:09:17
Porque un método puede ser un objeto que implementa una interfaz funcional. 00:09:19
Y un objeto que implementa una interfaz funcional tiene un método dentro, solo uno. 00:09:24
Pues ahí está el dato, en ese método. 00:09:28
Pero bueno, por partes 00:09:31
Esto sería una interfaz funcional 00:09:33
Cuando identificamos que tenemos una interfaz funcional 00:09:35
Es recomendable 00:09:38
Anotarla 00:09:40
Anotarla con la 00:09:41
Anotación funcional interface 00:09:48
Para indicar que es una interfaz funcional 00:09:50
¿Obligatorio? 00:09:51
No es obligatorio 00:09:54
¿Recomendable? Sí 00:09:55
¿Recomendable por qué? 00:09:57
Porque ofrece 00:10:01
Una validación ya en tiempo de compilación 00:10:02
Esto es como el override 00:10:04
cuando sobreescribimos un método 00:10:05
recordad cuando heredamos o implementamos 00:10:07
y sobreescribimos un método 00:10:09
podíamos poner el override o no ponerlo 00:10:11
no es obligatorio, pero si ponemos 00:10:13
el override automáticamente se hace 00:10:15
una validación en tiempo de compilación 00:10:17
que es, a ver, este método que tienes 00:10:19
debajo del override, ¿realmente 00:10:21
su cabecera es idéntica 00:10:23
que uno de la superclase? 00:10:25
porque si no lo es 00:10:28
te voy a dar un error 00:10:29
¿vale? entonces ya te ofrece una validación en tiempo 00:10:30
de compilación, que está muy bien porque tú 00:10:33
O a lo mejor crees que estás sobrescribiendo un método de la superclase 00:10:35
y te has equivocado poniendo un carácter de más. 00:10:39
Si no pones el override, no te enteras. 00:10:41
No te enteras, has puesto el carácter de más, no has puesto el override, 00:10:44
el tipo de combinación, no te enteras. 00:10:46
Cuando luego tu programa llame al método de la superclase, 00:10:48
al que va a llamar al de la superclase, 00:10:52
dices, pero si esto no hace nada, no hace nada, no hace nada. 00:10:54
Claro que no hace nada porque no lo has sobrescrito, 00:10:56
creyendo que si lo has hecho, no lo has hecho. 00:11:00
Pues esa es la ventaja de las anotaciones. 00:11:02
no siempre son obligatorias, ofrecen información, a veces información en tiempo de ejecución 00:11:04
y otras validación en tiempo de compilación como esta. Y esta validación es estupenda 00:11:11
porque si yo me creo que he hecho una interfaz funcional y que luego voy a poder instanciar 00:11:16
con una función, como veremos ahora, etc. Y resulta que no me he dado cuenta porque 00:11:21
he hecho un copia y pega de otra que tengo por ahí de hace dos años. He hecho un copia 00:11:27
y pega y aquí tengo yo 00:11:32
otro método abstracto 00:11:34
entonces automáticamente 00:11:36
si yo he puesto 00:11:38
la anotación, me salta el error 00:11:40
¿vale? porque solo puede tener una 00:11:42
pues no lo he mirado nunca, la verdad 00:11:44
anotación inválida 00:11:48
no es una interfaz funcional 00:11:50
¿vale? 00:11:52
entonces ya no solo por esa validación 00:11:54
en tiempo de compilación, sino porque 00:11:56
todo lo claro que pueda ser un código 00:11:58
mejor, cuanto más legible sea mejor 00:12:00
y las anotaciones, cuando tú ves 00:12:02
el código de alguien, las anotaciones te sitúan 00:12:04
en el objetivo 00:12:06
de esas interfaces 00:12:08
vale, pues ya está 00:12:09
entonces 00:12:11
esta interfaz funcional, si yo ahora la quiero usar 00:12:15
por ejemplo, tengo un 00:12:19
programa por aquí 00:12:23
ay, se me ha olvidado poner el 00:12:24
vale, pues 00:12:38
entonces 00:12:55
yo puedo tener un método 00:12:55
que en lugar de recibir un dato para hacer 00:12:59
cosas, reciba 00:13:01
un comportamiento, una acción 00:13:03
que es la idea 00:13:05
de la programación funcional, por ejemplo 00:13:07
vamos a hacer aquí un método 00:13:09
estático para que lo podamos llamar 00:13:10
desde main, haz algo 00:13:13
y ahora 00:13:20
a este haz algo 00:13:21
le voy a pasar 00:13:23
una instancia de mi interfaz funcional 00:13:25
anterior, entonces la 00:13:28
idea, lo que pasa es que luego con los 00:13:30
lo veremos más claro, la idea es que yo a esta función, a este método, no le estoy pasando, como siempre, 00:13:32
dato, un dato para que trabaje, un nombre, una cadena de cosas, no le estoy pasando un dato, 00:13:40
le estoy pasando una acción, le estoy pasando una acción. Pues, ¿cuál puede ser mi manera de pasarle una acción? 00:13:47
Le tendré que pasar una instancia de la interfaz anterior, porque esa instancia tendrá que haber 00:13:53
sobrescrito el método saludar 00:14:00
y, por tanto, le estoy pasando 00:14:02
la acción 00:14:04
de saludar. 00:14:07
Entonces, yo aquí le 00:14:08
¿cómo se llamaba mi interfaz? 00:14:10
Saludar. Vale. 00:14:13
Pues, entonces, a este método 00:14:24
le voy a pasar, en realidad, lo que le estoy pasando es un 00:14:25
comportamiento. Y ese comportamiento 00:14:28
¿dónde va a estar? Aquí. 00:14:30
Pero, claro, le tendré que pasar a una instancia. 00:14:34
Le tengo que pasar a una instancia porque solamente 00:14:35
yo aquí tengo que pasar siempre 00:14:37
como parámetro, siempre paso cosas que existan 00:14:39
lógicamente, objetos o datos 00:14:43
primitivos, pero algo que exista 00:14:44
algo que sea instanciable 00:14:46
yo no puedo pasar por parámetro algo que no sea 00:14:48
instanciable, entonces aquí siempre 00:14:50
tengo que pasar una instancia 00:14:52
no puede instanciar saludar, como bien sabemos 00:14:54
pues entonces toca hacer una clase 00:14:56
que implemente saludar 00:14:58
entonces 00:15:00
ahora ya 00:15:01
nos podemos hacer, por ejemplo 00:15:07
saludar1 00:15:09
Venga, para que el 1 00:15:11
Queda muy feo 00:15:17
Saludar bien 00:15:18
Pues en saludar bien 00:15:19
Yo quiero que esto 00:15:22
Implemente 00:15:25
Mi interfaz funcional anterior 00:15:26
Saludar 00:15:29
Desde el momento en que 00:15:30
Implementa mi interfaz 00:15:34
Anterior 00:15:36
Tengo que definir este comportamiento 00:15:37
Y solo este, porque no hay más métodos abstractos 00:15:41
Pues por ejemplo 00:15:43
Yo aquí podría poner 00:15:44
y puedo tener todas las implementaciones 00:15:46
que yo quiera 00:16:01
vale 00:16:02
mi aplicación puede saludar de mil maneras 00:16:04
implement 00:16:07
saludar 00:16:26
vale, al implementar saludar 00:16:28
vale, entonces 00:16:31
ahora ya 00:16:47
este método, en lugar de llamarlo 00:16:49
haz algo, vamos a llamarlo saludar 00:16:53
saludar, vale 00:16:55
pues a este método 00:16:59
Yo le tengo que pasar 00:17:03
Una instancia de este de aquí 00:17:05
Y en función de la instancia que le pase 00:17:07
Saludar hace una cosa u otra 00:17:09
Entonces 00:17:10
Bueno, primero tengo que hacer el método 00:17:11
Ese punto 00:17:17
Este, ¿vale? 00:17:19
Saludar 00:17:27
Ah, bueno, espérate 00:17:28
Porque el nombre pasado 00:17:31
Se recibía un parámetro 00:17:33
Cómo se encuentra, vamos a ponerle 00:17:35
Para que te diga 00:17:37
Quién 00:17:39
Voy a que le pasa un parámetro 00:17:39
Entra, nombre 00:17:42
Concatenamos 00:17:51
Con la interrogación 00:17:55
Vale 00:17:57
Porque pasarle el parámetro si no lo voy a usar 00:17:58
Vale 00:18:01
Cómo se encuentra 00:18:03
Saludar mal 00:18:11
Este 00:18:14
Y este de aquí 00:18:29
Sí, pero bueno 00:18:32
Como tiene que implementarlo tal cual 00:18:37
Podríamos pasar de él, pero bueno 00:18:39
Su nombrecito 00:18:41
Venga 00:18:44
Entonces, ahora voy a saludar 00:18:44
¿Vale? 00:18:48
Como estamos usando un parámetro 00:18:50
Pues vamos a pasar aquí a quien queremos saludar 00:18:51
Y ahora yo 00:18:53
esta podría ser la implementación de mi método 00:18:56
entonces ahora este método 00:19:01
tiene dos datos 00:19:03
un dato es el nombre de quien voy a saludar 00:19:05
ahí conceptualmente no cambia nada 00:19:08
es un dato 00:19:09
como los que conocemos, un nombre, un número 00:19:10
lo que sea 00:19:13
y el segundo dato o parámetro que tiene 00:19:14
es una manera de saludar 00:19:17
es decir, un comportamiento 00:19:19
este método ahora depende 00:19:21
de una forma 00:19:23
de actuar y de un dato 00:19:25
¿vale? 00:19:27
Entonces, una interfaz funcional es una forma de actuar que, de nuevo, repetimos, se puede pasar como parámetro. 00:19:28
Claro, de hecho, ahora podemos saludar de muchas maneras. 00:19:37
Le vamos a que nos diga cómo se llama. 00:19:41
Vale. 00:19:52
Y ahora ya. 00:20:27
Ahora, cuando llamemos a saludar, ¿vale? 00:20:37
cuando llamemos a saludar 00:20:40
vamos a saludar bien y saludar mal 00:20:42
a este tío 00:20:44
entonces, este tío se llama nombre 00:20:45
¿vale? 00:20:48
entonces 00:21:02
en estas dos llamadas 00:21:02
el dato lo he pasado 00:21:04
lo que me falta pasar es la forma de saludar 00:21:06
es decir, el comportamiento 00:21:08
el comportamiento es 00:21:10
la instancia correspondiente 00:21:12
de esa interfaz 00:21:15
funcional que me interesa 00:21:17
entonces 00:21:18
así 00:21:19
le paso el primer comportamiento 00:21:27
porque le paso una instancia de esa 00:21:30
interfaz funcional 00:21:31
y así le paso el segundo comportamiento 00:21:32
pues estoy pasando dos 00:21:38
cosas, la forma 00:21:40
de saludar que es 00:21:42
la instancia 00:21:43
de la interfaz 00:21:44
funcional y ya un dato porque en este ejemplo 00:21:47
en concreto además necesita un dato 00:21:49
vale 00:21:51
entonces 00:22:06
es el mismo código 00:22:11
es llamada 00:22:14
saludar 00:22:16
el mismo 00:22:18
lo que cambia es lo que yo le paso aquí 00:22:19
¿vale? 00:22:22
vale 00:22:45
¿hasta aquí está claro? 00:22:46
está claro 00:22:48
¿verdad? 00:22:50
bueno pues efectivamente se ve o se vislumbra 00:22:52
que esto es bastante útil 00:22:55
operativo, da mucha flexibilidad 00:22:56
y sobre todo me permite unos esquemas de diseño 00:22:58
muchísimo más 00:23:01
con muchísima más riqueza 00:23:02
aquí lo único que ha sido un poquito 00:23:04
farragoso es el paso 00:23:07
de tener que hacer 00:23:09
la clase 00:23:11
que implementa esta 00:23:13
porque tengo que hacer toda una clase entera 00:23:14
solamente 00:23:17
para esta línea 00:23:19
y toda esta clase entera 00:23:21
solamente 00:23:23
para esta línea 00:23:24
entonces lo que se nos ha hecho un poquito pesado 00:23:26
es tener que hacer una clase entera 00:23:29
que implemente la interfaz 00:23:32
solo para ofrecer este comportamiento. 00:23:33
No pasa nada, se puede hacer. 00:23:37
Lo que pasa es que Java te ofrece 00:23:38
una manera más dinámica 00:23:40
de crear estos comportamientos 00:23:42
más allá de hacer una clase 00:23:46
que lo implemente 00:23:48
y meter ese comportamiento dentro de esto de aquí. 00:23:49
Que es a través de las funciones. 00:23:53
¿No suena bien? 00:23:56
esto no es nada 00:24:05
hombre a ver 00:24:09
todo es mucho 00:24:10
en función del grado de profundidad 00:24:11
que se quiera meter uno 00:24:12
para el andar por casa 00:24:13
que andamos nosotros 00:24:16
para el andar por casa 00:24:17
esto es muy sencillo 00:24:18
para meterse en profundidades 00:24:20
que es lo que haréis 00:24:21
cuando te pongan a ti 00:24:22
a trabajar en una cosa concreta 00:24:23
sobre esto 00:24:25
entonces te metes en profundidades 00:24:26
pero tienes el hilo del que tirar 00:24:27
que eso es lo que se supone 00:24:29
que tenéis que coger en el ciclo 00:24:31
el hilo del cual tirar 00:24:32
para te pongan donde te pongan, te dan un bofetón 00:24:33
y te vas para allá, no pasa nada 00:24:36
sé dónde tirar para sobrevivir, me dan otro 00:24:37
bofetón y voy para acá, sé dónde tirar 00:24:39
no estoy en Alvis por la vida 00:24:41
y vale 00:24:44
porque ChatGPT es maravilloso 00:24:45
y útil para el que está 00:24:48
situado, entonces para el que 00:24:49
está situado en el mundo 00:24:51
es maravilloso 00:24:53
pero para el que no está situado 00:24:55
es un desastre porque él 00:24:57
pues no, si tú no le haces las preguntas 00:24:59
correctas jamás vas a obtener las preguntas 00:25:01
correctas, las respuestas correctas 00:25:03
lógicamente, entonces hay que 00:25:05
situarse, ¿qué es lo que hacemos aquí? 00:25:07
pues un poco tocar un poco todas las 00:25:09
cosas para saber de dónde tirar 00:25:11
bueno, pues entonces, ¿cómo podemos 00:25:13
usar una función lambda 00:25:15
para 00:25:17
dar una 00:25:19
instancia a una 00:25:21
interfaz 00:25:23
funcional? ¿qué es lo que queríamos 00:25:25
aquí? instanciar una interfaz funcional 00:25:27
porque aquí hemos 00:25:29
necesitado 00:25:31
instanciar 00:25:32
una interfaz funcional para 00:25:35
aquí hemos 00:25:37
necesitado instanciar una interfaz 00:25:39
funcional para pasar el comportamiento 00:25:42
¿no? 00:25:43
que el rollo ha sido, repito, tener que crear esta clase 00:25:45
el nudo rollo, pues no hace falta 00:25:47
en realidad crear esa clase intermedia 00:25:49
es decir 00:25:51
¿eh? 00:25:52
no hace falta 00:25:54
por ejemplo 00:25:56
vamos a hacerlo 00:25:58
Yo quiero crear una instancia 00:26:00
De este de aquí 00:26:05
Tal y como lo hemos hecho ahora 00:26:06
Por ejemplo tendría aquí 00:26:09
Saludar S1 00:26:10
Haría esto 00:26:12
Vamos a hacerlo en dos líneas 00:26:16
Para que se vea mejor la diferencia 00:26:21
Y saludar S2 00:26:23
Saludar mal 00:26:26
Vale, esto es lo que hemos hecho 00:26:27
¿No? Separándolo en dos líneas 00:26:30
S1, S2 00:26:32
Vale 00:26:36
bueno pues como puedo yo hacer esto 00:26:37
que es 00:26:40
instanciar 00:26:41
como puedo hacer yo hacer esto, instanciar 00:26:43
sin tener que crear 00:26:46
sin tener que tener creada la clase 00:26:47
saludar bien, pues lo que puedo hacer es 00:26:49
dar directamente aquí 00:26:51
el código del método, punto pelota 00:26:53
doy el código del método 00:26:56
y se convierte en una 00:26:57
creación de instancia 00:27:00
de esta interfaz cuya implementación 00:27:01
del método interno es la que yo doy aquí 00:27:04
doy aquí el código del método 00:27:06
y eso es una función lambda 00:27:08
entonces aquí podemos dar 00:27:10
aquí en lugar de esto 00:27:11
sustituimos esto 00:27:18
por una función lambda 00:27:20
y la función lambda 00:27:23
¿qué es? 00:27:26
es la implementación del método abstracto 00:27:27
es solamente eso 00:27:30
si, un método lambda 00:27:31
es una 00:27:39
implementación 00:27:40
de una instancia 00:27:42
de una interfaz funcional 00:27:43
la implementación de una interfaz funcional 00:27:45
implementación del método astral 00:27:46
entonces, tú solamente puedes proveer 00:27:49
una lambda 00:27:54
a quien te esté pidiendo una interfaz funcional 00:27:54
a quien te la esté pidiendo 00:27:57
vale, pues 00:27:59
los principios de 00:28:01
programación de la función lambda 00:28:03
para hacerlo de andar por casa 00:28:05
son muy sencillos, las funciones lambda 00:28:07
tienen esta cosita, tan bona 00:28:09
que separa 00:28:11
parámetros de entrada de ese método 00:28:12
De código de salida 00:28:15
¿Vale? 00:28:17
Los parámetros de entrada del método 00:28:18
Van separados por comas entre paréntesis 00:28:20
Y va con su nombre tal cual 00:28:23
Ni tipo ni nada 00:28:26
Porque el tipo ya 00:28:28
Se infiere luego en tiempo de ejecución 00:28:29
En función de quien va a estar llamando 00:28:33
Ya se va a inferir 00:28:34
Ahí no hay que poner tipo 00:28:35
Y aquí el código que sea 00:28:36
Entonces 00:28:40
esto es una función lambda válida 00:28:42
que sirve para implementar un método abstracto 00:28:46
que reciba dos parámetros 00:28:50
y te devuelve, color de retorno, la suma de los dos 00:28:52
o sea, esta sería un lambda válido 00:28:55
para un método que sea algo así 00:28:57
por ejemplo 00:29:00
int suma int a int b 00:29:01
¿vale? 00:29:08
si yo tengo una interfaz funcional 00:29:11
cuyo método abstracto es este, me devuelve 00:29:15
un valor y necesita 00:29:17
dos parámetros 00:29:18
esta lambda encaja en él perfectamente 00:29:19
bueno, pues 00:29:22
aquí en nuestro caso particular 00:29:28
cuando solamente 00:29:30
hay un parámetro de entrada 00:29:32
no se pone entre paréntesis 00:29:33
se pone 00:29:35
la x, y ya está 00:29:36
se suelen llamar las parámetros de entrada x, y, z 00:29:39
¿vale? 00:29:41
puede no tener parámetros de entrada 00:29:43
el método, entonces no se pone nada 00:29:45
hay pequeños, la sintaxis 00:29:47
de la función lambda 00:29:49
pues uno la mira sintaxis para hacer una función lambda 00:29:50
y no tiene mayor historia 00:29:53
es ir probando y se acabó 00:29:55
que sepamos simplemente que la idea es esa 00:29:57
este simbolito, parámetros de entrada 00:29:59
aquí separados por comas entre paréntesis 00:30:02
y no es menos que sea solo uno 00:30:04
y aquí el código que puede ser más de una línea 00:30:05
puede ser línea separada por un poco de coma 00:30:07
lo que queremos que haga el método 00:30:09
Que puede devolver algo o puede no devolver nada 00:30:10
No he puesto ahí el return 00:30:13
¿Vale? Debería 00:30:14
Bueno, pues entonces 00:30:15
Aquí si pasamos del saludar bien y del saludar mal 00:30:19
Vamos a instanciar 00:30:21
Ese 1 y ese 2 pasando de esas clases 00:30:26
Bueno, pues a ver 00:30:29
¿Qué tipo de función lambda deberíamos ofrecer aquí? 00:30:34
Una que recibe un único parámetro 00:30:38
Y lo que hace es mostrar este mensajito 00:30:40
Pues vamos a hacer eso mismo 00:30:45
Es muy fácil 00:30:47
De nuevo 00:30:50
Hasta la complejidad que se quiera meter uno 00:30:51
Pues x y ahora 00:30:54
Vamos a dejarla tal cual 00:30:57
Cambiando nombre por x 00:31:11
Lógicamente 00:31:15
Vale 00:31:16
Como veis 00:31:20
Me la coge, ya está, ya tengo mi función lambda 00:31:22
Que quiero instanciar 00:31:25
Porque quiero hacer dos instancias 00:31:30
diferentes para 00:31:34
dos saludos 00:31:35
o es lo mismo 00:31:37
son los parámetros de entrada 00:31:38
al método abstracto que tenga esta interfaz 00:31:57
esta interfaz tiene su 00:31:59
método abstracto único 00:32:01
con sus parámetros de entrada 00:32:03
y su posible valor de salida o no 00:32:04
pues los parámetros de entrada 00:32:08
tendrán que estar aquí separados por comas 00:32:10
dándole el nombre que tú quieras 00:32:12
la idea de la función lambda 00:32:13
es que quede cortita porque va a ir una línea 00:32:15
entonces aquí no aplica 00:32:17
lo que hemos dicho siempre 00:32:20
de por favor nombres de identificadores 00:32:22
lo más explicativo posible 00:32:24
cuando creéis una variable 00:32:26
que es el apellido de alguien 00:32:27
no la llaméis x, llamad apellido 00:32:30
pues todas esas reglas de estilo 00:32:32
aquí no aplican 00:32:34
porque aquí lo que queremos es códigos cortitos 00:32:36
y legibles 00:32:38
entonces aquí a los parámetros de entrada 00:32:39
se le puede llamar x, y, t 00:32:41
en el segundo no tiene que ser y 00:32:44
puede ser X 00:32:46
que más da, son funciones landas independientes 00:32:47
entonces 00:32:51
mientras yo no la cambie 00:32:55
es una instancia de esta interfaz 00:32:56
cuya implementación de su método es esta 00:32:58
¿vale? S1 00:33:00
podría luego darle otra función landa 00:33:02
pues la ha instanciado otra vez 00:33:04
con otra implementación 00:33:06
entonces esto hace que sea muchísimo más ágil 00:33:08
no tengo que hacer una implementación 00:33:10
por cada comportamiento distinto 00:33:13
doy ese comportamiento 00:33:15
a través de la función en la acta. 00:33:16
No, no, no. 00:33:20
Las clases no me hacen falta 00:33:20
porque las clases las hemos hecho 00:33:21
las clases las hemos hecho 00:33:24
para indicar 00:33:27
cuál es el comportamiento 00:33:29
que yo quiero para esa instancia. 00:33:31
Pero como ese comportamiento 00:33:33
en el momento de instanciarlo 00:33:35
ya se lo voy a dar aquí 00:33:37
en el momento de instanciarlo 00:33:40
estoy rellenando el método 00:33:43
en el momento de instanciarlo 00:33:45
Luego no necesito hacer la clase que lo implementa 00:33:46
Porque aquí ya estoy rellenando el método 00:33:49
¿Vale? 00:33:51
Y yo puedo redefinir 00:33:55
Esta interfaz siempre que quiera con funciones lambda 00:33:57
Distintas 00:34:00
Vale, si ejecutamos esto 00:34:01
Pues hará lo mismo 00:34:06
¿Vale? 00:34:07
¿Algo no te cuadra? 00:34:12
Sí 00:34:27
¿El qué? 00:34:27
El método de abajo 00:34:29
¿Cómo el método de abajo? 00:34:30
Sí, a ver, el método de abajo, claro, puedo pasarle aquí directamente, ya me puedo saltar este paso, efectivamente, claro. 00:34:38
Esto como le quedo no más claro, yo aquí tengo que pasar una instancia de segundo, eso está claro. 00:34:52
Entonces, o bien la creo antes 00:35:00
O la paso directamente 00:35:03
Es decir, nosotros podríamos aquí 00:35:04
En lugar de llamar 00:35:07
Crearlas primero 00:35:09
Y luego pasarlas 00:35:13
Podemos también 00:35:14
Hacerlo directamente 00:35:16
A saludar 00:35:18
Es como pasar el new, como antes hemos pasado el new 00:35:20
Ah, pues espérate 00:35:22
Porque esto era lo que yo quería decir ahora 00:35:24
Que también es 00:35:26
Ahora me dices lo otro 00:35:27
Vale, entonces 00:35:29
Porque ese me 00:35:31
Ah, vale 00:35:37
Ay, que no quería esto 00:35:38
Ahí, vale 00:35:41
Coma, nombre 00:35:42
Y aquí 00:35:56
Vale 00:35:57
Con este 00:35:59
System.out tan largo se pierde la 00:36:22
Perspectiva 00:36:23
Vale 00:36:25
Y ya podríamos, ahora vamos con lo 00:36:41
Tuyo, y ya podríamos 00:36:44
Dar el siguiente salto que lo hace más 00:36:46
depende de lo claro que quiera verlo uno en el código 00:36:48
¿no? 00:36:51
esto es como cuando hacemos un objeto 00:36:53
lo instanciamos con new 00:36:55
y pasamos el objeto 00:36:57
o pasamos el new directamente 00:36:58
depende de cómo quieras hacer todo el código 00:37:00
si quieres dejarlo más claro o no quieres dejarlo claro 00:37:03
si quieres conservar la referencia 00:37:05
y no quieres conservarla 00:37:07
si quieres conservar la referencia 00:37:08
tienes que guardarla en un sitio 00:37:10
pero si te da igual conservarla 00:37:12
porque solo la vas a usar una vez 00:37:15
Pues pasas el new directamente 00:37:16
Pues aquí igual 00:37:19
Yo a saludar, a este método saludar 00:37:21
Le tengo que pasar 00:37:23
Una instancia 00:37:25
De una interfaz funcional, obligatorio 00:37:27
Y este parámetro 00:37:29
Pues una instancia de una interfaz funcional 00:37:30
Es una función lambda, lo que acabamos de decir 00:37:33
Pues le paso la función lambda tal cual 00:37:35
Le paso la función lambda tal cual 00:37:37
La queja queda un poco larga porque tiene el sistema 00:37:39
Outprintln 00:37:41
Que no lo puedo abreviar porque 00:37:42
lo concatenamos con esto, lo de abreviar lo veremos 00:37:45
ahora, ¿vale? pero le paso 00:37:47
la función lambda tal cual 00:37:49
claro, x barrita 00:37:50
le paso la función lambda 00:37:55
y le estoy pasando la instancia, ¿vale? 00:37:57
¿y tu duda cuál era? 00:38:03
lo que yo digo es que 00:38:04
estás creando la instancia saludar 00:38:05
ese 1, ¿no? 00:38:07
la función lambda 00:38:08
ya tienen los métodos 00:38:10
ya puedes hacer ese 1.saludar 00:38:13
Podría llamar a ese uno 00:38:15
Punto saludar 00:38:21
¿Vale? 00:38:23
Y pasar el nombre, ¿vale? 00:38:25
Lo que pasa es que no sería el uso 00:38:26
No sería el uso 00:38:28
Ya, pero bueno 00:38:30
Sí, pero a ver, lo que estoy reflejando 00:38:36
Lo que estoy reflejando es que a un método 00:38:39
Le puedes pasar comportamiento 00:38:41
En este caso este método a su vez 00:38:42
saluda. O sea, los dos métodos hacen lo mismo. 00:38:45
Pero a lo mejor este método de abajo 00:38:47
podría hacer otra cosa con este comportamiento. 00:38:49
¿Vale? No tendría por qué 00:38:52
hacer lo mismo. ¿Vale? 00:38:53
Venga, pues paramos un momentico. 00:38:59
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
31
Fecha:
24 de septiembre de 2025 - 18:03
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
39′ 01″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
148.68 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid