Java - Interfaces Fonctionnelles

Bonjour, futurs développeurs Java ! Aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde des Interfaces Fonctionnelles en Java. Ne vous inquiétez pas si vous êtes nouveau en programmation ; je vais vous guider à travers ce concept pas à pas, tout comme j'ai fait pour d'innombrables étudiants au fil des années. Alors, prenez un café (ou votre boisson préférée), et plongeons-y !

Qu'est-ce qu'une Interface Fonctionnelle ?

Imaginez que vous êtes à une fête, et que vous êtes assigné au rôle de DJ. Votre travail est simple : jouer de la musique. Vous n'avez pas besoin de vous soucier de servir de la nourriture ou de décorer le lieu. En Java, une Interface Fonctionnelle est comme ce DJ - elle a un travail spécifique à faire, et elle le fait bien.

En termes techniques, une Interface Fonctionnelle est une interface qui contient exactement une méthode abstraite. Elle peut avoir d'autres méthodes, mais elles doivent être des méthodes par défaut ou statiques. La méthode abstraite unique est ce qui confère à l'Interface Fonctionnelle sa nature "fonctionnelle".

Exemple 1 : Une Interface Fonctionnelle Simple

@FunctionalInterface
interface Saluteur {
void saluer(String nom);
}

Dans cet exemple, Saluteur est une Interface Fonctionnelle. Elle n'a qu'une seule méthode abstraite saluer, qui prend un paramètre de type String et ne retourne rien (void).

Annotation @FunctionalInterface

Vous avez peut-être remarqué l'annotation @FunctionalInterface dans notre exemple. C'est comme mettre un badge "DJ" sur notre interface. Elle indique à Java, "Eh, cette interface est censée être fonctionnelle !" Si nous ajoutons accidentellement une autre méthode abstraite, Java nous donnera une erreur, nous aidant à maintenir la nature fonctionnelle de notre interface.

Utilisation des Interfaces Fonctionnelles

Maintenant que nous savons ce qu'elles sont, voyons comment nous pouvons les utiliser. Une des choses les plus cool à propos des Interfaces Fonctionnelles est que nous pouvons les utiliser avec des expressions lambda, qui sont comme des méthodes écrites en abrégé.

Exemple 2 : Utilisation d'une Interface Fonctionnelle avec une Expression Lambda

public class TestSaluteur {
public static void main(String[] args) {
Saluteur saluteurAmical = (nom) -> System.out.println("Bonjour, " + nom + " ! Comment ça va ?");
saluteurAmical.saluer("Alice");

Saluteur saluteurFormel = (nom) -> System.out.println("Bonjour, " + nom + ". J'espère que vous allez bien.");
saluteurFormel.saluer("M. Smith");
}
}

Dans cet exemple, nous créons deux salueurs différents en utilisant notre interface Saluteur. Les expressions lambda (nom) -> ... implémentent la méthode saluer à la volée. C'est comme embaucher deux DJs différents pour deux fêtes différentes !

Lorsque vous exécutez ce code, vous verrez :

Bonjour, Alice ! Comment ça va ?
Bonjour, M. Smith. J'espère que vous allez bien.

Types d'Interfaces Fonctionnelles en Java

Java fournit plusieurs Interfaces Fonctionnelles intégrées pour nous faciliter la vie. Examinons quelques-unes des plus couramment utilisées :

1. Predicate

L'interface Predicate<T> est utilisée pour des fonctions booléennes d'un argument. C'est comme une question qui peut être répondue par oui ou non.

import java.util.function.Predicate;

public class ExemplePredicate {
public static void main(String[] args) {
Predicate<Integer> estMajeur = age -> age >= 18;

System.out.println("20 est un âge majeur ? " + estMajeur.test(20));
System.out.println("15 est un âge majeur ? " + estMajeur.test(15));
}
}

Ce qui en résultera :

20 est un âge majeur ? true
15 est un âge majeur ? false

2. Function<T,R>

L'interface Function<T,R> représente une fonction qui accepte un argument et produit un résultat. C'est comme une machine qui prend quelque chose en entrée et donne quelque chose d'autre en sortie.

