¿Cómo funcionan las interfaces personalizadas en Java 8?
En Java 8, la personalización de interfaces adquiere un nuevo significado, brindando más flexibilidad y control sobre las funciones que podemos crear y utilizar. Esta capacidad permite definir métodos con un cuerpo dentro de una interfaz, lo cual se lleva a cabo por medio de la palabra clave default. A lo largo de esta explicación, exploraremos cómo estructurar y utilizar estas interfaces personalizadas creando métodos y funciones únicos.
¿Cómo crear una interfaz funcional personalizada?
Crear una interfaz funcional personalizada en Java 8 es un proceso sencillo, pero poderoso. Imagina que deseamos implementar una nueva clase llamada StringFunctions. Dentro de esta clase, crearemos una interfaz funcional llamada InterfazStringOperacion. Lo crucial para esta interfaz es tener:
Un método abstracto sin definición.
Métodos con definición usando la palabra default.
Por ejemplo, podríamos definir un método abstracto que devuelva un entero y un método default que reciba un String como argumento. Este método default tendría un cuerpo que define su comportamiento.
publicinterfaceInterfazStringOperacion{intobtenerNumero();defaultvoidoperacionTexto(String texto){int x =obtenerNumero();while(x-->0){System.out.println(texto);}}}
¿Cómo utilizar las interfaces personalizadas?
Una vez que tengamos nuestra interfaz personalizada, podemos crear métodos que la implementen y definan su comportamiento. Por ejemplo, podemos establecer un método que simplemente devuelva el número seis.
Posteriormente, podemos invocar este método y pasarle un texto para que lo imprima múltiples veces:
publicclassMain{publicstaticvoidmain(String[] args){// Implementación de la interfazInterfazStringOperacion operacion =()->6;// método abstracto operacion.operacionTexto("alumno");}}
Al ejecutar este código, veremos que imprime la palabra "alumno" seis veces, lo cual sucede debido al valor retornado por el método.
¿Qué otras operaciones se pueden implementar?
Además de imprimir textos, nuestras interfaces personalizadas pueden realizar operaciones más complejas. Por ejemplo, podríamos definir otra operación HuboOperacion que, aparte de imprimir, realice decrecimiento del índice, o realice otra acción en base al número retornado por el método obtenerNumero.
publicinterfaceHuboOperacion{defaultvoidejecutar(int veces,String texto){for(int i =0; i < veces; i++){System.out.print(texto);}}}
Este tipo de configuraciones demuestra la versatilidad que ofrece Java 8, permitiéndonos generar interfaces que no solo ejecutan métodos simples, sino que también se pueden integrar en operaciones más grandes como consultas a bases de datos o servicios web. Aquí, la funcionalidad se centra en lo que deseamos implementar, sin necesidad de modificar la conexión o la forma en que se invocan estas operaciones.
Con Java 8, el mundo de las interfaces ha evolucionado para darnos más libertad y utilidad, haciendo de la programación una experiencia más eficiente y personalizada. ¡Anímate a explorar y a seguir aprendiendo!
Interfaz Funcional en Java: Creación y Uso de Métodos Default
¿Cómo funcionan las interfaces personalizadas en Java 8?
En Java 8, la personalización de interfaces adquiere un nuevo significado, brindando más flexibilidad y control sobre las funciones que podemos crear y utilizar. Esta capacidad permite definir métodos con un cuerpo dentro de una interfaz, lo cual se lleva a cabo por medio de la palabra clave default. A lo largo de esta explicación, exploraremos cómo estructurar y utilizar estas interfaces personalizadas creando métodos y funciones únicos.
¿Cómo crear una interfaz funcional personalizada?
Crear una interfaz funcional personalizada en Java 8 es un proceso sencillo, pero poderoso. Imagina que deseamos implementar una nueva clase llamada StringFunctions. Dentro de esta clase, crearemos una interfaz funcional llamada InterfazStringOperacion. Lo crucial para esta interfaz es tener:
Un método abstracto sin definición.
Métodos con definición usando la palabra default.
Por ejemplo, podríamos definir un método abstracto que devuelva un entero y un método default que reciba un String como argumento. Este método default tendría un cuerpo que define su comportamiento.
public interface InterfazStringOperacion {
int obtenerNumero();
default void operacionTexto(String texto) {
int x = obtenerNumero();
while (x-- > 0) {
System.out.println(texto);
}
}
}
¿Cómo utilizar las interfaces personalizadas?
Una vez que tengamos nuestra interfaz personalizada, podemos crear métodos que la implementen y definan su comportamiento. Por ejemplo, podemos establecer un método que simplemente devuelva el número seis.
Posteriormente, podemos invocar este método y pasarle un texto para que lo imprima múltiples veces:
public class Main {
public static void main(String[] args) {
// Implementación de la interfaz
InterfazStringOperacion operacion = () -> 6; // método abstracto
operacion.operacionTexto("alumno");
}
}
Al ejecutar este código, veremos que imprime la palabra "alumno" seis veces, lo cual sucede debido al valor retornado por el método.
¿Qué otras operaciones se pueden implementar?
Además de imprimir textos, nuestras interfaces personalizadas pueden realizar operaciones más complejas. Por ejemplo, podríamos definir otra operación HuboOperacion que, aparte de imprimir, realice decrecimiento del índice, o realice otra acción en base al número retornado por el método obtenerNumero.
public interface HuboOperacion {
default void ejecutar(int veces, String texto) {
for (int i = 0; i < veces; i++) {
System.out.print(texto);
}
}
}
Este tipo de configuraciones demuestra la versatilidad que ofrece Java 8, permitiéndonos generar interfaces que no solo ejecutan métodos simples, sino que también se pueden integrar en operaciones más grandes como consultas a bases de datos o servicios web. Aquí, la funcionalidad se centra en lo que deseamos implementar, sin necesidad de modificar la conexión o la forma en que se invocan estas operaciones.
Con Java 8, el mundo de las interfaces ha evolucionado para darnos más libertad y utilidad, haciendo de la programación una experiencia más eficiente y personalizada. ¡Anímate a explorar y a seguir aprendiendo!
Personalmente me confundí un poco con esta clase porque no había visto antes una interfaz funcional con más de un método. Por eso me puse a investigar un poco más en los docs y se los comparto:
Escencialmente una interfaz con la anotación @FunctionalInterface solo puede tener 1 método abstracto. Como los métodos default tienen una implementación no son abstractos y por lo tanto no rompen el contrato de @FunctionalInterface.
También me surgió una duda respecto al método asociado a la lambda: ¿podríamos hacer StringOperation op = text -> {} (asociar la lambda a operate(String) en lugar de a getAmout())?. La respuesta es inmediata y obvia: No. Si pudiesemos hacer lo anterior getAmount() no tendría una definición y eso es imposible, generaría un error de compilación.
Por medio de los métodos default en las interfaces vamos a poder crear una estructura base para las funciones, en especial pre-establecer que parámetros tomaran.
Muchas gracias por la explicación instructor Sinuhé.
⠀
Al definir estas interfaces personalizadas, es posible incluir métodos default, estos son métodos cuyo código sí está escrito en la definición de la interfáz.
⠀
Por ejemplo, la interfáz posee el método default el cual recibe una lista, y devuelve una nueva lista donde cada elemento es el resultado de aplicar la funcion sobre los elementos de la lista original.
NumberListOperation
operarLista
operacion
@FunctionalInterface
interface NumberListOperation {
Integer operacion(Integer x);
default List<Integer> operarLista(List<Integer> numeros){
List<Integer> resultado = new ArrayList<>();
for (Integer n : numeros) {
Integer num = operacion(n);
resultado.add(num);
}
return resultado;
}
}
Dicha interfáz puede usarse para obtener el doble de cada uno de los números de una lista.
En una Functional Interface, tendremos un método abstracto (sin implementar) y al momento de crear una instancia de esa interface, al pasarle una lambda, esa será el comportamiento que tomará.
En la instancia llamada six, se imprimirá la palabra _alumno _ 6 veces. Pero en la instancia llamada duplicate, tomará el valor de la primera instancia y lo duplicará, haciendo que el valor Calificacion se imprimirá 12 veces.
Un error que me ocurrió cuando experimenté con los métodos default fue cuando intenté hacer que una clase implementara dos interfaces que tenían la misma cabecera del método default. Java reconoce que hay un cuerpo y no nos permite continuar la compilación si no se resuelve.
Como las interfaces son abstracciones de comportamiento, Java nos permite hacer una sobre-escritura del método y hacer como que no hay cuerpo en ninguno de los métodos default para resolver esta ambigüedad. Esto es lo que pasaría (frecuentemente) si se permitiera herencia múltiple en Java.
Muy bien por las opciones que ofrece Sinuhé para aplicar default, pero porqué no mejor nos muestra el ejemplo práctico desde código para apreciar mejor al menos un caso de aplicación de los que ha mencionado ?,
Personalmente me confundí un poco con esta clase porque no había visto antes una interfaz funcional con más de un método. Por eso me puse a investigar un poco más en los docs y se los comparto:
Escencialmente una interfaz con la anotación @FunctionalInterface solo puede tener 1 método abstracto. Como los métodos default tienen una implementación no son abstractos y por lo tanto no rompen el contrato de @FunctionalInterface.
También me surgió una duda respecto al método asociado a la lambda: ¿podríamos hacer StringOperation op = text -> {} (asociar la lambda a operate(String) en lugar de a getAmout())?. La respuesta es inmediata y obvia: No. Si pudiesemos hacer lo anterior getAmount() no tendría una definición y eso es imposible, generaría un error de compilación.
Default nos da la posibilidad de definir un comportamiento base para la interface y asi definir a su vez que parametros seran necesarios.
Por medio de los métodos default en las interfaces vamos a poder crear una estructura base para las funciones, en especial pre-establecer que parámetros tomaran.
Muchas gracias por la explicación instructor Sinuhé.
métodos default
⠀
Al definir estas interfaces personalizadas, es posible incluir métodos default, estos son métodos cuyo código sí está escrito en la definición de la interfáz.
⠀
Por ejemplo, la interfáz NumberListOperation posee el método default operarLista el cual recibe una lista, y devuelve una nueva lista donde cada elemento es el resultado de aplicar la funcion operacion sobre los elementos de la lista original.
@FunctionalInterfaceinterfaceNumberListOperation{Integeroperacion(Integer x);defaultList<Integer>operarLista(List<Integer> numeros){List<Integer> resultado =newArrayList<>();for(Integer n : numeros){Integer num =operacion(n); resultado.add(num);}return resultado;}}
Dicha interfáz puede usarse para obtener el doble de cada uno de los números de una lista.
List<Integer> numeros =Arrays.asList(1,2,3,4,5);NumberListOperation duplicar = x -> x *2;numeros = duplicar.operarLista(numeros);// ahora numeros contiene 2, 4, 6, 8, 10
Default
Es una keyword que permite añadir un comportamiento por defecto a la interfaz.
En una Functional Interface, tendremos un método abstracto (sin implementar) y al momento de crear una instancia de esa interface, al pasarle una lambda, esa será el comportamiento que tomará.
En el siguiente ejemplo que cree:
publicstaticvoidmain(String[] args){StringOperations six =()->6; six.operate("Alumno");StringOperations duplicate =()-> six.getAmount()*2; duplicate.operate("Calfiicacion");}
En la instancia llamada six, se imprimirá la palabra _alumno _ 6 veces. Pero en la instancia llamada duplicate, tomará el valor de la primera instancia y lo duplicará, haciendo que el valor Calificacion se imprimirá 12 veces.
Un error que me ocurrió cuando experimenté con los métodos default fue cuando intenté hacer que una clase implementara dos interfaces que tenían la misma cabecera del método default. Java reconoce que hay un cuerpo y no nos permite continuar la compilación si no se resuelve.
Como las interfaces son abstracciones de comportamiento, Java nos permite hacer una sobre-escritura del método y hacer como que no hay cuerpo en ninguno de los métodos default para resolver esta ambigüedad. Esto es lo que pasaría (frecuentemente) si se permitiera herencia múltiple en Java.
Default en una interfaz nos permitirá implementar un método.
@FunctionalInterface, esta anotación nos permite contar con método sin definir y también método default.
Muy bien por las opciones que ofrece Sinuhé para aplicar default, pero porqué no mejor nos muestra el ejemplo práctico desde código para apreciar mejor al menos un caso de aplicación de los que ha mencionado ?,
Muy buenas ideas de aplicación al final de la clase
Tengo la siguiente duda:
@FunctionalInterface
interface DoOperation{
void take(String text);
Yo sabía que las intefaces solo declaraban el método pero cuando usas default estás ingresando código en el cuerpo... eso no viola la definición propiamente dicha de una interface?
¡Buena vista! Tienes razón en que las interfaces tradicionales solo declaraban contratos vacíos. Pero Java 8 introdujo los métodos default justamente para romper esa regla sin romper el código existente de las clases que ya las implementaban.
No viola la definición funcional porque sigues teniendo un único método abstracto (el corazón de la interfaz). El default solo te regala comportamiento reutilizable listo para usar, como un superpoder heredado.
Me quede confundido, pero creo que pude entenderlo de manera fácil así:
Una interfaz @FunctionalInterface solo puede tener 1 método abstracto y tener varios defaults
Cuando instanciamos la interfaz, le tenemos que pasar la definición del método abstracto (en el video lo hace com lambdas)
Y ejecutamos los métodos default, que implementan ese método abstracto
Aun no puedo imaginar casos de uso, pero en la teoría eso fue lo que entendí
✅
El concepto del default tiene aplicaciones muy interesantes. Para entenderlo es imperativo orientar el razonamiento hacia el paradigma funcional. La costumbre del paradigma orientado a objetos nos confunde.
El default permite la definición de capacidades adicionales para la @FunctionalInterface que estamos construyendo; ya que el comportamiento de la función en sí solo será definido cuando usemos la interfaz y ejecutado por su método abstracto.
Se me hizo fácil entenderlo explorando la interfaz Consumer. Ésta por definición recibe un valor como parámetro y no devuelve nada. Lo cual está representado en su método abstracto:
void accept(T t);
Simplemente "acepta" el parámetro y lo usa para la función declarada, en éste caso será de tipo void.
Pero cuenta con el método default llamado andThen que recibe como parámetro otro Consumer.
De esa manera ejecuta ambas funciones para el mismo parámetro. En otras palabras, le está proporcionando la capacidad a la interfaz Consumer de decidir qué hacer después (a través de otra función del tipo Consumer) de ejecutar la función declarada. Encadena dos ejecuciones de tipo void.
Un ejemplo que se me ocurre sería notificar a un usuario acerca de un evento en el sistema "y luego" logear la ejecución de la notificación (Para efectos prácticos, omitamos las validaciones asociadas a la notificación de un usuario):
publicclassUserNotifier{publicstaticvoidmain(String[] args){String username ="JohnDoe";Consumer<String> notify = user ->System.out.println("Notificar al usuario: "+ user);Consumer<String> log = user ->System.out.println("El usuario: "+ user +" ha sido notificado.");Consumer<String> notifyAndLog = notify.andThen(log); notifyAndLog.accept(username);}}
Al final de la clase, se dan ejemplos del mundo real donde se puede implementar una interfaz funcional con métodos default, recomendaría que los ejemplos que dan durante las explicaciones en las clases no sean cosas tan genéricas como "DoOperation" o "StringOperation", es más fácil entender las cosas cuando los ejemplos que se utilizan guardan similitudes con escenarios de la vida real.
✅
wooww estuvo heavy. pero muy interesante
Son comportamientos, que puede tener una interfaz por defecto:
Por ejemplo, si la interfaz, hace queries, un comportamiento por defecto:
Establecer una conexión.
Verificar los datos del query.
Mapear las respuestas del query.
@FunctionalInterfaceinterfaceStringInterface{intgetValue();defaultvoidvalidateValue(String s)throwsException{if(s.isBlank()|| s.isEmpty()){System.out.println("Error bro");thrownewException();}}}publicstaticvoidmain(String[] args)throwsException{StringInterface v =()->6; v.validateValue("");}
default nos permite crear un metodo vacio o no devuelve nada