Usando metodos default en nuestras interfaces

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.

@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.

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:

 public static void main(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 buenas ideas de aplicación al final de la clase

✅

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.

    @FunctionalInterface
    interface StringInterface {
        int getValue();
        default void validateValue(String s) throws Exception {
            if (s.isBlank() || s.isEmpty()){
                System.out.println("Error bro");
                throw new Exception();
            }
        }
    }

    public static void main(String[] args) throws Exception {
        StringInterface v = () -> 6;
        v.validateValue("");
    }

default nos permite crear un metodo vacio o no devuelve nada

Super 😃

Genial