Interfaces Fonctionnelles

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy — leçon 39 sur 87.

Une interface fonctionnelle est une interface qui contient exactement une méthode abstraite. Cette contrainte de méthode unique rend les interfaces fonctionnelles spéciales car elles peuvent être implémentées à l'aide d'expressions lambda, permettant un style de codage plus concis.

Java fournit l'annotation @FunctionalInterface pour marquer explicitement une interface comme fonctionnelle. Bien qu'elle soit facultative, cette annotation aide le compilateur à détecter les erreurs si vous ajoutez accidentellement une deuxième méthode abstraite :

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

Vous pouvez implémenter une interface fonctionnelle de la manière traditionnelle avec une classe, ou de manière plus concise avec une expression lambda :

// Implémentation traditionnelle
Calculator adder = new Calculator() {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
};

// Expression lambda (beaucoup plus courte !)
Calculator adder = (a, b) -> a + b;

System.out.println(adder.calculate(5, 3));  // 8

Les interfaces fonctionnelles peuvent toujours avoir des méthodes par défaut et des méthodes statiques, car celles-ci ne comptent pas dans la règle de la méthode abstraite unique. Le package java.util.function de Java fournit de nombreuses interfaces fonctionnelles intégrées telles que Predicate, Function et Consumer que vous rencontrerez fréquemment en travaillant avec des flux (streams) et des collections.

Défi

Facile

Construisons un système de transformation de chaînes de caractères en utilisant des interfaces fonctionnelles et des expressions lambda. Vous allez créer un processeur de texte flexible capable d'appliquer différentes transformations aux chaînes de caractères, le tout piloté par une seule interface fonctionnelle.

Vous organiserez votre code sur trois fichiers :

StringTransformer.java : Définissez une interface fonctionnelle qui représente n'importe quelle opération de transformation de chaîne. Marquez-la avec l'annotation @FunctionalInterface pour garantir qu'elle reste fonctionnelle. Votre interface doit déclarer une seule méthode abstraite appelée transform qui prend une String et retourne une String.
TextProcessor.java : Créez une classe qui utilise votre interface fonctionnelle pour traiter du texte. Elle doit avoir un champ pour contenir un StringTransformer et un constructeur pour l'initialiser. Incluez une méthode appelée process(String text) qui applique le transformateur au texte donné et retourne le résultat. Cette conception vous permet d'injecter n'importe quel comportement de transformation via le constructeur.
Main.java : Rassemblez le tout en créant différentes transformations à l'aide d'expressions lambda. Vous recevrez deux entrées : une chaîne de texte et un type d'opération (upper, lower, ou reverse).
En fonction du type d'opération, créez un TextProcessor avec la lambda appropriée :
- upper : transforme le texte en majuscules
- lower : transforme le texte en minuscules
- reverse : inverse le texte (astuce : utilisez StringBuilder)
Ensuite, appelez process() avec le texte d'entrée et affichez le résultat dans ce format : Result: [transformed text]

Vous recevrez deux entrées : le texte à transformer (String) et le type d'opération (String).

Remarquez comment la même classe TextProcessor peut effectuer des opérations complètement différentes selon la lambda que vous passez — c'est toute la puissance des interfaces fonctionnelles !

Aide-mémoire

Une interface fonctionnelle est une interface avec exactement une méthode abstraite. Elle peut être implémentée à l'aide d'expressions lambda pour un code concis.

Utilisez l'annotation @FunctionalInterface pour marquer une interface comme fonctionnelle (optionnel mais recommandé) :

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

Les interfaces fonctionnelles peuvent être implémentées de manière traditionnelle ou avec des expressions lambda :

// Implémentation traditionnelle
Calculator adder = new Calculator() {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
};

// Expression lambda
Calculator adder = (a, b) -> a + b;

System.out.println(adder.calculate(5, 3));  // 8

Les interfaces fonctionnelles peuvent avoir des méthodes par défaut et statiques sans violer la règle de la méthode abstraite unique.

Le package java.util.function de Java fournit des interfaces fonctionnelles intégrées telles que Predicate, Function et Consumer.

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String text = scanner.nextLine();
        String operation = scanner.nextLine();
        
        TextProcessor processor;
        
        // TODO : En fonction du type d'opération, créez un TextProcessor avec la lambda appropriée :
        // - "upper" : transforme le texte en majuscules
        // - "lower" : transforme le texte en minuscules
        // - "reverse" : inverse le texte (indice : utilisez StringBuilder)
        
        // TODO : Appelez process() avec le texte d'entrée et affichez le résultat
        // Format de sortie : "Result: [transformed text]"
    }
}