Einfach- und 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

Erstellen wir eine Transporthierarchie, die sowohl einfache als auch mehrstufige Vererbungsmuster demonstriert. Du erstellst eine Kette von Klassen, wobei jede Ebene neue Fähigkeiten hinzufügt und zeigt, wie Methoden über mehrere Ebenen hinweg geerbt werden.

Du wirst deinen Code auf vier Dateien verteilen:

Vehicle.java: Erstelle die Basisklasse an der Spitze deiner Hierarchie. Jedes Fahrzeug sollte Folgendes haben:
- Ein privates Feld für brand (String)
- Einen Konstruktor, der die Marke entgegennimmt
- Eine Methode getBrand(), die die Marke zurückgibt
- Eine Methode move(), die Folgendes ausgibt: [brand] is moving
LandVehicle.java: Erstelle eine Klasse, die Vehicle erweitert und die mittlere Ebene deiner mehrstufigen Kette darstellt. Landfahrzeuge fügen landespezifisches Verhalten hinzu:
- Ein privates Feld für wheels (int)
- Einen Konstruktor, der Marke und Räder entgegennimmt und super(brand) für den Teil der übergeordneten Klasse verwendet
- Eine Methode getWheels(), die die Anzahl der Räder zurückgibt
- Eine Methode honk(), die Folgendes ausgibt: [brand] honks!
Car.java: Erstelle eine Klasse, die LandVehicle erweitert und damit deine dreistufige Vererbungskette vervollständigt. Autos fügen ihre eigenen spezialisierten Funktionen hinzu:
- Ein privates Feld für model (String)
- Einen Konstruktor, der Marke, Räder und Modell 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: Zeige, wie ein Car-Objekt Zugriff auf Methoden aus allen drei Ebenen der Hierarchie hat. Du erhältst drei Eingaben: Marke (String), Räder (int) und Modell (String). Erstelle ein Car und rufe diese Methoden in der folgenden Reihenfolge auf:
- move() – von Vehicle geerbt (Großelternklasse)
- honk() – von LandVehicle geerbt (Elternklasse)
- displayInfo() – direkt in Car definiert

Du erhältst drei Eingaben: den Markennamen, die Anzahl der Räder und den Modellnamen.

Deine Ausgabe sollte drei Zeilen enthalten, die zeigen, wie das Car-Objekt Methoden aus jeder Ebene seiner Vererbungskette verwenden kann – von der Vehicle-Klasse an der Spitze bis hinunter zu seiner eigenen Klasse!

ERFORDERLICHES AUSGABEFORMAT: [Dein übersetzter Inhalt hier]

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
    }
}