Beziehungen zwischen Klassen - Assoziation, Aggregation und Komposition

Klassen in Beziehung setzen Bindungsstärke

Assoziation
etwas in Verbindung 🔗 bringen

Auto *               1 Fahrer

Ein Auto hat einen (1) Fahrer. Ein Fahrer hat beliebig viele (* oder 0..*) Autos.

Die Klassen Fahrer und Auto stehen in Beziehung zueinander. Die Kardinalitätetn (1, *, ...) beschreiben die Anzahl. Die Klassen existieren unabhängig voneinander.

Aggregation
etwas anhäufen 🎨

Spieler *        1◇ Mannschaft

Ein Spieler ist Teil einer Mann­schaft. Eine Mann­schaft besteht aus beliebig vielen Spielern.

Das Ganze, die Mannschaft, besteht aus Spielern. Man beachte: Die Spieler können aber auch unabhängig von der Mannschaft existieren. Diese Kardinalität wird mit einer leeren Raute ◇ gekennzeichnet.

Komposition
etwas zusammensetzen 🎵

Raum 1..*        1◆ Haus

Ein Raum ist Teil eines Hauses. Ein Haus besteht aus mindestens einem Raum.

Wie bei der Aggregation besteht das Ganze, das Haus, aus mindestens einem Raum. Zusätzlich gilt aber: Ein Raum kann nicht ohne Haus existieren. Diese Kardinalität wird zusätzlich mit einer gefüllten Raute ◆ gekennzeichnet.

Java programmieren Assoziation, Aggregation und Komposition

Die Assoziation

Bei der Assoziation enthält die Fahrerklasse eine Liste mit Autoobjekten.

class Fahrer:
  def __init__(self, name, alter, autoliste=None):
    self.name = name
    self.alter = alter
    self.autoliste = autoliste if autoliste is not None else []

  def __str__(self):
    autoinfos = '\n '.join(str(auto) for auto in self.autoliste) or "Keine Autos"
    return (
      f"{self.__class__.__name__}: {self.name}\n"
      f"Alter: {self.alter}\n"
      f"Besitzt 🚗:\n {autoinfos}"
    )

class Auto:
  def __init__(self, marke="VW", modell="Käfer"):
    self.marke = marke
    self.modell = modell

  def __str__(self):
    return f"{self.marke} {self.modell}"

Wir testen die Assoziation indem wir eine Liste mit Objekten von Autos erzeugen. Ebenso wird ein Objekt der Klasse Fahrer erzeugt und diesem die Liste mit Autoobjekten übergeben.

# Liste von Autos
autoliste = [
  Auto(), 
  Auto("Porsche", "911 Turbo"), 
  Auto("Audi", "Quattro")]

# Fahrer erstellen – jetzt mit Name und Alter
f1 = Fahrer(name="Elias", alter=25, autoliste=autoliste)

# Ausgabe
print(f1)

Die Aggregation

Bei der Aggregation enthält die Mannschaftklasse eine Liste mit Spielerobjekten. Eine Mannschaft besteht aus beliebig vielen Spielern. Bei der Programmierung gibt es keinen Unterschied zur Assoziation.

class Mannschaft:
  def __init__(self, name, trainer, spielerliste):
    self.name = name
    self.trainer = trainer
    self.spielerliste = spielerliste

  def __str__(self):
    spieler_info = "\n  ".join(str(s) for s in self.spielerliste)
    return (f"{self.__class__.__name__}: {self.name}\n"
      f"Trainer: {self.trainer}\n"
      f"Spieler:\n  {spieler_info}")

class Spieler:
  def __init__(self, name, position, alter, marktwert):
    self.name = name
    self.position = position
    self.alter = alter
    self.marktwert = marktwert

  def __str__(self):
    return f"{self.name} ist {self.alter} alt. Marktwert: {self.marktwert} Mio€"

Wir testen die Aggregation mit einer Liste von Spielerobjekten. Ebenso wird ein Objekt der Klasse Mannschaft erzeugt und diesem die Liste mit Spielerobjekten übergeben.

# Bundesliga-Daten definieren
spielerliste = [
  Spieler("Manuel Neuer", "Torwart", 38, 4),
  Spieler("Joshua Kimmich", "Rechter Verteidiger", 29, 50),
  Spieler("Jamal Musiala", "Offensives Mittelfeld", 21, 120),
  Spieler("Mathys Tel", "Linksaußen", 19, 40),
  Spieler("Harry Kane", "Mittelstürmer", 30, 100),
  Spieler("Eric-Maxim Choupo-Moting", "Mittelstürmer", 35, 2.5)
]

m1 = Mannschaft("Bayern", "Jürgen Klopp", spielerliste)
print(m1)

Die Komposition

Bei der Komposition werden die Räume im Konstruktor der Klasse Haus erzeugt. Die Räume existieren also erst mit Erzeugung des Hauses.

class Haus:
  def __init__(self, raumnummern):
    self.raumliste = [Raum(name) for name in raumnummern]

  def __str__(self):
    raeume = '\n  - ' + '\n  - '.join(str(raum) for raum in self.raumliste)
    return f"{self.__class__.__name__} mit Räumen:{raeume}"

class Raum:
  def __init__(self, name):
    self.name = name
    
  def __str__(self):
    return self.__class__.__name__ + f" {self.name}"

Zum Test der Komposition wird ein Array mit Raumnamen angelegt. Es wird ein Objekt der Klasse Haus angelegt und das Array mit den Raumnamen übergeben. Man beachte, dass in der Testklasse keine Räume als Objekte erzeugt werden.

raumnummer=("A0.04", "A0.05", "A0.06")

h1 = Haus(raumnummer)
print(h1)

Aufgabe 3 Komposition programmieren

Die Pizza soll Zutaten bekommen. Eine Pizza besteht aus beliebig vielen Zutaten. Jede Zutat ist Teil einer Pizza. Darüber hinaus kann eine Zutat nicht ohne Pizza existieren.