Array von Referenzen

Lernziele

Nach diesem Kapitel kannst du:

• erklären, warum new Typ[n] keine n Objekte erzeugt, sondern n null-Referenzen,
• eine Initialisierungsschleife schreiben, die alle Elemente mit new erzeugt,
• Array-typische Fehler (NullPointerException, Off-by-One) debuggen,
• das Speicherbild eines Referenz-Arrays zeichnen,
• ein Programm entwerfen, das ein Array von Referenzen nutzt.

Leitfrage: Warum erzeugt new Raumschiff[5] keine fünf Raumschiffe — und wie löst du das Problem sauber?

Voraussetzungen

Phase 1: Einstieg — Die null-Falle

Vorhersage

Lies den Code. Sage vorher: Funktioniert das?

Raumschiff[] flotte = new Raumschiff[3];
flotte[0].setGroesse(100);

Teste es:

Phase 2: Konzeptaufbau — Initialisieren, dann Verarbeiten

2.1 Das Standardmuster

Bei Referenz-Arrays gibt es immer zwei Schritte:

1. Initialisieren: Jedes Element mit new erzeugen
2. Verarbeiten: Methoden an den Objekten aufrufen

// Schritt 1: Array + Objekte erzeugen
Raumschiff[] flotte = new Raumschiff[5];
for (int i = 0; i < flotte.length; i++)
{
    flotte[i] = new Raumschiff();   // Objekt erzeugen und eintragen
}
 
// Schritt 2: Alle Objekte verarbeiten
for (int i = 0; i < flotte.length; i++)
{
    flotte[i].setGroesse(100 + i * 50);   // Jetzt sicher — kein null mehr
    System.out.println("Schiff " + i + ": " + flotte[i].getGroesse());
}

// 1. Array anlegen (nur Plätze, alle null)
Typ[] arr = new Typ[n];
 
// 2. Objekte erzeugen (Init-Schleife)
for (int i = 0; i < arr.length; i++) {
    arr[i] = new Typ();
}
 
// 3. Objekte verarbeiten
for (int i = 0; i < arr.length; i++) {
    arr[i].methode();
}

2.2 Speicherbild

Nach new Raumschiff[3]:

Nach der Initialisierungsschleife:

Mermaid-Diagramm wird geladen…

Reflexionsfrage: Was passiert, wenn du in der Verarbeitungsschleife i <= flotte.length statt i < flotte.length schreibst?

Ruhige Sicherung: Plätze sind noch keine Dinge

Probiere das Standardmuster aus:

Fading: Übe schrittweise

Phase 3: Üben

Abgabe-Aufgaben

Raumschiff[] arr = new Raumschiff[4];
arr[0] = new Raumschiff("A");
arr[2] = new Raumschiff("C");
 
for (int i = 0; i < arr.length; i++)
{
    if (arr[i] != null)
    {
        System.out.println(i + ": " + arr[i].getName());
    }
    else
    {
        System.out.println(i + ": null");
    }
}

Raumschiff[] flotte = new Raumschiff[5];
for (int i = 0; i <= flotte.length; i++)    // Fehler 1
{
    flotte[i] = new Raumschiff("Schiff " + i);
}
 
flotte[3] = null;   // Schiff 3 wurde entfernt
 
for (int i = 0; i < flotte.length; i++)
{
    flotte[i].info();    // Fehler 2
}

Raumschiff[] flotte = new Raumschiff[100];
flotte[0] = new Raumschiff();
flotte[1] = flotte[0];

Phase 4: Transfer und Vernetzung

Transferaufgabe

Vernetzung

Heute gelöst: Du kannst jetzt viele Referenzen gemeinsam verwalten. Du weißt, warum ein Referenzarray anfangs nur null enthält und warum Initialisierungsschleifen notwendig sind.

Noch offen: Der Code wird langsam schwer im Kopf zu halten: Referenzen, Arrays, null, Aliasing, Speicherbilder. Bevor wir neue Datenstrukturen bauen, müssen wir lernen, solche Strukturen sichtbar und planbar zu machen.

Nächster Schritt: Das nächste Kapitel ist bewusst ein Zwischenstopp. Wir schreiben weniger neuen Code und ordnen, was wir bisher gelernt haben: mit Struktogrammen, Objektbildern und Entwurfsdiagrammen.

Reflexion

Selbstdiagnose

• Ich weiß, dass new Typ[n] nur null-Plätze erzeugt.
• Ich kann eine Initialisierungsschleife schreiben.
• Ich kann Off-by-One-Fehler in Array-Schleifen erkennen.
• Ich kann Aliasing in Arrays erklären.