Conception par Objet et Programmation Java

Ce document présente les nouveautés introduites par Java 8 concernant les interfaces, en particulier les méthodes par défaut, les méthodes statiques, et les interfaces fonctionnelles. Il s'adresse aux étudiants et développeurs souhaitant approfondir leur compréhension de la programmation orientée objet en Java et exploiter les nouvelles fonctionnalités des interfaces pour concevoir des API modernes et compatibles.

Les méthodes par défaut et les méthodes statiques dans les interfaces

Java 8 introduit deux nouveautés majeures pour les interfaces : les méthodes statiques et les méthodes par défaut. Les méthodes statiques dans les interfaces fonctionnent de manière identique à celles des classes, donc leur usage est simple et ne modifie pas fondamentalement la conception.

En revanche, les méthodes par défaut permettent d'ajouter de nouvelles fonctionnalités aux interfaces tout en assurant la compatibilité avec les versions antérieures du JDK. Cela modifie profondément la manière de concevoir les API, car il est désormais possible de fournir une implémentation par défaut dans une interface.

Exemple de méthode par défaut

Considérons l'interface suivante nommée Formule :

public interface Formule {
    double calculer(double a);
    default double sqrt(double a) {
        return Math.sqrt(a);
    }
}

Dans cet exemple, la méthode calculer est abstraite et doit être implémentée par les classes concrètes, tandis que la méthode sqrt est une méthode par défaut qui fournit une implémentation prête à l'emploi.

Implémentation anonyme d'une interface avec méthode par défaut

Voici un exemple d'implémentation anonyme de l'interface Formule :

Formule formule = new Formule() {
    public double calculer(double a) {
        return sqrt(a * 100);
    }
};

Ce code, bien que fonctionnel, est verbeux (6 lignes pour un simple calcul). Les chapitres suivants présenteront une manière plus concise d'implémenter des interfaces à méthode abstraite unique grâce aux expressions lambda.

Les interfaces fonctionnelles

Une interface fonctionnelle est une interface qui ne contient qu'une seule méthode abstraite. Elle sert à définir la signature d'une méthode pouvant être passée en paramètre sous forme :

• d'une référence vers une méthode statique
• d'une référence vers une méthode d'instance
• d'une référence vers un constructeur
• d'une expression lambda

On peut annoter une interface fonctionnelle avec @FunctionalInterface. Cette annotation n'est pas obligatoire, mais elle permet au compilateur de vérifier que l'interface ne contient qu'une seule méthode abstraite. Si ce n'est pas le cas, une erreur de compilation est générée.

Les interfaces fonctionnelles les plus utilisées en Java 8

Function

Interface représentant une fonction qui prend un argument et retourne un résultat. Sa méthode abstraite est :

R apply(T t);

Déclaration :

@FunctionalInterface
public interface Function<T,R> {
    R apply(T t);
}

Supplier

Interface qui produit un résultat d'un type donné sans accepter d'arguments. Sa méthode abstraite est :

T get();

Déclaration :

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

Consumer

Interface représentant une opération qui accepte un seul argument et ne renvoie aucun résultat. Sa méthode abstraite est :

void accept(T t);

Déclaration :

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

Predicate

Interface représentant une opération qui accepte un seul argument et retourne un résultat de type Boolean. Sa méthode abstraite est :

boolean test(T t);

Déclaration :

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

Comparator

Interface bien connue pour comparer deux objets et imposer un ordre total. Sa méthode abstraite est :

int compare(T o1, T o2);

Déclaration :

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
}

BiFunction

Interface représentant une fonction prenant deux arguments et produisant un résultat. Sa méthode abstraite est :

R apply(T t, U u);

Déclaration :

@FunctionalInterface
public interface BiFunction<T,U,R> {
    R apply(T t, U u);
}

UnaryOperator

Interface représentant une opération sur un seul opérande qui produit un résultat du même type. C'est une spécialisation de Function où l'entrée et la sortie sont du même type. Sa méthode abstraite est :

T apply(T t);

Déclaration :

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T,T> {
    T apply(T t);
}

Glossaire des termes clés

• Méthode par défaut : méthode dans une interface qui possède une implémentation et peut être utilisée par les classes implémentant l'interface sans la redéfinir.
• Méthode statique : méthode définie dans une interface accessible via l'interface elle-même, sans instance.
• Interface fonctionnelle : interface ne contenant qu'une seule méthode abstraite, utilisée pour représenter une fonction ou une opération.
• @FunctionalInterface : annotation indiquant qu'une interface est fonctionnelle, permettant au compilateur de vérifier cette contrainte.
• Expression lambda : syntaxe concise permettant d'implémenter une interface fonctionnelle en fournissant directement le corps de la méthode abstraite.
• Function : interface fonctionnelle représentant une fonction prenant un argument et retournant un résultat.
• Supplier : interface fonctionnelle produisant un résultat sans argument.
• Consumer : interface fonctionnelle acceptant un argument et ne retournant rien.
• Predicate : interface fonctionnelle acceptant un argument et retournant un booléen.
• Comparator : interface fonctionnelle comparant deux objets pour imposer un ordre.
• BiFunction : interface fonctionnelle prenant deux arguments et retournant un résultat.
• UnaryOperator : interface fonctionnelle opérant sur un seul argument et retournant un résultat du même type.

Points clés à retenir

• Java 8 introduit les méthodes par défaut et statiques dans les interfaces pour enrichir les API tout en assurant la compatibilité.
• Les méthodes par défaut permettent d'ajouter du comportement sans casser les implémentations existantes.
• Les interfaces fonctionnelles sont au cœur des expressions lambda et des références de méthode en Java 8.
• L'annotation @FunctionalInterface garantit qu'une interface ne contient qu'une seule méthode abstraite.
• Java 8 propose plusieurs interfaces fonctionnelles standards comme Function, Supplier, Consumer, Predicate, Comparator, BiFunction et UnaryOperator.