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, unterscheiden sich jedoch in einem entscheidenden Aspekt: Besitz 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. Denke 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 jedoch 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 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

Erstellen wir ein Universitätssystem, das sowohl Aggregation als auch Komposition demonstriert. 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 besitzt 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 sinnvoll ist. Eine Lecture besitzt 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 demonstrierst du beide Beziehungen! Ein Course besitzt 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 innerhalb des Konstruktors 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 einer Dauer von 45 Minuten. Diese interne Erstellung demonstriert 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 das toString() jeder Vorlesung in einer eigenen Zeile steht.
Main.java: Führe alles zusammen! Du erhältst vier Eingaben: den Namen des Professors (String), das Department des Professors (String), den Kurstitel (String) und die Anzahl der Vorlesungen (int).
Erstelle zuerst einen Professor mit dem angegebenen Namen und Department. Dieser Professor existiert unabhängig. Erstelle anschließend einen Course und übergib ihm den Titel, den Professor (Aggregation) und die Anzahl der Vorlesungen (der Kurs wird seine eigenen Vorlesungen intern erstellen – Komposition).

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

Du erhältst vier Eingaben in dieser Reihenfolge: den Namen des Professors, das Department, den Kurstitel und die Anzahl der Vorlesungen.

Beachte 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 Kurs existieren). Die Lectures werden innerhalb des Course-Konstruktors 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 lesen
        String professorName = scanner.nextLine();
        String department = scanner.nextLine();
        String courseTitle = scanner.nextLine();
        int numberOfLectures = scanner.nextInt();
        
        // TODO: Erstelle ein Professor-Objekt (existiert unabhängig - Aggregation)
        
        // TODO: Erstelle ein Course-Objekt und übergebe den Professor (Aggregation)
        // Der Course wird seine eigenen Lectures intern erstellen (Komposition)
        
        // TODO: Gib das Ergebnis von getInfo() aus
        
        // TODO: Gib eine leere Zeile aus
        
        // TODO: Gib das Ergebnis von listLectures() aus
        
    }
}