Formations — 1 037 leçons en français

Accueil › Java › Les interfaces fonctionnelles

Les interfaces fonctionnelles

Programmation fonctionnelleintermediaire

Une interface fonctionnelle est une interface avec une seule méthode abstraite. @FunctionalInterface documente cette intention et fait échouer la compilation si une deuxième méthode abstraite est ajoutée par erreur — elle est optionnelle mais recommandée.

java.util.function fournit les interfaces les plus courantes, à connaître avant d'en écrire une soi-même :

Interface Méthode abstraite Usage typique
Function<T,R> R apply(T t) transformer une valeur
BiFunction<T,U,R> R apply(T t, U u) combiner deux valeurs en une
Predicate<T> boolean test(T t) tester une condition
Consumer<T> void accept(T t) effet de bord (afficher, enregistrer)
Supplier<T> T get() fournir une valeur à la demande
UnaryOperator<T> T apply(T t) transformer une valeur en une du même type
BinaryOperator<T> T apply(T t1, T t2) combiner deux valeurs du même type
Function<Produit, Double> prixTTC = p -> p.prixHT() * 1.20;
Predicate<Produit> enStock = p -> p.quantite() > 0;
Consumer<Produit> journaliser = p -> System.out.println("Traité : " + p.nom());
Supplier<Produit> defaut = () -> new Produit("Inconnu", 0.0);

Ces interfaces se composent sans écrire de nouvelle lambda : Predicate.and, or, negate, Function.andThen, compose. Des variantes primitives (IntPredicate, ToIntFunction<T>, IntUnaryOperator…) évitent l'autoboxing quand le type manipulé est int, long ou double.

Les termes à connaître

@FunctionalInterface

Annotation optionnelle qui documente l'intention et fait vérifier par le compilateur qu'une interface ne déclare bien qu'une seule méthode abstraite. Sans elle, une interface à une seule méthode abstraite reste utilisable comme cible de lambda, mais sans ce filet de sécurité si une deuxième méthode abstraite est ajoutée par erreur.

Function<T,R>

Transforme une valeur de type T en une valeur de type R via apply(T). Composable avec andThen (enchaîner après) et compose (enchaîner avant).

Predicate<T>

Teste une valeur de type T et renvoie un boolean via test(T). Composable avec and, or et negate.

Consumer<T>

Consomme une valeur de type T sans rien renvoyer (void accept(T)). Utilisé pour un effet de bord : afficher, enregistrer, envoyer.

Supplier<T>

Ne prend aucun argument et fournit une valeur de type T via get(). Utilisé pour différer un calcul ou une création d'objet jusqu'au moment où elle est réellement nécessaire.

Variante primitive

Version spécialisée d'une interface fonctionnelle pour int, long ou double (IntPredicate, ToIntFunction<T>, IntUnaryOperator…), qui évite l'autoboxing en travaillant directement sur le type primitif.

Composition fonctionnelle

Combiner plusieurs interfaces fonctionnelles en une seule via des méthodes par défaut (andThen, compose, and, or, negate) plutôt qu'en écrivant une nouvelle lambda qui répète la logique des précédentes.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.