Aggregation vs. Komposition

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

Sowohl Aggregation als auch Komposition sind Formen von „has-a“-Beziehungen, aber sie unterscheiden sich in einem entscheidenden Aspekt: Besitzverhältnis und Lebenszyklusabhängigkeit.

Bei der Komposition kann das enthaltene Objekt nicht unabhängig vom Container existieren. Wenn der Container zerstört wird, werden auch seine Teile zerstört. Denken Sie an ein House und seine Room-Objekte – Räume existieren nicht ohne das Haus:

class House {
    private Room[] rooms;
    
    public House(int numRooms) {
        rooms = new Room[numRooms];
        for (int i = 0; i < numRooms; i++) {
            rooms[i] = new Room();  // Haus erstellt und besitzt Räume
        }
    }
}

Bei der Aggregation kann das enthaltene Objekt unabhängig existieren. Der Container verwendet das Objekt, kontrolliert aber nicht dessen Lebenszyklus. Betrachten Sie ein Team und seine Player-Objekte – Spieler existieren auch ohne ein Team:

class Team {
    private List<Player> players;
    
    public Team() {
        players = new ArrayList<>();
    }
    
    public void addPlayer(Player player) {
        players.add(player);  // Team nutzt vorhandene Spieler
    }
}

Der entscheidende Unterschied: Bei der Komposition erstellt der Container seine Teile intern. Bei der Aggregation werden Objekte von außen übergeben. Wenn ein Team gelöscht wird, existieren die Player-Objekte weiterhin. Wenn ein House gelöscht wird, sind auch seine Room-Objekte verschwunden.

Aufgabe

Einfach

Lassen Sie uns ein Universitätskurssystem aufbauen, das sowohl Aggregation als auch Komposition demonstriert. Sie werden sehen, wie ein Course seine Lecture-Objekte besitzt (Komposition), während er nur auf Professor-Objekte verweist, die unabhängig existieren (Aggregation).

Sie werden Ihren Code über vier Dateien organisieren:

Professor.java: Erstellen Sie eine Klasse, die einen Professor darstellt, der unabhängig von jedem Kurs existieren kann. Ein Professor hat zwei private Felder: name (String) und department (String). Fügen Sie einen Konstruktor zur Initialisierung beider Felder und Getter-Methoden für jedes Feld hinzu. Überschreiben Sie toString(), um Folgendes zurückzugeben: Prof. [name] ([department])
Lecture.java: Erstellen Sie eine Klasse, die eine Vorlesung darstellt, die nur innerhalb eines Kurses Sinn ergibt. Eine Lecture hat zwei private Felder: topic (String) und durationMinutes (int). Fügen Sie einen Konstruktor und Getter hinzu. Überschreiben Sie toString(), um Folgendes zurückzugeben: Lecture: [topic] ([durationMinutes] min)
Course.java: Hier werden Sie beide Beziehungen demonstrieren! Ein Course hat drei private Felder: title (String), professor (Professor - Aggregation) und lectures (ein Array von Lecture-Objekten - Komposition).
Der Konstruktor nimmt den Kurstitel, ein Professor-Objekt (von außen übergeben - Aggregation) und die Anzahl der Vorlesungen entgegen. Erstellen Sie innerhalb des Konstruktors das Lecture-Array und füllen Sie es mit neuen Lecture-Objekten. Erstellen Sie für jede Vorlesung am Index i ein Objekt mit dem Thema "Topic " + (i + 1) und einer Dauer von 45 Minuten. Diese interne Erstellung demonstriert Komposition.

Fügen Sie eine getInfo()-Methode hinzu, die einen mehrzeiligen String zurückgibt:
```
Course: [title]
Instructor: [professor.toString()]
Lectures: [number of lectures]
```
Fügen Sie außerdem eine listLectures()-Methode hinzu, die einen String zurückgibt, in dem das toString() jeder Vorlesung in einer eigenen Zeile steht.
Main.java: Bringen Sie alles zusammen! Sie erhalten vier Eingaben: Professorname (String), Fachbereich des Professors (String), Kurstitel (String) und Anzahl der Vorlesungen (int).
Erstellen Sie zuerst einen Professor mit dem angegebenen Namen und Fachbereich – dieser Professor existiert unabhängig. Erstellen Sie dann einen Course und übergeben Sie den Titel, den Professor (Aggregation) und die Anzahl der Vorlesungen (der Kurs erstellt seine eigenen Vorlesungen intern - Komposition).

Geben Sie das Ergebnis von getInfo() aus, geben Sie dann eine Leerzeile aus und geben Sie schließlich das Ergebnis von listLectures() aus.

Sie erhalten vier Eingaben in der folgenden Reihenfolge: Professorname, Fachbereich, Kurstitel und Anzahl der Vorlesungen.

Beachten Sie den entscheidenden Unterschied: Der Professor wird außerhalb erstellt und an den Course übergeben (Aggregation – der Professor könnte andere Kurse unterrichten oder ohne diesen existieren). Die Lectures werden innerhalb des Course-Konstruktors erstellt (Komposition – sie gehören exklusiv zu diesem Kurs und würden ohne ihn nicht existieren).

Spickzettel

Sowohl Aggregation als auch Komposition sind „hat-ein“-Beziehungen, die sich in Bezug auf Besitz und Lebenszyklusabhängigkeit unterscheiden.

Komposition: Das enthaltene Objekt kann nicht unabhängig vom Container existieren. Wenn der Container zerstört wird, werden auch seine Teile zerstört. Der Container erstellt seine Teile intern.

class House {
    private Room[] rooms;
    
    public House(int numRooms) {
        rooms = new Room[numRooms];
        for (int i = 0; i < numRooms; i++) {
            rooms[i] = new Room();  // House creates and owns rooms
        }
    }
}

Aggregation: Das enthaltene Objekt kann unabhängig existieren. Der Container verwendet das Objekt, kontrolliert aber nicht dessen Lebenszyklus. Objekte werden von außen übergeben.

class Team {
    private List<Player> players;
    
    public Team() {
        players = new ArrayList<>();
    }
    
    public void addPlayer(Player player) {
        players.add(player);  // Team uses existing players
    }
}

Wesentlicher Unterschied: Wenn ein Container gelöscht wird, existieren aggregierte Objekte weiterhin, während komponierte Objekte zerstört werden.

Probier es selbst

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Eingaben lesen
        String professorName = scanner.nextLine();
        String department = scanner.nextLine();
        String courseTitle = scanner.nextLine();
        int numberOfLectures = scanner.nextInt();
        
        // TODO: Ein Professor-Objekt erstellen (existiert unabhängig - Aggregation)
        
        // TODO: Ein Course-Objekt erstellen und den Professor übergeben (Aggregation)
        // Der Kurs wird seine eigenen Vorlesungen intern erstellen (Komposition)
        
        // TODO: Ergebnis von getInfo() ausgeben
        
        // TODO: Eine Leerzeile ausgeben
        
        // TODO: Ergebnis von listLectures() ausgeben
        
    }
}