Referenzen im Speicher

Lernziele

Nach diesem Kapitel kannst du:

• die Grundidee der Von-Neumann-Architektur erklären,
• Speicher als Modell aus Adresse und Daten beschreiben,
• Speicherabbilder für Objekte und Referenzen zeichnen und lesen,
• Setter und Getter für Referenz-Attribute implementieren,
• analysieren, ob eine Methode das übergebene Objekt verändert oder nur die lokale Referenz umbiegt,
• begründen, warum getPilot() Zugriff auf das Original-Objekt gibt, nicht auf eine Kopie.

Leitfrage: Wie sieht eine Referenz im Speicher tatsächlich aus — und was passiert, wenn du sie an eine Methode weitergibst?

Voraussetzungen

Phase 1: Einstieg — Was IST eine Referenz im Speicher?

Aufgabe: Vorhersage

Lies den folgenden Code. Was erwartest du — true oder false bei den Vergleichen?

Raumschiff rs1 = new Raumschiff();
Raumschiff rs2 = rs1;
 
System.out.println(rs1 == rs2);
 
rs2 = new Raumschiff();
System.out.println(rs1 == rs2);

Phase 2: Konzeptaufbau — Vom Speicher zur Praxis

2.1 Von-Neumann-Architektur

Die zentrale Idee: Programme und Daten liegen im selben Speicher (RAM). Die CPU holt Befehle und Daten, verarbeitet sie und schreibt Ergebnisse zurück.

2.2 Speicher als Adress-/Daten-Tabelle

Der RAM ist eine große Folge von Speicherzellen. Jede Zelle hat eine Adresse und speichert Bytes:

Reflexionsfrage: Warum speichert Java nicht einfach das ganze Objekt in der Variablen, statt nur eine Adresse?

2.3 Objekte miteinander verbinden — Referenz-Attribute

Bisher hatten wir Referenzen in der Hauptklasse (WeltraumSim → Raumschiff). Aber was, wenn das Raumschiff selbst wissen soll, wer es fliegt?

Dafür bekommt Raumschiff ein Referenz-Attribut:

Mermaid-Diagramm wird geladen…

Implementierung:

public class Raumschiff
{
    private String typ;
    private Pilot pil;       // Referenz-Attribut
 
    public void setPilot(Pilot pp)
    {
        pil = pp;            // Referenz wird gespeichert — nicht das Objekt kopiert!
    }
 
    public Pilot getPilot()
    {
        return pil;          // Gibt die Referenz zurück — Zugriff auf das Original
    }
}

Reflexionsfrage: Warum erzeugt das Raumschiff den Piloten nicht selbst im Konstruktor (z.B. pil = new Pilot();)? Wann wäre das sinnvoll, wann nicht?

Was passiert bei setPilot(p1) im Speicher?

1. p1 enthält die Adresse des Pilot-Objekts (z.B. 0x500).
2. setPilot(p1) übergibt diese Adresse an den Parameter pp.
3. pil = pp kopiert die Adresse nach pil.
4. Ergebnis: p1 (in WeltraumSim) und pil (in Raumschiff) speichern beide 0x500 — dasselbe Objekt.

Mermaid-Diagramm wird geladen…

Probiere es selbst aus:

Sicherheit: null-Check vor dem Zugriff

getPilot() kann null zurückgeben — wenn noch kein Pilot zugewiesen wurde.

Pilot p = rs1.getPilot();
if (p != null)
{
    System.out.println(p.getName());
}

Ruhige Sicherung: Referenz, Adresse, Objekt

Code-Patterns zum Nachschlagen

// Referenz setzen
obj.setRef(anderesObj);
 
// Referenz sicher auslesen
Typ x = obj.getRef();
if (x != null) { x.methode(); }
 
// Optional-Check als boolean-Methode
public boolean hatRef() { return ref != null; }

Fading: Übe schrittweise

Phase 3: Üben — Parameterübergabe und Praxis

3.1 Parameterübergabe: Objekt verändern vs. Referenz umbiegen

Sage für beide Methoden vorher: Ändert sich das Original?

3.2 Abgabe-Aufgaben

Pilot p1 = new Pilot("Kirk");
Raumschiff rs1 = new Raumschiff();
rs1.setPilot(p1);
Pilot p = rs1.getPilot();

void wechslePilot(Raumschiff rs) { rs.setPilot(new Pilot("Neu")); }
void resetSchiff(Raumschiff rs) { rs = new Raumschiff(); }

Phase 4: Transfer und Vernetzung

Transferaufgabe

Projekt: Bank-Software

Mermaid-Diagramm wird geladen…

Vernetzung

Heute gelöst: Der Pfeil aus Kapitel 01 ist jetzt kein bloßes Bild mehr. Du weißt: Eine Referenz ist ein Adresswert. Bei einer Übergabe an eine Methode wird diese Adresse kopiert. Das Originalobjekt kann dadurch verändert werden, aber die ursprüngliche Variable wird nicht einfach umgebogen.

Noch offen: Bisher haben wir einzelne Referenzen betrachtet: ein Raumschiff kennt einen Piloten, ein Kunde kennt ein Lieblingsprodukt. Reale Systeme brauchen aber nicht nur einen Pfeil, sondern viele Pfeile nebeneinander.

Nächster Schritt: Im nächsten Kapitel entstehen Arrays von Referenzen. Die neue Falle: Viele Plätze bedeuten noch nicht viele Objekte.

Reflexion

Selbstdiagnose

• Ich kann erklären, was eine Referenz im Speicher ist (eine Adresse).
• Ich kann ein Speicherabbild zu gegebenem Code zeichnen (Adresse | Daten | Interpretation).
• Ich kann Setter/Getter für Referenz-Attribute schreiben.
• Ich weiß, wann ich einen null-Check brauche.
• Ich kann erklären, ob eine Methode das Original-Objekt verändert oder nicht.