Konstruktorverkettung

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

Konstruktorverkettung ist der Vorgang, einen Konstruktor von einem anderen aus aufzurufen. Diese Technik hilft, Code-Duplikation zu vermeiden, wenn eine Klasse mehrere Konstruktoren hat oder wenn mit Vererbungshierarchien gearbeitet wird.

Innerhalb derselben Klasse können Sie Konstruktoren mit this() verketten. Dies ermöglicht es Ihnen, einen „Haupt“-Konstruktor zu haben, der die gesamte Arbeit erledigt, während andere Konstruktoren einfach an diesen delegieren:

public class Rectangle {
    private int width;
    private int height;
    
    public Rectangle() {
        this(1, 1);  // Ruft den Konstruktor mit zwei Parametern auf
    }
    
    public Rectangle(int size) {
        this(size, size);  // Erzeugt ein Quadrat
    }
    
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
}

Bei der Vererbung erfolgt die Konstruktorverkettung automatisch. Wenn Sie ein Objekt einer Unterklasse erstellen, ruft Java zuerst den Konstruktor der Elternklasse mit super() auf. Wenn Sie super() nicht explizit aufrufen, fügt Java automatisch super() (die argumentlose Version) ein:

public class Animal {
    private String name;
    
    public Animal(String name) {
        this.name = name;
        System.out.println("Animal constructor");
    }
}

public class Dog extends Animal {
    private String breed;
    
    public Dog(String name, String breed) {
        super(name);  // Muss die erste Zeile sein
        this.breed = breed;
        System.out.println("Dog constructor");
    }
}

Beim Erstellen von new Dog("Buddy", "Labrador") wird zuerst "Animal constructor" und anschließend "Dog constructor" ausgegeben. Dadurch wird sichergestellt, dass übergeordnete Klassen immer ordnungsgemäß initialisiert werden, bevor die Unterklasse ihre eigene Einrichtung hinzufügt.

Aufgabe

Einfach

Erstelle ein Bestellsystem für Produkte, das die Konstruktorverkettung sowohl innerhalb einer Klasse als auch über eine Vererbungshierarchie hinweg demonstriert. Du wirst sehen, wie this() Konstruktoren in derselben Klasse verkettet, während super() die Verkettung mit Konstruktoren der übergeordneten Klasse herstellt.

Du erstellst drei Dateien, um deinen Code zu organisieren:

Product.java: Erstelle eine übergeordnete Klasse, die ein beliebiges Produkt in einem Geschäft repräsentiert. Sie sollte Folgendes enthalten:
- Private Felder für name (String) und price (double)
- Einen Hauptkonstruktor, der name und price entgegennimmt, die Felder initialisiert und Folgendes ausgibt: Product constructor: [name]
- Einen zweiten Konstruktor, der nur den Namen entgegennimmt und mit this(name, 0.0) den Hauptkonstruktor aufruft, um einen Standardpreis von 0.0 festzulegen
- Methoden getName() und getPrice(), um auf die Felder zuzugreifen
Electronics.java: Erstelle eine Unterklasse, die Product erweitert und Garantieinformationen hinzufügt:
- Ein privates Feld für warrantyYears (int)
- Einen Hauptkonstruktor, der name, price und warrantyYears entgegennimmt – verwende super(name, price), um die übergeordnete Klasse zu initialisieren, setze anschließend die Garantie und gib Folgendes aus: Electronics constructor: [warrantyYears] year warranty
- Einen zweiten Konstruktor, der nur name und price entgegennimmt und mit this(name, price, 1) den Hauptkonstruktor aufruft, um eine standardmäßige Garantie von 1 Jahr bereitzustellen
- Einen dritten Konstruktor, der nur den Namen entgegennimmt und mit this(name, 0.0) den zweiten Konstruktor aufruft
- Eine Methode getDetails(), die Folgendes zurückgibt: [name] - $[price] ([warrantyYears] year warranty)
Main.java: Zeige die Konstruktorverkettung in Aktion. Du erhältst drei Eingaben: einen Produktnamen (String), einen Preis (double) und die Anzahl der Garantiejahre (int). Erstelle ein Electronics-Objekt mit allen drei Parametern und gib anschließend das Ergebnis von getDetails() aus.

Du erhältst drei Eingaben: den Produktnamen, den Preis und die Anzahl der Garantiejahre.

Formatiere den Preis in getDetails() so, dass er mit String.format("%.2f", price) mit 2 Dezimalstellen angezeigt wird. Beobachte die Ausgabe aufmerksam – du wirst sehen, dass die Konstruktormeldungen in der richtigen Reihenfolge erscheinen und zeigen, wie die Verkettung von der übergeordneten Klasse zur Unterklasse verläuft!

Probier es selbst

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Eingaben lesen
        String name = scanner.nextLine();
        double price = scanner.nextDouble();
        int warrantyYears = scanner.nextInt();
        
        // TODO: Erstelle ein Electronics-Objekt unter Verwendung aller drei Parameter
        
        // TODO: Gib das Ergebnis von getDetails() aus
    }
}