Entendiendo dos jugadores clave: SAM y FunctionalInterface

Notes:

1. SAM is the abbreviation of Single Abstract Method.

2. A functional interface is an interface that contains only one abstract method. They can have only one functionality to exhibit. From Java 8 onwards, lambda expressions can be used to represent the instance of a functional interface. A functional interface can have any number of default methods. Runnable, ActionListener, Comparable are some of the examples of functional interfaces.Before Java 8, we had to create anonymous inner class objects or implement these interfaces.

3. @FunctionalInterface annotation is used to ensure that the functional interface can’t have more than one abstract method. In case more than one abstract methods are present, the compiler flags an ‘Unexpected @FunctionalInterface annotation’ message. However, it is not mandatory to use this annotation.

Para evitar la validación de agregar ceros se puede mejorar utilizando el formateador de la siguiente forma:
String.format("%02d ", days);

Este curso me vuela el cerebro.

Interfaces SAM y FunctionalInterface

⠀

Java tiene incorporadas las interfaces necesarias para crear funciones que reciban uno o dos parámetros de tipos diferentes, pudiendo especificar también el tipo de retorno, pero también es posible definir interfaces personalizadas que cumplan la misma funcion, pero que permita la utilización de más parámetros o fijar su tipo para no tener que especificarlos al definirlas.
⠀

Para hacerlo, basta con crear una interfáz SAM (Single Abstract Method) y agregar la anotación @FunctionalInterface
⠀

Por ejemplo, se puede definir una interfaz que permita crear funciones con tres parámetros.

@FunctionalInterface
public interface TriFunction<T, U, V, R> {
    R apply(T t, U u, V v);
}

Su utilización es similar a Function.

//       si x ____ y
// entonces z ____ ?
TriFunction<Integer, Integer, Integer, Double> reglaDeTres = (x, y, z) -> Double.valueOf(y * z / x);

Double resultado = reglaDeTres.apply(5, 30, 15); // retorna 90

Muchas gracias instructor Sinuhé, entonces por medio del uso de SAM y FunctionalInterface tendremos una forma de crear funciones que utilicen más de dos parámetros de ingreso.

Buenas, durante el vídeo el profesor indica que lo que vamos a calcular la edad, pero existe un pequeño error en el código. Lo que nuestra función calculateAge hace es obtener la diferencia de días y con esto no se obtiene la edad. La corrección es muy simple, solo se tiene que remplazar el getDays por getYears

Les comparto como quedaría la modificación

TriFunction<Integer,Integer,Integer,Integer> calculateAge =
                (day, month, year) -> Period.between(
                            parseDate.apply(day, month, year),
                            LocalDate.now()
                        ).getYears();

O se utiliza LocalDate#of(int year, int month, int dayOfMonth) en lugar de un hack innecesario.

SAM --> Single Abstrab Method, Es una interfaz que tiene un solo método sin definir. Para ello decoramos con @FuctionalInterface. Nos permite crear nuestras propias funciones.

En mi caso getDays() no funciono de forma correcta, probe con getYears() y funciono sin problemas.

en mi trifuncion tuve que usar applay xq apply no me deja.

“La anotación @FunctionalInterface no es estrictamente necesaria para que una interfaz sea funcional, pero proporciona una forma explícita de indicar las intenciones del programador. Además, el uso de la anotación permite que el compilador realice verificaciones adicionales, lo que ayuda a evitar errores al usar interfaces funcionales.”

now() = 2019

22:27

SAM es Single Abstract Method, es una interface que debe tener solo un método.

Functional Interface: para que un interface se vuelva funcional, tiene que ser una SAM, sino es así, Java no me va a dejar volverla funcional

Sin la anotacion tambien funciona.
en realidad el unico valor que le agrega la anotacion es que valida que tenga un solo metodo.

Aso no tenga la anotacion. sino si una intefaz solo tiene un metodo abtracto. es considerada funcional.

Vale entonces para hacer nuestras propias funciones Funcionales solo necesitamos de una interfaz y la anotación @FunctionalInterface que maravilla

Esta clase me encantó, muy útil esta información y el ejemplo está perfecto aplicando lo visto hasta ahora.

Esta clase fue colosal, me encantó.

en function addCeros que quiere decir el símbolo “?”

Muchas gracias

Genial 😃 gracias… me corrió sin problemas el ejercicio 😃

Bien, me encantó. Algo nuevo… 😉

Increible

public class AgeUtils {
    public static void main(String[] args) {
        Function<Integer, String> addZero = x -> x < 10 ? "0" + x : String.valueOf(x);

        ITryFunction<Integer, Integer, Integer, LocalDate> parseDate =
                (day, month, year) -> LocalDate.parse(year + "-" + addZero.apply(month) + "-" + addZero.apply(day));

        ITryFunction<Integer, Integer, Integer, Integer> calculateAge =
                (day, month, year) -> Period.between(parseDate.apply(day, month, year), LocalDate.now()).getYears();

        System.out.println(calculateAge.apply(13, 9, 1996));
    }

    @FunctionalInterface
    interface ITryFunction<T, U, V, R>{
        R apply(T t, U u, V v);
    }
}

Muy bien Explicado

Perfecto con esto puedo generar funciones simples a la medida del proyecto que estemos desarrollando, de manera de evitar que se repitan operaciones a lo largo del proyecto.

Define que una interfaz se va a usar como una función