1. Verwenden Sie in der Deklaration der Klasse das Schlüsselwort „extends“, um eine Unterklasse der Klasse zu erstellen. Eine Klasse erklärt über das Schlüsselwort „implementiert“, dass sie eine oder mehrere Schnittstellen verwendet.
Erweitert bedeutet, eine bestimmte Klasse zu erben. Nach der Vererbung können Sie die Methoden der übergeordneten Klasse verwenden oder die Methoden der übergeordneten Klasse überschreiben. Schnittstellenmethoden sind im Allgemeinen leer und müssen neu geschrieben werden gebraucht.
2. Erweitert besteht darin, die übergeordnete Klasse zu erben, solange die Klasse nicht als endgültig deklariert oder als abstrakt definiert ist. JAVA unterstützt keine Mehrfachvererbung, kann jedoch mithilfe von Schnittstellen implementiert werden In diesem Fall müssen Implementierungen nur eine Klasse erben, Implementierungen können jedoch mehrere Schnittstellen implementieren. Trennen Sie diese beispielsweise durch Kommas
Kopieren Sie den Codecode wie folgt:
Klasse A erweitert B implementiert C, D, E
Nach langem Lernen habe ich heute endlich die Umsetzung verstanden. Schauen Sie sich einfach die folgenden Beispiele an
Einige Konzepte von Schnittstellen
<!--[if !supportLineBreakNewLine]-->
Kopieren Sie den Codecode wie folgt:
öffentlicher Innerface Runner
{
int ID = 1;
void run ();
}
Schnittstelle Animal erweitert Runner
{
Leere atmen();
}
Klasse Fish implementiert Animal
{
public void run()
{
System.out.println("Fisch schwimmt");
}
öffentliche Verschnaufpause ()
{
System.out.println("Fisch sprudelt");
}
}
abstraktes LandAnimal implementiert Animal
{
öffentliche Verschnaufpause ()
{
System.out.println("LandAnimal atmet");
}
}
Klasse Student erweitert Person implementiert Runner
{
...
public void run()
{
System.out.println("Der Schüler läuft");
}
...
}
Schnittstellen-Flyer
{
void fly();
}
Klasse Bird implementiert Runner, Flyer
{
public void run()
{
System.out.println("der Vogel rennt");
}
öffentliche Leere fliegen()
{
System.out.println("der Vogel fliegt");
}
}
Klasse TestFish
{
public static void main (String args[])
{
Fisch f = neuer Fisch();
int j = 0;
j = Runner.ID;
j = f.ID;
}
}
Hinweise zur Schnittstellenimplementierung:
a. Um eine Schnittstelle zu implementieren, müssen alle Methoden der Schnittstelle implementiert werden (außer abstrakten Klassen).
b. Die Methoden in der Schnittstelle sind abstrakt.
c. Mehrere nicht verwandte Klassen können dieselbe Schnittstelle implementieren, und eine Klasse kann mehrere nicht verwandte Schnittstellen implementieren.
=============================================== =========
Der Unterschied zwischen Extends und Implements
Die Erweiterung dient dazu, die übergeordnete Klasse zu erben, solange sie nicht als endgültig deklariert oder als abstrakt definiert ist. JAVA unterstützt keine Mehrfachvererbung, kann jedoch über Schnittstellen implementiert werden. Implements müssen nur eine Klasse erben, Implements können jedoch mehrere Schnittstellen implementieren. Trennen Sie diese einfach durch Kommas
Klasse A erweitert B implementiert C, D, E
Eine Klasse erklärt über das Schlüsselwort „implementiert“, dass sie eine oder mehrere Schnittstellen verwendet. Verwenden Sie in der Klassendeklaration das Schlüsselwort „extends“, um eine Unterklasse der Klasse zu erstellen.
Kopieren Sie den Codecode wie folgt:
Der Name der Klassenunterklasse erweitert den Namen der übergeordneten Klasse und implementiert den Schnittstellennamen
{...
}
=============================================== =========
A a = new B(); Folglich ist a eine Instanz der Klasse A und kann nur auf Methoden in A zugreifen. Was ist also der Unterschied zu A a = new A();?
=============================================== ========
Klasse B erweitert A
Nach der Vererbung werden normalerweise einige Mitglieder oder Methoden definiert, die in der übergeordneten Klasse nicht gefunden werden.
A a = neues B();
Das ist in Ordnung, laden Sie es hoch.
a ist eine Instanz eines übergeordneten Klassenobjekts und kann daher nicht auf neue Mitglieder oder Methoden zugreifen, die von der Unterklasse definiert werden.
=============================================== ========
Wenn es wie folgt definiert ist:
Klasse A{
int i;
void f(){}
}
Klasse B erweitert A{
int j;
void f(){}//Umschreiben
void g(){}
}
Dann:
B b = neues B();
b ist eine Instanz eines Unterklassenobjekts. Es kann nicht nur auf seine eigenen Eigenschaften und Methoden zugreifen, sondern auch auf die Eigenschaften und Methoden der übergeordneten Klasse. Dinge wie bi, bj, bf(), bg() sind alle legal. Zu diesem Zeitpunkt wird auf bf() in B zugegriffen
A a = neues B();
Obwohl a den Konstruktor von B verwendet, wird es nach dem Upcast zu einer Instanz des übergeordneten Klassenobjekts und kann nicht auf die Eigenschaften und Methoden der Unterklasse zugreifen. ai,af() sind legal, aber aj,ag() sind illegal. Zu diesem Zeitpunkt ist der Zugriff auf af() ein Zugriff auf f() in B
=============================================== ========
A a = new B(); Diese Anweisung hat tatsächlich drei Prozesse:
(1) A a;
Deklarieren Sie a als übergeordnetes Klassenobjekt, nur als Referenz, ohne zugewiesenen Speicherplatz
(2) B temp = new B();
Eine Instanz eines Klasse-B-Objekts wird über den Konstruktor der Klasse B erstellt, also initialisiert
(3) a = (A)temp;
Konvertieren Sie das Unterklassenobjekt temp in ein nicht übergeordnetes Klassenobjekt und weisen Sie es einem zu. Dies ist ein sicherer Upload (Upcast).
Nach den oben genannten drei Prozessen ist a vollständig zu einer Instanz der Klasse A geworden.
Unterklassen verfügen oft über mehr Eigenschaften und Methoden als übergeordnete Klassen. Beim Hochladen werden sie nur verworfen, was beim Downcasting manchmal der Fall ist, was normalerweise unsicher ist.
=============================================== =========
af() sollte der Methode f() der Klasse B entsprechen
Nach dem Aufruf des Konstruktors zum Erstellen einer Instanz wurde der Eingang zur entsprechenden Methode bestimmt.
Obwohl a als Klasse A hochgeladen wurde, ist die überschriebene Methode f() seitdem immer noch die Methode f() von B. Das heißt, jedes Objekt weiß, welche Methode es aufrufen soll.
A a1 = neues B();
A a2 = neues C();
Obwohl a1 und a2 beide Objekte der Klasse A sind, sind ihre jeweiligen f() unterschiedlich. Dies ist genau die Verkörperung des im ersten Stock erwähnten Polymorphismus.
Solche Probleme werden in „Java Programming Thoughts“ sehr deutlich erklärt.
Implementiert im Allgemeinen die Schnittstelle. „extends“ ist eine geerbte Klasse. Schnittstellen haben im Allgemeinen nur Methodendeklarationen, aber keine Definitionen. Daher ist es für Java sinnvoll, speziell auf die Implementierung von Schnittstellen hinzuweisen, da Vererbung bedeutet, dass die übergeordnete Klasse Methoden implementiert hat, während Schnittstellen keine eigenen Methoden, sondern nur Deklarationen implementieren Ein Methodenheader hat keinen Methodenkörper. Daher können Sie verstehen, dass eine Schnittstelle eine Unterklasse ist, die ihre Methodendeklarationen implementiert, anstatt ihre Methoden zu erben. Allerdings können allgemeine Klassenmethoden Methodenkörper haben, daher ist es sinnvoller, sie als Vererbung zu bezeichnen. Beim Importieren eines Pakets können alle Klassen verwendet werden, die Nicht-Schnittstellen darin implementieren. Dann entscheiden Sie, ob Sie die Schnittstelle implementieren möchten oder nicht. Wenn Sie sie verwenden möchten, können Sie die Schnittstelle nicht aufrufen, ohne sie zu implementieren, da die Schnittstelle eine Spezifikation ist, eine Sammlung von Methodendeklarationen ohne Methodenkörper. Lassen Sie mich ein Beispiel geben: Eine Schnittstelle kann mit einem Protokoll verglichen werden. Wenn ich zum Beispiel sage, dass ein Protokoll „tötet“, dann können Sie eine Machete verwenden, um diese Schnittstelle zu implementieren Natürlich können Sie Grab auch zum Implementieren der Kill-Schnittstelle verwenden, aber Sie können die Kill-Schnittstelle nicht zum Töten von Personen verwenden, da es sich bei der Kill-Schnittstelle nur um eine Funktionsbeschreibung handelt und die Vorgehensweise von der Implementierungsklasse abhängt . Wenn ein Paket also eine Schnittstelle enthält, müssen Sie diese nicht implementieren. Dies hat keinen Einfluss auf Ihre Nutzung anderer Klassen.
implementiert
implementiert ist ein Schlüsselwort, das von einer Klasse zum Implementieren einer Schnittstelle verwendet wird. Es wird verwendet, um die in der Schnittstelle definierten abstrakten Methoden zu implementieren. Zum Beispiel: „people“ ist eine Schnittstelle und verfügt über die Methode „say“. öffentliche Schnittstelle people(){ public say();} Die Schnittstelle hat jedoch keinen Methodenkörper. Der Methodenkörper kann nur über eine bestimmte Klasse implementiert werden. Beispielsweise implementiert die chinesische Klasse die Personenschnittstelle. public class chinese implementiert people{ public say() {System.out.println("Hello!");}}
In Java bedeutet „implementiert“, dass eine Unterklasse eine übergeordnete Klasse erbt. Beispielsweise erbt Klasse A Klasse B und wird als „Klasse A implementiert B“ geschrieben.
Unterschied zu Extends
erweitert, können Sie die übergeordnete Klasse implementieren oder die übergeordnete Klasse aufrufen, um this.parent() zu initialisieren. Und es überschreibt Variablen oder Funktionen, die von der übergeordneten Klasse definiert wurden. Dies hat den Vorteil, dass der Architekt die Schnittstelle definieren und sie vom Ingenieur implementieren lassen kann. Die Entwicklungseffizienz und die Entwicklungskosten des gesamten Projekts werden erheblich reduziert.
implementiert, implementiert die übergeordnete Klasse und Unterklassen können die Methoden oder Variablen der übergeordneten Klasse nicht überschreiben. Selbst wenn die Unterklasse dieselben Variablen oder Funktionen wie die übergeordnete Klasse definiert, werden diese durch die übergeordnete Klasse ersetzt.
Die spezifische Verwendung dieser beiden Implementierungen hängt von der tatsächlichen Situation des Projekts ab und muss nicht implementiert werden. Nur die definierte Schnittstelle muss speziell implementiert werden, oder sie kann für eine gute Skalierbarkeit geändert werden.
<!--[endif]-->