import java.util.function.Function;

public class ExempleFunction {
public static void main(String[] args) {
Function<String, Integer> longueurChaine = str -> str.length();

System.out.println("Longueur de 'Bonjour' : " + longueurChaine.apply("Bonjour"));
System.out.println("Longueur de 'Java est génial' : " + longueurChaine.apply("Java est génial"));
}
}

Ce qui en résultera :

Longueur de 'Bonjour' : 7
Longueur de 'Java est génial' : 14

3. Consumer

L'interface Consumer<T> représente une opération qui accepte un seul argument en entrée et ne retourne pas de résultat. C'est comme un trou noir qui consomme des données mais ne produit rien.

import java.util.function.Consumer;

public class ExempleConsumer {
public static void main(String[] args) {
Consumer<String> imprimeur = message -> System.out.println("Impression : " + message);

imprimeur.accept("Bonjour, Interface Fonctionnelle !");
imprimeur.accept("Java est amusant !");
}
}

Ce qui en résultera :

Impression : Bonjour, Interface Fonctionnelle !
Impression : Java est amusant !

4. Supplier

L'interface Supplier<T> représente un fournisseur de résultats. Elle n'accepte pas d'arguments mais produit une valeur. C'est comme une machine à sous qui vous donne quelque chose sans que vous mettiez quoi que ce soit dedans.

import java.util.function.Supplier;
import java.util.Random;

public class ExempleSupplier {
public static void main(String[] args) {
Supplier<Integer> fournisseurNombreAleatoire = () -> new Random().nextInt(100);

System.out.println("Nombre aléatoire : " + fournisseurNombreAleatoire.get());
System.out.println("Autre nombre aléatoire : " + fournisseurNombreAleatoire.get());
}
}

Ce qui en résultera deux nombres aléatoires entre 0 et 99, par exemple :

Nombre aléatoire : 42
Autre nombre aléatoire : 73

Interfaces Fonctionnelles Existantes Avant Java 8

Avant que Java 8 n'introduise le concept des Interfaces Fonctionnelles, Java avait quelques interfaces qui correspondaient à la définition. Ces dernières étaient principalement utilisées pour la gestion des événements et la programmation concurrente. Examinons quelques exemples :

1. Runnable

L'interface Runnable a été là depuis les débuts de Java. Elle est couramment utilisée pour créer des threads.

public class ExempleRunnable {
public static void main(String[] args) {
Runnable helloRunnable = () -> System.out.println("Bonjour d'un thread !");
new Thread(helloRunnable).start();
}
}

Ce qui en résultera :

Bonjour d'un thread !

2. Comparator

L'interface Comparator est utilisée pour définir un ordre personnalisé pour les objets.

import java.util.Arrays;
import java.util.Comparator;

public class ExempleComparator {
public static void main(String[] args) {
String[] noms = {"Alice", "Bob", "Charlie", "David"};

Comparator<String> comparateurLongueur = (s1, s2) -> s1.length() - s2.length();

Arrays.sort(noms, comparateurLongueur);

System.out.println("Trié par longueur : " + Arrays.toString(noms));
}
}

Ce qui en résultera :

Trié par longueur : [Bob, Alice, David, Charlie]

Conclusion

Félicitations ! Vous venez de faire vos premiers pas dans le monde des Interfaces Fonctionnelles en Java. Nous avons couvert ce qu'elles sont, comment les utiliser, et examiné quelques types courants. Souvenez-vous, les Interfaces Fonctionnelles sont comme des outils spécialisés dans votre boîte à outils Java. Elles vous aident à écrire un code plus propre et plus expressif.

À mesure que vous continuerez votre voyage en Java, vous trouverez de plus en plus d'utilisations pour les Interfaces Fonctionnelles. Elles sont particulièrement puissantes lorsqu'elles sont utilisées avec des streams et des collections, ce que nous couvrirons dans des leçons futures.

Continuez à pratiquer, soyez curieux, et surtout, amusez-vous à coder ! Java est un langage vaste et passionnant, et vous êtes bien parti pour le maîtriser. À la prochaine fois, bonne codation !

Credits: Image by storyset