Introduction aux interfaces fonctionnelles

S'il vous plaît, ne trollez pas trop, je commence tout juste à traduire les articles.

Introduction aux interfaces fonctionnelles - Concepts recréés en Java 8

Chaque développeur Java dans le monde a utilisé au moins une fois l'une des interfaces suivantes : java.lang.Runnable, java.awt.event.ActionListener, java.util.Comparator, java.util.concurrent.Callable. Ils ont tous une chose en commun, c’est qu’ils n’ont tous qu’une seule méthode. Il existe de nombreuses autres interfaces de ce type dans le JDK, ainsi que d'autres créées par les développeurs Java. Ces interfaces sont également appelées Single Abstract Method interfaces(interfaces SAM). L'une des façons les plus courantes d'utiliser ces interfaces consiste à créer des classes internes anonymes qui utilisent ces interfaces, comme dans l'exemple suivant :

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

Dans Java 8, le concept SAM est recréé et appelé interfaces fonctionnelles. Ils peuvent être représentés à l'aide d'expressions lambda, de références de méthode et de constructeurs de référence. Une nouvelle annotation @FunctionalInterface a été créée. Elle est utilisée pour générer des erreurs au niveau du compilateur lorsque l'interface que vous avez annotée ne fonctionne pas au niveau fonctionnel. Examinons une interface fonctionnelle simple avec une méthode abstraite :

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

Une interface peut aussi déclarer des méthodes abstraites d'une classe java.lang.Object, mais dans ce cas l'interface peut aussi être déclarée fonctionnelle :

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

Dès que vous avez ajouté une autre méthode abstraite à l'interface, l'IDE la marquera comme erronée comme sur l'image : Une interface peut hériter d'une autre interface ; si l'interface hérite d'une interface fonctionnelle et ne contient pas de nouvelles méthodes abstraites, alors cette interface est également fonctionnelle. Mais une interface ne peut contenir qu’une seule méthode abstraite et plusieurs méthodes par défaut, et elle sera toujours considérée comme fonctionnelle.

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

Le meilleur exemple est toujours une interface fonctionnelle. Voyons maintenant comment utiliser les expressions lambda pour remplacer une classe interne anonyme afin d'implémenter des interfaces fonctionnelles :

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

Le résultat du programme sera le suivant :

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

Si vous utilisez un IDE prenant en charge la syntaxe d'expression Java lambda (versions Netbeans 8 Nightly) - Vous obtenez un indice lors de l'utilisation de classes internes anonymes : il s'agissait d'une brève introduction au concept d'interfaces fonctionnelles dans Java 8 et à la manière dont elles peuvent être implémentées. en utilisant des expressions lambda.