Nouvelles fonctionnalités de Java 8 : méthodes d'interface par défaut

Résumé : à partir de Java8, l'interface n'est pas seulement un endroit où les méthodes peuvent uniquement être déclarées. Nous pouvons également donner à la méthode une implémentation par défaut lors de la déclaration de la méthode, nous l'appelons la méthode d'interface par défaut, de sorte que tous les enfants qui le soient. implémenter l'interface Les classes peuvent contenir une implémentation par défaut de cette méthode.

1. L'arrière-plan de l'introduction des méthodes d'interface par défaut

java8 peut être considérée comme la version qui a le plus changé dans le processus itératif de mise à jour de la version Java (uniquement par Nous devrions être heureux qu'il soit immortel), mais après tant d'années de développement et d'itérations, le code source de Java est devenu un monstre, et il ne sera certainement pas facile de faire un grand pas dans ce sens un volume énorme. Ainsi, lorsque j'ai vu pour la première fois les méthodes d'interface par défaut de Java 8, mon premier sentiment a été qu'il s'agissait d'un trou creusé par les concepteurs Java avant de le combler.

D'après les explications précédentes, nous savons que java8 a ajouté de nombreuses méthodes aux interfaces existantes, comme la méthode

sort(Comparator<? super E> c)

de List. Si vous suivez les idées de conception des interfaces antérieures à Java 8, lors de l'ajout d'une déclaration de méthode à une interface, la classe qui implémente l'interface doit ajouter une implémentation correspondante pour la méthode nouvellement ajoutée. Compte tenu de la compatibilité, cela n'est pas conseillé, c'est donc un piège, et les nouvelles fonctionnalités nécessitent d'ajouter de nouvelles méthodes à l'interface. Afin d'avoir le gâteau et de le manger aussi, les concepteurs de Java8 ont proposé la méthode d'interface par défaut. . concept.

De cette façon, la méthode d'interface par défaut semble être développée pour les concepteurs d'API, ce qui est encore loin de nous, développeurs ordinaires, penser ainsi, même si nous n'avons pas besoin de concevoir du JDK. , nous Dans le processus de développement quotidien, il sera toujours nécessaire de fournir des API que d'autres parties commerciales pourront appeler. Lorsque nous mettons à jour nos API, nous pouvons utiliser la méthode par défaut pour fournir des fonctions plus avancées tout en maintenant la compatibilité.

2. Définition de la méthode d'interface par défaut

La définition de la méthode d'interface par défaut est très simple, il suffit d'ajouter un

default

Les mots clés suffisent, comme suit :

public interface A {
    /**
     * 默认方法定义
     */
    default void method() {
        System.out.println("This is a default method!");
    }
}

Quand on définit une méthode par défaut comme celle-ci, toutes les sous-classes qui implémentent cette interface détiennent indirectement cette méthode. Ou vous avez peut-être l'impression comme moi que les interfaces et les classes abstraites deviennent effectivement de plus en plus similaires, mais il existe toujours les différences suivantes entre elles :

1 Une classe ne peut hériter que d'une seule classe, mais peut en implémenter plusieurs. interfaces

2. Les classes abstraites peuvent définir des variables, mais les interfaces ne le peuvent pas.
En plus de résoudre les problèmes que nous avons mentionnés ci-dessus, l'abstraction présente également les avantages suivants :

Pour certaines choses qui. ne sont pas toutes les méthodes dont toutes les sous-classes ont besoin, nous lui donnons une implémentation par défaut pour éviter les implémentations dénuées de sens dans les sous-classes (généralement, nous lancerons une nouvelle UnsupportedException())

2 La méthode par défaut est java L'héritage multiple fournit une nouvelle. manière (bien que nous ne puissions hériter que d'une seule classe, nous pouvons implémenter plusieurs interfaces, et désormais les interfaces peuvent également définir des méthodes par défaut)

Conflits et leurs solutions

Parce qu'une classe peut le faire. implémentez plusieurs interfaces, des conflits se produiront lorsqu'une classe implémentera plusieurs interfaces et qu'il existe deux méthodes par défaut ou plus avec la même signature de méthode dans ces interfaces, définition java8. Les trois principes suivants sont utilisés pour résoudre les conflits :

1. Les méthodes explicitement déclarées dans une classe ou une classe parent ont une priorité plus élevée que toutes les méthodes par défaut

2. Si la règle 1 échoue, sélectionnez La méthode par défaut avec une implémentation spécifique la plus proche de la classe actuelle

3. Si la règle 2 échoue également, vous devez spécifier explicitement l'interface
Ce qui suit est expliqué à travers plusieurs exemples :

Exemple 1

public interface A {
    /**
     * 默认方法定义
     */
    default void method() {
        System.out.println("A's default method!");
    }
}
public interface B extends A {
    /**
     * 默认方法定义
     */
    default void method() {
        System.out.println("B's default method!");
    }
}
public class C implements A, B {
    public static void main(String[] args) {
        new C().method();
    }
}
// 输出：B's default method!

Ici parce que l'interface B est plus proche de C que de A, et que la méthode de B est une implémentation par défaut spécifique, selon la règle 2, elle est donc en fait appelée ici est la méthode par défaut de l'interface B

Exemple 2

public class D implements A {
}
public class C extends D implements A, B {
    public static void main(String[] args) {
        new C().method();
    }
}
// 输出：B's default method!

L'exemple 2 ajoute une classe D qui implémente l'interface A sur la base des interfaces d'origine A et B, puis la classe C hérite de D et implémente A et B. Bien que C soit plus proche de D, parce que l'implémentation spécifique de D est dans A, la méthode par défaut dans B est toujours l'implémentation par défaut la plus proche. Selon la règle 2, ici ce qu'on appelle en réalité est la méthode par défaut de B.

Exemple 3

// A接口不变
public interface B {
    /**
     * 默认方法定义
     */
    default void method() {
        System.out.println("B's default method!");
    }
}
public class C implements A, B {
    @Override
    public void method() {
        // 必须显式指定
        B.super.method();
    }
    public static void main(String[] args) {
        new C().method();
    }
}

Dans l'exemple 3, l'interface B n'hérite plus de l'interface A, donc la méthode par défaut est appelée en C à ce moment

method()

La distance d'implémentation spécifique des interfaces A et B est la même, et le compilateur ne peut pas la déterminer, donc une erreur est signalée. À ce stade, elle doit être spécifiée explicitement :

<.>.

B.super.method()

Ce qui précède est le contenu de la nouvelle fonctionnalité de Java8, la méthode d'interface par défaut. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !