Einfache & mehrstufige Vererbung

Teil des Abschnitts Objektorientierte Programmierung der Java-Journey von Coddy — Lektion 25 von 87.

Bisher haben wir gesehen, wie Klassen direkt eine Elternklasse erweitern. Aber Vererbung kann verschiedene Strukturen bilden, je nachdem, wie Klassen zueinander in Beziehung stehen. Lassen Sie uns die zwei Hauptmuster untersuchen: Einzelvererbung und mehrstufige Vererbung.

Einfachvererbung ist das, was wir bisher verwendet haben. Eine Klasse erweitert direkt genau eine Elternklasse:

public class Animal { }
public class Dog extends Animal { }
public class Cat extends Animal { }

Hier erben sowohl Dog als auch Cat von Animal, aber sie erben nicht voneinander. Jedes Kindelement hat ein direktes Elternelement.

Mehrstufige Vererbung erzeugt eine Kette, in der eine Klasse eine andere Klasse erweitert, die ihrerseits eine weitere Klasse erweitert:

public class Animal {
    public void eat() {
        System.out.println("Eating");
    }
}

public class Mammal extends Animal {
    public void breathe() {
        System.out.println("Breathing");
    }
}

public class Dog extends Mammal {
    public void bark() {
        System.out.println("Barking");
    }
}

In dieser Kette erbt Dog von Mammal, welches wiederum von Animal erbt. Ein Dog-Objekt hat Zugriff auf alle Methoden der gesamten Kette:

Dog dog = new Dog();
dog.eat();      // Von Animal
dog.breathe();  // Von Mammal
dog.bark();     // Von Dog

Denken Sie daran, dass Object an der Spitze jeder Kette steht. So hat unser Dog tatsächlich vier Ebenen: Object -> Animal -> Mammal -> Dog. Die Konstruktor-Verkettung durchläuft all diese Ebenen, wenn ein neues Objekt erstellt wird.

Aufgabe

Einfach

Lassen Sie uns eine Transporthierarchie aufbauen, die sowohl einfache als auch mehrstufige Vererbungsmuster demonstriert. Sie werden eine Kette von Klassen erstellen, bei der jede Ebene neue Funktionen hinzufügt und zeigt, wie Methoden über mehrere Ebenen hinweg vererbt werden.

Sie werden Ihren Code in vier Dateien organisieren:

Vehicle.java: Erstellen Sie die Basisklasse an der Spitze Ihrer Hierarchie. Jedes Fahrzeug sollte Folgendes haben:
- Ein privates Feld für brand (String)
- Einen Konstruktor, der die Marke (brand) akzeptiert
- Eine Methode getBrand(), die die Marke zurückgibt
- Eine Methode move(), die Folgendes ausgibt: [brand] is moving
LandVehicle.java: Erstellen Sie eine Klasse, die Vehicle erweitert und die mittlere Ebene Ihrer mehrstufigen Kette darstellt. Landfahrzeuge fügen bodenspezifisches Verhalten hinzu:
- Ein privates Feld für wheels (int)
- Einen Konstruktor, der brand und wheels entgegennimmt und super(brand) für den Elternteil verwendet
- Eine Methode getWheels(), die die Anzahl der Räder zurückgibt
- Eine Methode honk(), die Folgendes ausgibt: [brand] honks!
Car.java: Erstellen Sie eine Klasse, die LandVehicle erweitert und damit Ihre dreistufige Vererbungskette vervollständigt. Autos fügen ihre eigenen spezialisierten Merkmale hinzu:
- Ein privates Feld für model (String)
- Einen Konstruktor, der brand, wheels und model entgegennimmt und super(brand, wheels) verwendet
- Eine Methode getModel(), die das Modell zurückgibt
- Eine Methode displayInfo(), die Folgendes ausgibt: [brand] [model] with [wheels] wheels
Main.java: Demonstrieren Sie, wie ein Car-Objekt Zugriff auf Methoden aus allen drei Ebenen der Hierarchie hat. Sie erhalten drei Eingaben: brand (String), wheels (int) und model (String). Erstellen Sie ein Car-Objekt und rufen Sie diese Methoden in der folgenden Reihenfolge auf:
- move() - geerbt von Vehicle (Großelternteil)
- honk() - geerbt von LandVehicle (Elternteil)
- displayInfo() - in Car selbst definiert

Sie erhalten drei Eingaben: den Markennamen (brand), die Anzahl der Räder (wheels) und den Modellnamen (model).

Ihre Ausgabe sollte drei Zeilen zeigen, die demonstrieren, wie das Car-Objekt Methoden von jeder Ebene seiner Vererbungskette nutzen kann - vom übergeordneten Vehicle bis hinunter zu seiner eigenen Klasse!

Spickzettel

Java unterstützt verschiedene Vererbungsstrukturen. Die zwei Hauptmuster sind die Einfachvererbung und die mehrstufige Vererbung.

Einfachvererbung tritt auf, wenn eine Klasse direkt von genau einer Elternklasse erbt:

public class Animal { }
public class Dog extends Animal { }
public class Cat extends Animal { }

Sowohl Dog als auch Cat erben von Animal, aber nicht voneinander.

Mehrstufige Vererbung erzeugt eine Kette, in der eine Klasse eine andere Klasse erweitert, welche wiederum eine andere Klasse erweitert:

public class Animal {
    public void eat() {
        System.out.println("Eating");
    }
}

public class Mammal extends Animal {
    public void breathe() {
        System.out.println("Breathing");
    }
}

public class Dog extends Mammal {
    public void bark() {
        System.out.println("Barking");
    }
}

Bei der mehrstufigen Vererbung hat eine Kindklasse Zugriff auf alle Methoden der gesamten Vererbungskette:

Dog dog = new Dog();
dog.eat();      // From Animal
dog.breathe();  // From Mammal
dog.bark();     // From Dog

Jede Klassenhierarchie hat Object an der Spitze. Die Konstruktorenverkettung durchläuft alle Ebenen, wenn ein neues Objekt erstellt wird.

Probier es selbst

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Eingaben lesen
        String brand = scanner.nextLine();
        int wheels = scanner.nextInt();
        scanner.nextLine(); // Zeilenumbruch konsumieren
        String model = scanner.nextLine();
        
        // TODO: Erstelle ein Car-Objekt mit den Eingabewerten
        
        // TODO: Rufe move() auf - geerbt von Vehicle (Großelternklasse)
        
        // TODO: Rufe honk() auf - geerbt von LandVehicle (Elternklasse)
        
        // TODO: Rufe displayInfo() auf - definiert in Car selbst
    }
}