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 d’une seule méthode rend les interfaces fonctionnelles particulières, car elles peuvent être implémentées à l’aide d’expressions lambda, ce qui permet un style de programmation plus concis.

Java fournit l’annotation @FunctionalInterface pour marquer explicitement une interface comme fonctionnelle. Bien que 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 manière traditionnelle avec une classe, ou de façon 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 l’unique méthode abstraite. Le package java.util.function de Java fournit de nombreuses interfaces fonctionnelles intégrées comme Predicate, Function et Consumer, que vous rencontrerez fréquemment lorsque vous travaillerez avec des flux et des collections.

Défi

Facile

Construisons un système de transformation de chaînes à l’aide d’interfaces fonctionnelles et d’expressions lambda. Vous allez créer un processeur de texte flexible capable d’appliquer différentes transformations aux chaînes : le tout grâce à une seule interface fonctionnelle.

Vous allez organiser votre code sur trois fichiers :

StringTransformer.java : définissez une interface fonctionnelle qui représente toute opération de transformation de chaîne. Annotez-la avec l’annotation @FunctionalInterface pour vous assurer qu’elle reste fonctionnelle. Votre interface doit déclarer une seule méthode abstraite appelée transform, qui prend une String et renvoie une String.
TextProcessor.java : créez une classe qui utilise votre interface fonctionnelle pour traiter du texte. Elle doit posséder un champ contenant un StringTransformer ainsi qu’un constructeur pour l’initialiser. Incluez une méthode appelée process(String text) qui applique le transformateur au texte fourni et renvoie le résultat. Cette conception vous permet d’injecter n’importe quel comportement de transformation via le constructeur.
Main.java : assemblez 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 (indice : utilisez StringBuilder)
Appelez ensuite 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 que la même classe TextProcessor peut effectuer des opérations complètement différentes selon la lambda que vous lui transmettez : c’est là toute la puissance des interfaces fonctionnelles !

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 le lambda approprié :
        // - "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]"
    }
}