Introduzione alle interfacce funzionali

Per favore, non trollare troppo, sto appena iniziando a tradurre articoli

Introduzione alle interfacce funzionali - Concetti ricreati in Java 8

Ogni sviluppatore Java nel mondo ha utilizzato almeno una volta una delle seguenti interfacce: java.lang.Runnable, java.awt.event.ActionListener, java.util.Comparator, java.util.concurrent.Callable. Hanno tutti una cosa in comune, ovvero che hanno tutti un solo metodo. Esistono molte altre interfacce simili nel JDK, così come altre create dagli sviluppatori Java. Queste interfacce sono anche conosciute come Single Abstract Method interfaces(interfacce SAM). Uno dei modi più popolari per utilizzare queste interfacce è creare classi interne anonime che utilizzino queste interfacce, come nell'esempio seguente:

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();
    }
}

In Java 8, il concetto SAM viene ricreato e chiamato interfacce funzionali. Possono essere rappresentati utilizzando espressioni lambda, riferimenti a metodi e costruttori di riferimenti. È stata creata una nuova annotazione @FunctionalInterface che viene utilizzata per generare errori a livello di compilatore quando l'interfaccia annotata non funziona a livello funzionale. Diamo un'occhiata a una semplice interfaccia funzionale con un metodo astratto:

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

Un'interfaccia può anche dichiarare metodi astratti da una classe java.lang.Object, ma in questo caso l'interfaccia può anche essere dichiarata funzionale:

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

Non appena avrai aggiunto un altro metodo astratto all'interfaccia, l'IDE lo contrassegnerà come errato come nell'immagine: Un'interfaccia può ereditare da un'altra interfaccia; se l'interfaccia eredita da un'interfaccia funzionale e non contiene nuovi metodi astratti, allora anche questa interfaccia è funzionale. Ma un'interfaccia può contenere solo un metodo astratto e molti metodi predefiniti e sarà comunque considerata funzionale.

@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...");
    }
}

L'esempio principale è ancora un'interfaccia funzionale. Ora diamo un'occhiata a come possiamo utilizzare le espressioni lambda per sostituire una classe interna anonima per implementare interfacce funzionali:

/*
*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();
    }
}

Il risultato del programma sarà il seguente:

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

Nel caso in cui si utilizzi un IDE che supporti la sintassi dell'espressione lambda Java (build Netbeans 8 Nightly) - si ottiene un suggerimento quando si utilizzano classi interne anonime: questa era una breve introduzione al concetto di interfacce funzionali in Java 8 e come possono essere implementate utilizzando le espressioni lambda.