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é ce:
implements
indique la définition d'une mise en œuvre pour les méthodes d'une interface. Cependant, les interfaces n'ont pas d'implémentation, ce n'est donc pas possible.
Cependant, interface est une classe abstraite à 100%, et une classe abstraite peut implémenter des interfaces (classe abstraite à 100%) sans implémenter ses méthodes. Quel est le problème quand il définit comme "interface"?
Dans 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
6 réponses
implements
signifie implémentation, quand interface
est destiné à déclarer juste pour fournir interface
pas pour l'implémentation.
Un 100% abstract class
est fonctionnellement équivalent à un interface
mais il peut aussi 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.
Aussi la variable membre dans une classe 100% abstraite peut avoir n'importe quel qualificateur d'accès, où dans une interface ils sont implicitement public static final
.
implements
signifie qu'un comportement sera défini pour les méthodes abstract
(sauf pour les classes abstraites évidemment), vous définissez l'implémentation.
extends
signifie qu'un comportement est héréditaire.
Avec les interfaces, il est possible de dire qu'une interface doit 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 pour une interface de extends
une autre interface au lieu de l'implémenter.
Sur une note de côté, rappelez-vous que même si une classe abstract
peut définir des méthodes abstract
(la manière saine d'une interface), il s'agit toujours d'une classe et doit toujours être héritée (étendue) et non implémentée.
Conceptuellement, il y a les deux classes et interfaces" domaines". À l'intérieur de ces domaines, vous étendez toujours, seule une classe implémente une interface, ce qui est en quelque sorte "franchir la frontière". Donc, fondamentalement "étend" pour les interfaces reflète le comportement pour les 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 le trouve un peu artificiel moi-même), et en fait il n'y a aucune raison technique d'avoir deux mots-clés différents à tout.
Cependant, l'interface est une classe abstraite à 100% et la classe abstraite peut implémente l'interface (classe 100% abstraite) sans implémenter son méthode. Quel est le problème quand il définit comme "interface"?
Il s'agit simplement d'une question de convention. Les auteurs du langage java ont décidé que "extends" est la meilleure façon de décrire cette relation, donc c'est ce que nous utilisons tous.
En général, même si une interface est "une classe 100% abstraite", nous ne pensons pas de cette façon. Nous pensons généralement aux interfaces comme une promesse d'implémenter certaines méthodes clés plutôt qu'une classe à partir de laquelle dériver. Et nous avons 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 "s'étend" sur " implémente."
J'espère que cela vous aidera un peu ce que j'ai appris dans 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, ce n'est donc 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 dans oops.
interface ParentInterface{
void myMethod();
}
interface SubInterface extends ParentInterface{
void anotherMethod();
}
Et garder une chose dans un esprit une interface ne peut qu'étendre une autre interface et si vous voulez définir sa fonction sur une classe alors seulement une interface 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 define et declare 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 proroger. voici l'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");
}
}
Interface est la classe qui contient une méthode abstraite qui ne peut pas créer d'objet.Puisque L'Interface ne peut pas créer l'objet et que ce n'est pas une classe pure, cela ne vaut pas la peine de l'implémenter.