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 „Hat-ein“-Beziehungen, unterscheiden sich jedoch in einem entscheidenden Aspekt: Besitz und Abhängigkeit vom Lebenszyklus.

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. Denk 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();  // House erstellt und besitzt rooms
        }
    }
}

Bei der Aggregation kann das enthaltene Objekt unabhängig existieren. Der Container verwendet das Objekt, kontrolliert aber nicht dessen Lebenszyklus. Betrachte 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 verwendet bereits 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

Lass uns ein Universität-Kurssystem erstellen, das sowohl Aggregation als auch Komposition veranschaulicht. Du wirst sehen, wie ein Course seine Lecture-Objekte besitzt (Komposition), während er nur auf Professor-Objekte verweist, die unabhängig existieren (Aggregation).

Du wirst deinen Code auf vier Dateien verteilen:

Professor.java: Erstelle 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üge einen Konstruktor hinzu, der beide Felder initialisiert, sowie Getter-Methoden für jedes Feld. Überschreibe toString(), sodass Folgendes zurückgegeben wird: Prof. [name] ([department])
Lecture.java: Erstelle eine Klasse, die eine Vorlesung darstellt, die nur innerhalb eines Kurses Sinn ergibt. Eine Vorlesung hat zwei private Felder: topic (String) und durationMinutes (int). Füge einen Konstruktor und Getter hinzu. Überschreibe toString(), sodass Folgendes zurückgegeben wird: Lecture: [topic] ([durationMinutes] min)
Course.java: Hier veranschaulichst du beide Beziehungen! Ein Kurs hat drei private Felder: title (String), professor (Professor – Aggregation) und lectures (ein Array von Lecture-Objekten – Komposition).
Der Konstruktor erhält den Kurstitel, ein Professor-Objekt (von außen übergeben – Aggregation) und die Anzahl der Vorlesungen. Erstelle im Konstruktor das Lecture-Array und fülle es mit neuen Lecture-Objekten. Erstelle für jede Vorlesung am Index i ein Objekt mit dem Thema "Topic " + (i + 1) und der Dauer 45 Minuten. Diese interne Erstellung veranschaulicht die Komposition.

Füge eine getInfo()-Methode hinzu, die einen mehrzeiligen String zurückgibt:
```
Course: [title]
Instructor: [professor.toString()]
Lectures: [number of lectures]
```
Füge außerdem eine listLectures()-Methode hinzu, die einen String zurückgibt, in dem jede Vorlesung mit ihrem toString() in einer eigenen Zeile steht.
Main.java: Füge alles zusammen! Du erhältst vier Eingaben: den Namen des Professors (String), die Abteilung des Professors (String), den Kurstitel (String) und die Anzahl der Vorlesungen (int).
Erstelle zuerst einen Professor mit dem angegebenen Namen und der Abteilung. Dieser Professor existiert unabhängig. Erstelle dann einen Kurs und übergib ihm den Titel, den Professor (Aggregation) und die Anzahl der Vorlesungen (der Kurs erstellt seine Vorlesungen intern selbst – Komposition).

Gib das Ergebnis von getInfo() aus, gib dann eine leere Zeile aus und anschließend das Ergebnis von listLectures().

Du erhältst vier Eingaben in dieser Reihenfolge: Name des Professors, Abteilung, Kurstitel und Anzahl der Vorlesungen.

Beachte den entscheidenden Unterschied: Der Professor wird außerhalb erstellt und an den Kurs übergeben (Aggregation: Der Professor könnte andere Kurse unterrichten oder auch ohne diesen Kurs existieren). Die Vorlesungen werden innerhalb des Kurskonstruktors erstellt (Komposition). Sie gehören ausschließlich zu diesem Kurs und würden ohne ihn nicht existieren.

Probier es selbst

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Eingaben einlesen
        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 erstellt seine eigenen Vorlesungen intern (Komposition)
        
        // TODO: Ergebnis von getInfo() ausgeben
        
        // TODO: Eine Leerzeile ausgeben
        
        // TODO: Ergebnis von listLectures() ausgeben
        
    }
}