La mise en œuvre de deux des interfaces avec les deux méthodes par défaut de la même signature dans Java 8

Supposons que je dispose de deux interfaces:

public interface I1
{
    default String getGreeting() {
        return "Good Morning!";
    }
}

public interface I2
{
    default String getGreeting() {
        return "Good Afternoon!";
    }
}

Si je veux mettre en œuvre les deux d'entre eux, quelle mise en œuvre seront utilisées?

public class C1 implements I1, I2
{
    public static void main(String[] args)
    {
        System.out.println(new C1().getGreeting());
    }
}

Que faire Si I2 s'étend I1 et C1 implémente I2 !!? Je pense que cela va compiler...ou je me trompe ?
Merci pour la question! J'ai juste essayé: oui, cela va compiler, quel que soit getGreeting() dans I1 est abstrait ou par défaut. Si la méthode de I1 est par défaut, cela signifie que vous pouvez remplacer la valeur par défaut de mise en œuvre de l'interface-intheritance...
Oui exactement...Ça sera la méthode héritée.
Voici un article sur les méthodes par Défaut : Java 8 : méthode par Défaut dans l'Interface

InformationsquelleAutor kavai77 | 2014-03-27

55

C'est une erreur de compilation. Vous ne pouvez pas avoir deux de la mise en œuvre de deux interfaces.

Cependant, il est correct, si vous mettez en œuvre la getGreeting méthode dans C1:
```
public class C1 implements I1, I2 //this will compile, bacause we have overridden getGreeting()
{
    public static void main(String[] args)
    {
        System.out.println(new C1().getGreeting());
    }

    @Override public String getGreeting()
    {
        return "Good Evening!";
    }
}
```
Je veux juste ajouter que, même si la méthode de I1 est abstrait, et par défaut dans I2, vous ne pouvez pas mettre en œuvre les deux d'entre eux. Donc, c'est aussi une erreur de compilation:
```
public interface I1
{
    String getGreeting();
}

public interface I2
{
    default String getGreeting() {
        return "Good afternoon!";
    }
}

public class C1 implements I1, I2 //won't compile
{
    public static void main(String[] args)
    {
        System.out.println(new C1().getGreeting());
    }
}
```
- C'est une réponse...à mon humble avis !!!
- Notez que cela permettra de compiler et d'exécuter (bien sûr) si I2 ne dispose pas d'une méthode par défaut avec la double signature. Si vous ajoutez ultérieurement que la méthode par défaut pour I2, après la compilation de I1 et C1, alors C1 (qui auparavant fonctionnait bien) lèvera une erreur d'exécution. C'est un gros bémol à l'idée que l'ajout de méthodes par défaut pour les interfaces existantes est "safe" - il existe des scénarios où vous risqueriez de casser le code existant. C'est vraiment important de penser si vous êtes le maintien de bibliothèques.
- Je seconde @James_D sur le potentiel de ce casser le code existant. Ce qui semble être une question qui devra être abordée.
InformationsquelleAutor kavai77
23

Ce n'est pas spécifique à la question. Mais, je pense que cela ajoute de la valeur au contexte. Comme un ajout à l' @toni77 réponse, je tiens à ajouter que, par défaut, la méthode peut être appelé à partir d'une mise en œuvre de la classe, comme indiqué ci-dessous. Dans le code ci-dessous, la méthode par défaut getGreeting() de interface I1 est appelé à partir d'une méthode redéfinie:
```
public interface I1 {
     default String getGreeting() {
        return "Good Morning!";
     }
}

public class C1 implements I1, I2 {       
    @override
    public String getGreeting() {
        return I1.super.getGreeting();
    }
}
```
- Est votre I2 interface vide?
InformationsquelleAutor Keerthivasan

Si une classe implémente 2 interfaces qui ont tous deux une java-8 par défaut de la méthode avec la même signature (comme dans votre exemple), la mise en œuvre de la classe est obligé de remplacer la méthode. La classe pouvez toujours accéder à la méthode par défaut à l'aide de I1.super.getGreeting();. Il peut accéder à l'un, l'autre ou les deux ou aucun des deux. Donc la suite serait valide la mise en œuvre de la C1

public class C1 implements I1, I2{
    public static void main(String[] args)
    {
        System.out.println(new C1().getGreeting());
    }

    @Override //class is obliged to override this method
    public String getGreeting() {
        //can use both default methods
        return I1.super.getGreeting()+I2.super.getGreeting();
    }

    public String useOne() {
        //can use the default method within annother method
        return "One "+I1.super.getGreeting();
    }

    public String useTheOther() {
        //can use the default method within annother method
        return "Two "+I2.super.getGreeting();
    }


}

InformationsquelleAutor Richard Tingle

2

Il y a un cas où cela fonctionne en fait selon les règles de résolution. Si l'une des interfaces s'étend l'un des autres.

À l'aide de l'exemple ci-dessus:
```
public interface I2 extends I1 {
    default String getGreeting() {
        return "Good Afternoon!";
    }
}
```
Le résultat serait:

Bon Après-Midi!

Cependant, je crois que cela va être un gros problème. La raison pour laquelle l'ensemble par défaut des interfaces est de permettre à la bibliothèque de développeurs pour faire évoluer les api sans casser les exécutants.

Compréhensible, ils ne permettent pas de méthodes pour compiler sans la structure d'héritage par extension, car un développeur de la bibliothèque pourrait détourner comportement.

Cependant, ce qui a le potentiel d'être un échec. Si une classe implémente deux interfaces qui ne sont pas liés à partir d'une vue hiérarchique, mais à la fois de définir la même méthode par défaut de signature, puis la classe qui étend les deux interfaces ne compilera pas. (comme démontré ci-dessus)

Il est concevable que les deux différents bibliothèque développeurs pourraient décider d'ajouter des méthodes par défaut à des moments différents à l'aide de signatures courantes; en fait, il est probable que cela se produira dans les bibliothèques qui mettent en œuvre des concepts tels que les bibliothèques de mathématiques. Si vous arrive d'être l'désolé âme la mise en œuvre de deux interfaces dans la même classe, vous allez être cassé sur la mise à jour.

InformationsquelleAutor TechTrip

Je crois que la règle est que la classe de mise en œuvre de la double méthodes par défaut "doit" remplacer la mise en œuvre.. Le suivant compile et fonctionne très bien...

public class DupeDefaultInterfaceMethods {

interface FirstAbility {
    public default boolean doSomething() {
        return true;
    }
}

interface SecondAbility {
    public default boolean doSomething() {
        return true;
    }
}

class Dupe implements FirstAbility, SecondAbility {
    @Override
    public boolean doSomething() {
        return false;
    }
}

public static void main(String[] args) {
    DupeDefaultInterfaceMethods ddif = new DupeDefaultInterfaceMethods();
    Dupe dupe = ddif.new Dupe();
    System.out.println(dupe.doSomething());

    }
}

> false

InformationsquelleAutor Eddie B

Vous devez vous connecter pour publier un commentaire.