Java Vererbung meistern: Subclassing und Superclass-Prinzipien

• Es wird verwendet, um die Member der Superclass von den Membern der Subclass zu unterscheiden, wenn sie dieselben Namen haben.
• Es wird verwendet, um den Superclass-Konstruktor von der Subclass aufzurufen.

Mitglieder unterscheiden

Wenn eine Klasse die Eigenschaften einer anderen Klasse erbt und die Member der Superclass dieselben Namen haben wie die der Subclass, verwenden wir das super-Schlüsselwort, um diese Variablen zu unterscheiden, wie unten gezeigt:

super.variable
super.method();

Beispielcode

Dieser Abschnitt bietet ein Programm, das die Verwendung des super-Schlüsselworts demonstriert.

Im gegebenen Programm haben Sie zwei Klassen: Sub_class und Super_class. Beide haben eine Methode namens display() mit unterschiedlichen Implementierungen und eine Variable namens num mit unterschiedlichen Werten. Wir rufen die display()-Methode beider Klassen auf und geben den Wert der Variable num beider Klassen aus. Hier können Sie beobachten, dass wir das super-Schlüsselwort verwendet haben, um die Member der Superclass von der Subclass zu unterscheiden.

Beispiel

class Super_class {
    int num = 20;

    // display-Methode der Superclass
    public void display() {
        System.out.println("This is the display method of superclass");
    }
}

public class Sub_class extends Super_class {
    int num = 10;

    // display-Methode der Subclass
    public void display() {
        System.out.println("This is the display method of subclass");
    }

    public void my_method() {
        // Subclass instanziieren
        Sub_class sub = new Sub_class();

        // display()-Methode der Subclass aufrufen
        sub.display();

        // display()-Methode der Superclass aufrufen
        super.display();

        // Wert der Variable num der Subclass ausgeben
        System.out.println("value of the variable named num in sub class: " + sub.num);

        // Wert der Variable num der Superclass ausgeben
        System.out.println("value of the variable named num in super class: " + super.num);
    }

    public static void main(String args[]) {
        Sub_class obj = new Sub_class();
        obj.my_method();
    }
}

Ausgabe:

This is the display method of subclass
This is the display method of superclass
value of the variable named num in sub class: 10
value of the variable named num in super class: 20

Superclass-Konstruktor aufrufen

Wenn eine Klasse die Eigenschaften einer anderen Klasse erbt, erwirbt die Subclass automatisch den Default-Konstruktor der Superclass. Aber wenn Sie einen parametrisierten Konstruktor der Superclass aufrufen möchten, müssen Sie das super-Schlüsselwort wie folgt verwenden:

super(values);

Beispielcode

Das in diesem Abschnitt gegebene Programm demonstriert, wie man das super-Schlüsselwort verwendet, um den parametrisierten Konstruktor der Superclass aufzurufen. Dieses Programm enthält eine Superclass und eine Subclass, wobei die Superclass einen parametrisierten Konstruktor enthält, der einen Integer-Wert akzeptiert, und wir das super-Schlüsselwort verwendet haben, um den parametrisierten Konstruktor der Superclass aufzurufen.

Beispiel

class Superclass {
    int age;

    Superclass(int age) {
        this.age = age;
    }

    public void getAge() {
        System.out.println("The value of the variable named age in super class is: " + age);
    }
}

public class Subclass extends Superclass {
    Subclass(int age) {
        super(age);
    }

    public static void main(String args[]) {
        Subclass s = new Subclass(24);
        s.getAge();
    }
}

Ausgabe:

The value of the variable named age in super class is: 24

IS-A-Beziehung

IS-A ist eine Art zu sagen: Dieses Objekt ist ein Typ von jenem Objekt. Sehen wir uns an, wie das extends-Schlüsselwort verwendet wird, um Vererbung zu erreichen.

public class Animal { }
public class Mammal extends Animal { }
public class Reptile extends Animal { }
public class Dog extends Mammal { }

Basierend auf dem obigen Beispiel sind in objektorientierten Begriffen die folgenden Aussagen wahr:

