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
Ten une valeur de typeRviaapply(T). Composable avecandThen(enchaîner après) etcompose(enchaîner avant).- Predicate<T>
Teste une valeur de type
Tet renvoie unbooleanviatest(T). Composable avecand,oretnegate.- Consumer<T>
Consomme une valeur de type
Tsans 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
Tviaget(). 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,longoudouble(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.
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.