Introducción a las interfaces funcionales

Por favor, no trollees demasiado, apenas estoy empezando a traducir artículos.

Introducción a las interfaces funcionales: conceptos recreados en Java 8

Todos los desarrolladores de Java del mundo han utilizado una de las siguientes interfaces al menos una vez: java.lang.Runnable, java.awt.event.ActionListener, java.util.Comparator, java.util.concurrent.Callable. Todos tienen una cosa en común, y es que todos tienen un solo método. Hay muchas otras interfaces similares en el JDK, así como otras creadas por desarrolladores de Java. Estas interfaces también se conocen como Single Abstract Method interfaces(interfaces SAM). Una de las formas más populares de utilizar estas interfaces es crear clases internas anónimas que utilicen estas interfaces, como en el siguiente ejemplo:

public class AnonymousInnerClassTest {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("A thread created and running...");
            }
        }).start();
    }
}

En Java 8, el concepto SAM se recrea y se denomina interfaces funcionales. Se pueden representar mediante expresiones lambda, referencias a métodos y constructores de referencia. Se ha creado una nueva anotación @FunctionalInterface que se utiliza para generar errores en el nivel del compilador cuando la interfaz que anotó no funciona en el nivel funcional. Veamos una interfaz funcional simple con un método abstracto:

@FunctionalInterface
public interface SimpleFunInterface {
    public void doWork();
}

Una interfaz también puede declarar métodos abstractos de una clase java.lang.Object, pero en este caso la interfaz también se puede declarar funcional:

@FunctionalInterface
public interface SimpleFuncInterface {
    public void doWork();
    public String toString();
    public Boolean equals(Object o);
}

Tan pronto como haya agregado otro método abstracto a la interfaz, el IDE lo marcará como erróneo como en la imagen: Una interfaz puede heredar de otra interfaz; si la interfaz hereda de una interfaz funcional y no contiene nuevos métodos abstractos, entonces esta interfaz también es funcional. Pero una interfaz sólo puede contener un método abstracto y muchos métodos predeterminados, y aun así se considerará funcional.

@FunctionalInterface
public interface ComplexFunctionalInterface extends SimpleFuncInterface {
    default public void doSomeWork() {
        System.out.println("Doing some work in interface impl...");
    }
    default public void doSomeWork() {
        System.out.println("Doing some other work in interface impl...");
    }
}

El mejor ejemplo sigue siendo una interfaz funcional. Ahora veamos cómo podemos usar expresiones lambda para reemplazar una clase interna anónima para implementar interfaces funcionales:

/*
*Implementation the interface by creating an
*anonymoous inner class versus using
*lambda expression.
*/
public class SimpleFunInterfaceTest {
    public static void main(String[] args) {
        carryOutWork(new SimpleFunInterface() {
            @Override
            public void doWork() {
                System.out.println("Do work in SimpleFun impl...");
            }
        });
        carryOutWork(() -> System.out.println("Do work in lambda exp impl..."));
    }
    public static void carryOutWork(SimpleFuncInterface sfi) {
        sfi.work();
    }
}

El resultado del programa será el siguiente:

Do work in SimpleFun impl...
Do work in lambda exp impl...

En caso de que esté utilizando un IDE que admita la sintaxis de expresión lambda de Java (compilaciones nocturnas de Netbeans 8), obtendrá una pista cuando utilice clases internas anónimas: esta fue una breve introducción al concepto de interfaces funcionales en Java 8 y cómo se pueden implementar. utilizando expresiones lambda.