Java-Vererbung

In diesem Tutorial werden wir durch Beispiele lernen, wie man Vererbung in Java anwendet.

Vererbung ist eine wichtige Funktion von OOP (Objektorientierte Programmierung), die es uns ermöglicht, eine neue Klasse aus einer bestehenden Klasse zu definieren. Zum Beispiel,

class Animal
{
　　　　//　eat() Method
　　　　//　sleep() Method
}
class Dog extends Animal
{
　　　　//　bark() Methode
}

In Java verwenden wir den Schlüsselwort "extends", um von einer Klasse zu erben. Hier erben wir die Klasse Dog von der Klasse Animal.

Animal ist die Superklasse (Elterklasse oder Basisklasse), und Dog ist die Unterklasse (Unterklasse oder Ableitungsklasse). Die Unterklasse erbt Felder und Methoden der Superklasse.

ist-a Beziehung

Vererbung istist-aBeziehung, nur wenn zwischen zwei Klassen eine-wenn wir eine Beziehung haben, verwenden wir Vererbung.

Hier sind einige Beispiele:

• Das Auto ist ein Fahrzeug.

• Orange ist ein Obst.

• Der Chirurg ist ein Arzt.

• Der Hund ist ein Tier.

Beispiel1：Java-Vererbung

class Tier {
　　　public void essen() {
　　　　　　System.out.println("Ich kann essen");
　　　}
　　　public void schlafen() {
　　　　　　System.out.println("Ich kann schlafen");
　　　}
}
class Dog extends Tier {
　　　public void bellen() {
　　　　　　System.out.println("Ich kann bellen");
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Dog dog1　= new Hund();
　　　　　　Hund1.essen();
　　　　　　Hund1.schlafen();
　　　　　　Hund1.bellen();
　　　}
}

Ausgaberesultat

Ich kann essen
Ich kann schlafen
I　can　bark

Hier haben wir die Unterklasse Dog von der Superklasse Animal geerbt. Die Klasse Dog hat die Methoden eat() und sleep() von der Klasse Animal geerbt.

Daher können Objekte der Klasse Dog die Mitglieder der Klasse Dog und der Klasse Animal erreichen.

geschützte Schlüsselwörter

Wir haben in den vorherigen Tutorials die privaten und öffentlichen Zugriffsmodifikatoren kennengelernt.

• Private Mitglieder sind nur innerhalb der Klasse zugänglich

• Öffentliche Mitglieder sind von überall zugänglich

Sie können auch Methoden und Felder als geschützt setzen, geschützte Mitglieder sind zugänglich

• Innerhalb der Klasse

• In der Unterklasse

• Innerhalb desselben Pakets

Dies ist eine Zusammenfassung über zugängliche Zugriffsmodifikatoren.

Beispiel2：geschützte Schlüsselwörter

class Tier {
　　　protected String type;
　　　private String color;
　　　public void essen() {
　　　　　　System.out.println("Ich kann essen");
　　　}
　　　public void schlafen() {
　　　　　　System.out.println("Ich kann schlafen");
　　　}
　　　public String getColor(){
　　　　　　return color;
　　　}
　　　public void setColor(String col){
　　　　　　color = col;
　　　}
}
class Dog extends Tier {
　　　public void displayInfo(String c){
　　　　　　System.out.println("Ich bin ein ",　+　type);
　　　　　　System.out.println("Meine Farbe ist ",　+　c);
　　　}
　　　public void bellen() {
　　　　　　System.out.println("Ich kann bellen");
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Dog dog1　= new Hund();
　　　　　　Hund1.essen();
　　　　　　Hund1.schlafen();
　　　　　　Hund1.bellen();
　
　　　　　　Hund1.type = "mammal";
　　　　　　Hund1.setColor("black");
　　　　　　Hund1.displayInfo(dog1.getColor());　
　　　}
}

Ausgaberesultat

Ich kann essen
Ich kann schlafen
I　can　bark
Ich bin ein Säugetier
Meine Farbe ist schwarz

Hund1.type = "mammal";

Dies ist möglich, weil die Klassen Animal und Main im selben Paket ( derselben Datei ) sind.

Java Methodenüberschreibung

Aus dem obigen Beispiel wissen wir, dass das Objekt der Unterklasse auch auf die Methoden der Oberklasse zugreifen kann.

　Was passiert, wenn das gleiche Verfahren sowohl in der Oberklasse als auch in der Unterklasse definiert ist?

Nun, in diesem Fall wird das Verfahren in der Unterklasse das Verfahren in der Oberklasse überschreiben. Zum Beispiel,

Beispiel3：Methodenüberschreibung/Überschreibungsbeispiel

class Tier {
　　　geschütztes String type = "animal";
　　　public void essen() {
　　　　　　System.out.println("Ich kann essen");
　　　}
　　　public void schlafen() {
　　　　　　System.out.println("Ich kann schlafen");
　　　}
}
class Dog extends Tier {
　　
　　　@Override
　　　public void essen() {
　　　　　　System.out.println("Ich esse Hundefutter");
　　　}
　　　public void bellen() {
　　　　　　System.out.println("Ich kann bellen");
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Dog dog1　= new Hund();
　　　　　　Hund1.essen();
　　　　　　Hund1.schlafen();
　　　　　　Hund1.bellen();
　　　}
}

Ausgaberesultat

Ich esse Hundefutter
Ich kann schlafen
I　can　bark

Hier erscheint eat() gleichzeitig in der Oberklasse Tier und der Unterklasse Hund. Wir haben das Objekt der Unterklasse Dog als dog erstellt1Java super-Schlüsselwort

Wenn wir mit dog1Methode wird überschrieben, wenn das Objekt eat() aufruft, wird das interne Verfahren von Dog aufgerufen, ohne dass das gleiche Verfahren der Oberklasse aufgerufen wird. Dies wird als Methodenüberschreibung bezeichnet.

Im obigen Programm haben wir das @Override-Kommentar verwendet, um dem Compiler mitzuteilen, dass wir eine Methode überschreiben. Dies ist jedoch nicht obligatorisch. In dem nächsten Tutorial werden wir diese Thematik im Detail besprechenMethodenüberschreibungJava super-Schlüsselwort

Wenn Sie das eat()-Verfahren von der Unterklasse Animal aufrufen möchten, verwenden Sie das Schlüsselwort super.

Beispiel4：super-Schlüsselwort

class Tier {
　　　public Tier() {
　　　　　System.out.println("Ich bin ein Tier");
　　　}
　　　public void essen() {
　　　　　System.out.println("Ich kann essen");
　　　}
}
class Dog extends Tier {
　　　public Dog(){
　　　　　　super();
　　　　　　System.out.println("Ich bin ein Hund");
　　　}
　　@Override
　　public void essen() {
　　　　　super.essen();
　　　　　System.out.println("Ich esse Hundefutter");
　　}
　　　public void bellen() {
　　　　　　System.out.println("Ich kann bellen");
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Dog dog1　= new Hund();
　　　　　　Hund1.essen();
　　　　　　Hund1.bellen();
　　　}
}

Ausgaberesultat

Ich bin ein Tier
Ich bin ein Hund
Ich kann essen
Ich esse Hundefutter
I　can　bark

I can bark

Hier verwenden wir den Schlüsselwort super durch super() um den Konstruktor aufzurufen. Außerdem rufen wir die Methode eat() der Superklasse Animal mit super.eat() auf.Hinweis: Unterschied zwischen dem Aufruf von Konstruktoren und super-Methode. Für weitere Informationen besuchen SieJava super-Schlüsselwort

.

Vererbungstypen

• Vererbung gibt es fünf Typen. - Einfachvererbung

• Klasse B erbt nur von Klasse A. - Mehrfachstufener Vererbung

• Klasse B erbt von Klasse A und dann Klasse C von Klasse B erbt. - Schichtenvererbung

• Klasse A als Elternklasse für B, C und D. -Mehrfachvererbung

• Klasse C von Schnittstelle A und Erweiterung B erweitert. -MischvererbungZwei oder mehrVererbte

Mischung.

Java unterstützt keine mehrfache Vererbung und gemischte Vererbung durch Klassen. Aber wir können durch Schnittstellen mehrfache Vererbung in Java erreichen. Wir werden in den folgenden Kapiteln die Schnittstellen kennenlernen.

• Warum sollte man Vererbung verwenden?

• Die wichtigste Anwendung ist die Wiederverwendbarkeit des Codes. Code, der in der Superklasse existiert, muss nicht in der Unterklasse erneut geschrieben werden.