Erben Subklassen Interfaces?

Schnelle Frage, ich lerne über Schnittstellen und inheritance.

Dies ist kein tatsächlicher Code, nur ein Beispiel. Sagen wir, ich habe die abstrakte class Animal. Es gibt einige inheritance mit Gruppen wie Pferden und Eckzähnen. Es gibt auch eine Schnittstelle “Haustiere”. Es wird für verschiedene Unterklassen von Animal verwendet. Die Unterklasse des Hundes “Dog” implementiert die Schnittstelle “Haustiere”. Daher implementieren alle Unterklassen von “Dog” auch die Schnittstelle “Pet”, ohne “Pets” für jede Unterklasse von “Dog” einzeln implementieren zu müssen, oder?

Wenn Sie haben:

abstract class StaffMember implements MyInterface 

woher

 interface MyInterface { void myMethod(); } 

dann erben alle classn, die StaffMember erweitern, den Typ MyInterface, und Sie können auf diesen Basistyp in anderen Teilen des Codes verweisen, wo eine MyInterface-Instanz als Operand / Argument erwartet wird, zum Beispiel:

 void otherMethod(MyInterface param) { //... } 

Die eigentliche Implementierung der Schnittstelle MyInterface kann entweder in der abstrakten class oder in einer der classn stattfinden, die die abstrakte class erweitern. Wichtig ist in diesem Fall einfach, dass myMethod () irgendwo in der inheritanceshierarchie angegeben wird, so dass die JVM eine Definition finden kann, die aufgerufen werden soll.

Nein.

Eine Schnittstelle definiert, wie eine class aussehen soll (als absolutes Minimum). Ob Sie dies in einer Basisklasse oder in der niedrigsten Unterklasse implementieren, spielt keine Rolle.

Die Schnittstelle muss vollständig in der Hierarchie der Unterklassen und der Basisklasse implementiert werden und muss auf der Ebene definiert werden, auf der sich die Schnittstellenimplementierungssignatur befindet ( implements Interface ).

Die Unterklassen selbst haben kein Wissen über die Schnittstelle, aber sie haben die implizite Verbindung durch ihre Basisklasse.

Weil ich eine freundliche Person bin:

 public class Test { public static void main(String[] args) { BaseClass obj = new SubClass(); obj.test(); obj.test2(); SomeInterface obj2 = new SubClass(); obj2.test(); obj2.test2(); } } interface SomeInterface { public void test(); public void test2(); } abstract class BaseClass implements SomeInterface { @Override public abstract void test(); @Override public void test2() { try { System.out.println(Arrays.toString(this.getClass().getMethod("test2", null).getDeclaringClass().getInterfaces())); } catch (NoSuchMethodException | SecurityException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } class SubClass extends BaseClass { @Override public void test() { try { System.out.println(Arrays.toString(this.getClass().getMethod("test", null).getDeclaringClass().getInterfaces())); } catch (NoSuchMethodException | SecurityException e) { // TODO Auto-generated catch block e.printStackTrace(); } } 

}

Ausgabe:

 [] [interface SomeInterface] [] [interface SomeInterface] 

Wie Sie sehen, zeigt test() (das in SubClass implementiert SubClass ) keine implementierten Schnittstellen zurück, während test2() (das in BaseClass implementiert BaseClass ) zeigt, dass eine Schnittstelle von dieser class implementiert wird. Abstrakte classn können die Implementierung der Methoden einer implementierten Schnittstelle in Unterklassen ermöglichen, indem sie die Definition als abstract markieren.

Und wie Sie in der Hauptmethode sehen können, funktioniert das Definieren des Objekts als BaseClass oder SomeInterface und macht keinen Unterschied.