• Animal ist die Superclass der Mammal-Klasse.
• Animal ist die Superclass der Reptile-Klasse.
• Mammal und Reptile sind Subclasses der Animal-Klasse.
• Dog ist die Subclass sowohl der Mammal- als auch der Animal-Klasse.

Betrachten wir die IS-A-Beziehung, können wir sagen:

• Mammal IS-A Animal
• Reptile IS-A Animal
• Dog IS-A Mammal
• Daher: Dog IS-A Animal ebenfalls

Mit der Verwendung des extends-Schlüsselworts können die Subclasses alle Eigenschaften der Superclass erben, außer den privaten Eigenschaften der Superclass.

Wir können sicherstellen, dass Mammal tatsächlich ein Animal ist, mit dem instanceof-Operator.

Beispiel

class Animal { }
class Mammal extends Animal { }
class Reptile extends Animal { }

public class Dog extends Mammal {
    public static void main(String args[]) {
        Animal a = new Animal();
        Mammal m = new Mammal();
        Dog d = new Dog();
        System.out.println(m instanceof Animal);
        System.out.println(d instanceof Mammal);
        System.out.println(d instanceof Animal);
    }
}

Ausgabe:

true
true
true

Da wir ein gutes Verständnis des extends-Schlüsselworts haben, schauen wir uns an, wie das implements-Schlüsselwort verwendet wird, um die IS-A-Beziehung zu erhalten.

Im Allgemeinen wird das implements-Schlüsselwort mit Klassen verwendet, um die Eigenschaften eines Interfaces zu erben. Interfaces können nie von einer Klasse erweitert (extended) werden.

Beispiel

public interface Animal { }
public class Mammal implements Animal { }
public class Dog extends Mammal { }

Das instanceof-Schlüsselwort

Lassen Sie uns den instanceof-Operator verwenden, um zu prüfen, ob Mammal tatsächlich ein Animal ist und Dog tatsächlich ein Animal ist.

Beispiel

interface Animal { }
class Mammal implements Animal { }

public class Dog extends Mammal {
    public static void main(String args[]) {
        Mammal m = new Mammal();
        Dog d = new Dog();
        System.out.println(m instanceof Animal);
        System.out.println(d instanceof Mammal);
        System.out.println(d instanceof Animal);
    }
}

Ausgabe:

true
true
true

HAS-A-Beziehung

Diese Beziehungen basieren hauptsächlich auf der Verwendung. Sie bestimmen, ob eine bestimmte Klasse HAS-A bestimmtes Ding. Diese Beziehung hilft, Code-Duplikation sowie Bugs zu reduzieren.

Beispiel

public class Vehicle { }
public class Speed { }
public class Van extends Vehicle {
    private Speed sp;
}

Dies zeigt, dass die Klasse Van HAS-A Speed. Durch eine separate Klasse für Speed müssen wir nicht den gesamten Code, der zu Speed gehört, in die Van-Klasse packen, was es ermöglicht, die Speed-Klasse in mehreren Applikationen wiederzuverwenden.

In objektorientierten Features müssen sich die Benutzer nicht darum kümmern, welches Objekt die eigentliche Arbeit tut. Um dies zu erreichen, verbirgt die Van-Klasse die Implementierungsdetails vor den Benutzern der Van-Klasse. Grundlegend passiert Folgendes: Die Benutzer bitten die Van-Klasse, eine bestimmte Aktion auszuführen, und die Van-Klasse führt die Arbeit entweder selbst aus oder bittet eine andere Klasse, die Aktion auszuführen.

Arten der Vererbung

Es gibt verschiedene Arten der Vererbung, wie unten dargestellt.

Wichtige Tatsache: Java unterstützt keine multiple Vererbung. Das bedeutet, eine Klasse kann nicht mehr als eine Klasse erweitern. Daher ist Folgendes illegal:

public class extends Animal, Mammal { }

Eine Klasse kann jedoch ein oder mehrere Interfaces implementieren, was Java geholfen hat, die Unmöglichkeit der multiple Vererbung zu überwinden.