MINT lernen

Assoziationen zwischen Klassen

Ein kleines Sternchen an einer Linie entscheidet, ob im Quelltext eine einzelne Referenz steht oder eine ganze Liste.

1

Linie, Richtung, Kardinalität

  • Assoziation:Objekte einer Klasse kennen Objekte einer anderen Klasse — „hat“, „kennt“, „betreut“.
  • Beschriftung:an der Linie steht der Rollenname; er wird später der Name des Attributs.
  • Richtung:die offene Pfeilspitze zeigt auf die gekannte Klasse; nur die Klasse am Linienanfang bekommt ein Attribut.
  • Kardinalität:steht am anderen Ende: 1 genau eins · 0..1 höchstens eins · * beliebig viele · 1..* mindestens eins · 0..4 höchstens vier.
  • Lesen:„Ein Kurs kennt * Schüler“ — die Zahl neben Schueler sagt, wie viele Schüler ein Kurs kennt.
Lehrkraft
  • - kuerzel: Zeichenkette
  • + getKuerzel(): Zeichenkette
Kurs
  • - fach: Zeichenkette
  • - leitung: Lehrkraft
  • - teilnehmer: DynArray<Schueler>
  • c Kurs(fach: Zeichenkette, l: Lehrkraft)
  • + aufnehmen(s: Schueler)
  • + getAnzahl(): Ganzzahl
teilnehmer*
Schueler
  • - name: Zeichenkette
  • + getName(): Zeichenkette

Ein Kurs hat genau eine Lehrkraft als Leitung und beliebig viele Teilnehmer; Lehrkraft und Schüler wissen nichts vom Kurs.

Wähle unten eine Kardinalität und stelle mit dem Regler ein, wie viele Schueler-Objekte der Kurs k kennen soll. Beobachte, welches Attribut entsteht — und wann Objekte keinen Platz mehr finden.

Wie viele passen hinein?

Attribut in Java:

Halte fest: Die Kardinalität legt fest, wie viele Referenzen ein Objekt speichern muss — und damit den Datentyp des Attributs: eine Referenz, eine Reihung fester Länge oder eine dynamische Reihung.

2

Umsetzung in Java

  • 1:Referenzattribut, im Konstruktor gesetzt — nie null.
  • 0..1:Referenzattribut, anfangs null; vor jedem Aufruf prüfen.
  • 0..4:Reihung new Schueler[4] — freie Plätze enthalten null.
  • *, 1..*:dynamische Reihung — im Abitur DynArray, in Java ArrayList; im Konstruktor erzeugen.
  • In beide Richtungen:nur wenn beide Seiten navigieren müssen; dann beide Attribute gemeinsam setzen.

Herleitung:

Kurs ——teilnehmer——> * Schueler
| Richtung lesen
Der Pfeil zeigt auf Schueler: Nur Kurs bekommt ein Attribut, es heißt wie die Rolle.
- teilnehmer: viele Schueler
| Kardinalität *
Beliebig viele, Anzahl vorher unbekannt — eine Reihung fester Länge passt nicht.
- teilnehmer: DynArray<Schueler>
| nach Java
DynArray heißt in Java ArrayList; append wird add, getLength wird size.
private ArrayList<Schueler> teilnehmer;
Ergebnis
Im Konstruktor folgt teilnehmer = new ArrayList<Schueler>(); — sonst ist die Liste null.
import java.util.ArrayList;

public class Kurs {
    private String fach;
    private Lehrkraft leitung;                 // 1
    private Schueler sprecher;                 // 0..1, anfangs null
    private ArrayList<Schueler> teilnehmer;    // *

    public Kurs(String fach, Lehrkraft leitung) {
        this.fach = fach;
        this.leitung = leitung;
        teilnehmer = new ArrayList<Schueler>();
    }
    public void aufnehmen(Schueler s) {
        teilnehmer.add(s);
    }
    public void setSprecher(Schueler s) {
        sprecher = s;
    }
    public int getAnzahl() {
        return teilnehmer.size();
    }
    public String getSprecherName() {
        if (sprecher == null) {
            return "noch keiner";
        }
        return sprecher.getName();
    }
}
Kurs k = new Kurs("Informatik", new Lehrkraft("SCH"));
Schueler a = new Schueler("Ada");
k.aufnehmen(a);
k.aufnehmen(new Schueler("Ben"));
System.out.println(k.getAnzahl());        // 2
System.out.println(k.getSprecherName());  // noch keiner
k.setSprecher(a);
System.out.println(k.getSprecherName());  // Ada
Merke

Kardinalität → Attributtyp: 1 / 0..1 → eine Referenz (bei 0..1 mit null-Prüfung) · feste Obergrenze → Reihung · * → dynamische Reihung (ArrayList), im Konstruktor erzeugt.

3

Allgemeine Hinweise

Zahl auf der richtigen Seite

Die Kardinalität steht bei der Klasse, die gezählt wird. Kurs ——— * Schueler heißt: ein Kurs, viele Schüler — nicht umgekehrt.

Liste erzeugen

private ArrayList<Schueler> teilnehmer; legt nur die Referenz an. Fehlt im Konstruktor das new, endet der erste add-Aufruf mit einer NullPointerException.

Richtung sparsam wählen

Eine Beziehung in beide Richtungen muss an zwei Stellen gepflegt werden. Zeichne den Pfeil nur dorthin, wohin das Programm tatsächlich navigiert.

Videos