Pourquoi une interface ne peut pas implémenter une autre interface?

Ce que je veux dire est:

interface B {...}

interface A extends B {...} // allowed  

interface A implements B {...} // not allowed

Je l'ai googlé et j'ai trouvé ceci :

implementsdésigne la définition d'une implémentation pour les méthodes d'une interface. Cependant, les interfaces n'ont pas d'implémentation donc ce n'est pas possible.

Cependant, l'interface est une classe 100% abstraite, et une classe abstraite peut implémenter des interfaces (classe 100% abstraite) sans implémenter ses méthodes. Quel est le problème quand il est défini comme "interface"?

En détails,

interface A {
    void methodA();
}

abstract class B implements A {} // we may not implement methodA() but allowed

class C extends B {
   void methodA(){}
} 

interface B implements A {} // not allowed. 
//however, interface B = %100 abstract class B

implementssignifie implémentation, quand interfaceest censé déclarer juste pour interfacene pas prévoir d'implémentation.

Un 100% abstract classest fonctionnellement équivalent à un interfacemais il peut également avoir une implémentation si vous le souhaitez (dans ce cas, il ne restera pas à 100% abstract), donc du point de vue de la JVM, ce sont des choses différentes.

De plus, la variable membre dans une classe 100% abstraite peut avoir n'importe quel qualificatif d'accès, là où dans une interface ils sont implicitement public static final.

implementssignifie qu'un comportement sera défini pour les abstractméthodes (sauf pour les classes abstraites évidemment), vous définissez l'implémentation.

extends signifie qu'un comportement est hérité.

Avec les interfaces, il est possible de dire qu'une interface devrait avoir le même comportement qu'une autre, il n'y a même pas d'implémentation réelle. C'est pourquoi il est plus logique d'avoir une interface vers extendsune autre interface au lieu de l'implémenter.

Par ailleurs, rappelez-vous que même si une abstractclasse peut définir des abstractméthodes (comme le fait une interface), elle est toujours une classe et doit toujours être héritée (étendue) et non implémentée.

Conceptuellement, il existe les deux classes et interfaces «domaines». À l'intérieur de ces domaines, vous étendez toujours, seule une classe implémente une interface, qui est en quelque sorte "franchir la frontière". Donc, fondamentalement, "étend" pour les interfaces reflète le comportement des classes. Au moins, je pense que c'est la logique derrière. Il semble que tout le monde n'est pas d'accord avec ce genre de logique (je la trouve moi-même un peu artificielle), et en fait il n'y a aucune raison technique d'avoir deux mots-clés différents.

Cependant, l'interface est une classe 100% abstraite et la classe abstraite peut implémenter l'interface (classe 100% abstraite) sans implémenter ses méthodes. Quel est le problème quand il est défini comme "interface"?

C'est simplement une question de convention. Les auteurs du langage java ont décidé que "extend" est la meilleure façon de décrire cette relation, c'est donc ce que nous utilisons tous.

En général, même si une interface est "une classe 100% abstraite", nous ne les pensons pas de cette façon. Nous considérons généralement les interfaces comme une promesse d'implémenter certaines méthodes clés plutôt qu'une classe à partir de laquelle dériver. Nous avons donc tendance à utiliser un langage différent pour les interfaces que pour les classes.

Comme d'autres le disent, il y a de bonnes raisons de choisir «étend» plutôt que «outils».

J'espère que cela vous aidera un peu ce que j'ai appris en oops (core java) pendant mon collège.

Implements désigne la définition d'une implémentation pour les méthodes d'une interface. Cependant, les interfaces n'ont pas d'implémentation donc ce n'est pas possible. Une interface peut cependant étendre une autre interface, ce qui signifie qu'elle peut ajouter plus de méthodes et hériter de son type.

Voici un exemple ci-dessous, c'est ma compréhension et ce que j'ai appris en oops.

interface ParentInterface{  
        void myMethod();  
}  

interface SubInterface extends ParentInterface{  
        void anotherMethod();  
}  

et gardez une chose à l'esprit, une interface ne peut étendre qu'une autre interface et si vous voulez définir sa fonction sur une classe, seule une interface est implémentée par exemple ci-dessous

public interface Dog
{
    public boolean Barks();

    public boolean isGoldenRetriever();
}

Maintenant, si une classe devait implémenter cette interface, voici à quoi elle ressemblerait:

public class SomeClass implements Dog
{
    public boolean Barks{
    // method definition here

    }

    public boolean isGoldenRetriever{
    // method definition here
    }
}

et si une classe abstraite a une fonction abstraite définie et déclarée et que vous voulez définir ces fonctions ou vous pouvez dire implémenter ces fonctions, vous supposez étendre cette classe car la classe abstraite ne peut être étendue. voici un exemple ci-dessous.

public abstract class MyAbstractClass {

    public abstract void abstractMethod();
}

Voici un exemple de sous-classe de MyAbstractClass:

public class MySubClass extends MyAbstractClass {

    public void abstractMethod() {
        System.out.println("My method implementation");
    }
}

L'interface est comme une abstraction qui ne fournit aucune fonctionnalité. Par conséquent, il n'implémente pas mais étend les autres abstractions ou interfaces.

Interface est la classe qui contient une méthode abstraite qui ne peut créer aucun objet. Comme Interface ne peut pas créer l'objet et ce n'est pas une classe pure, cela ne vaut pas la peine de l'implémenter.