Abituraufgaben: Reihungen von Objekten

Es gibt 3 Teilnehmer-Objekte (Mia, Ben, Ayla); new Teilnehmer[5] erzeugt nur die Reihung. gruppe[4] verweist auf dasselbe Objekt wie gruppe[1], daher erhöht gruppe[4].einzahlen(60) Bens Betrag: gruppe[1].getBezahlt() liefert 180.

Summe: Platz 0: 180, Platz 1: 180, Platz 2: null (übersprungen), Platz 3: 180, Platz 4: 180 (erneut Ben). summe = 720. Bens Einzahlung wird doppelt gezählt, weil zwei Plätze auf dasselbe Objekt verweisen – tatsächlich eingezahlt sind nur 540 Euro.

new Teilnehmer[5] erzeugt ein Reihungsobjekt mit fünf Plätzen für Referenzen auf Teilnehmer-Objekte. Alle Plätze sind mit null vorbelegt; es wird kein einziges Teilnehmer-Objekt erzeugt. Jedes Objekt muss einzeln mit einem Konstruktoraufruf wie new Teilnehmer("Mia", 180) erzeugt und einem Platz zugewiesen werden.

Ohne die Abfrage würde bei i = 2 der Aufruf gruppe[2].getBezahlt() ausgeführt. Da gruppe[2] den Wert null hat, gibt es kein Objekt, das die Methode ausführen könnte: Es tritt eine NullPointerException auf, das Programm bricht ab, und die Plätze 3 und 4 werden nicht mehr summiert.

public int getOffen() {
    int offen = 0;
    for (int i = 0; i < teilnehmer.length; i++) {
        if (teilnehmer[i] != null && teilnehmer[i].getBezahlt() < preis) {
            offen = offen + (preis - teilnehmer[i].getBezahlt());
        }
    }
    return offen;
}

public Teilnehmer suchen(String name) {
    for (int i = 0; i < teilnehmer.length; i++) {
        if (teilnehmer[i] != null && teilnehmer[i].getName().equals(name)) {
            return teilnehmer[i];
        }
    }
    return null;
}

Beispiel: Preis 240 Euro, angemeldet Mia (240), Ben (180), Ayla (0): getOffen() liefert 0 + 60 + 240 = 300. Bewertungsrelevant: null-Prüfung vor dem Getter-Aufruf (Kurzschlussauswertung), equals statt ==, return null erst nach der Schleife.

Rückgabewerte: Platz 0 true; Platz 2 Basilikum true; Platz 2 Paprika false (belegt); Platz 5 Gurke true; Platz 6 Minze false (existiert nicht, Plätze 0 bis 5); Platz 3 t true (leer). Danach leert entfernen(0) Platz 0.

Die Namen b und u sind frei gewählt, da diese Objekte keine eigene Variable haben. Paprika und Minze wurden zwar erzeugt, aber nirgends gespeichert; sie sind nicht mehr erreichbar. Die Tomate stand zwischenzeitlich in Platz 0 und Platz 3 (dasselbe Objekt); nach entfernen(0) bleibt nur der Verweis in Platz 3.

public Pflanze trockenste() {
    Pflanze min = null;
    for (int i = 0; i < beete.length; i++) {
        if (beete[i] != null) {
            if (min == null || beete[i].getFeuchte() < min.getFeuchte()) {
                min = beete[i];
            }
        }
    }
    return min;
}

public int bewaessern(int grenze, int menge) {
    int anzahl = 0;
    for (int i = 0; i < beete.length; i++) {
        if (beete[i] != null && beete[i].getFeuchte() < grenze) {
            beete[i].giessen(menge);
            anzahl++;
        }
    }
    return anzahl;
}

Im Zustand aus a) liefert trockenste() die Gurke (25 %). g.bewaessern(40, 20) liefert 2: Tomate 35 → 55, Gurke 25 → 45, Basilikum (55) bleibt unverändert.

Leere Beete: Es fehlt die null-Prüfung. Im Zustand aus a) ist schon beete[0] gleich null; beete[0].getHoehe() löst eine NullPointerException aus. Die Methode funktioniert nur, wenn alle Beete belegt sind.

Leeres Gewächshaus: Selbst mit null-Prüfung würde 0 geliefert. Das ist nicht von „Beet 0 enthält die höchste Pflanze“ zu unterscheiden. Ein ungültiger Index wie −1 macht den Fall erkennbar.

Gleich hohe Pflanzen: Wegen > wird die erste der gleich hohen Pflanzen gefunden; das ist eine zulässige Festlegung. Der Startwert max = 0 ist unkritisch, da Höhen positiv sind, beruht aber auf dieser Annahme.

public int hoechste() {
    int platz = -1;
    for (int i = 0; i < beete.length; i++) {
        if (beete[i] != null) {
            if (platz == -1 || beete[i].getHoehe() > beete[platz].getHoehe()) {
                platz = i;
            }
        }
    }
    return platz;
}

Im Zustand aus a) liefert die verbesserte Fassung 5 (Gurke, 120 cm).

Gemeinsamkeiten: Beide nutzen eine Reihung fester Länge; die Pflanzen-Objekte werden einzeln erzeugt, gespeichert werden Referenzen.

Unterschiede: Mit Lücken entspricht der Index dem realen Beet; ein Sensor an Beet 3 findet seine Pflanze direkt über beete[3]. Entfernen ist einfach (Platz auf null setzen). Dafür muss jeder Durchlauf alle Plätze prüfen und bei jedem Zugriff null abfangen. Lückenlos mit anzahl durchläuft man nur die Plätze 0 bis anzahl - 1 und braucht keine null-Prüfung; beim Entfernen müssen jedoch nachfolgende Einträge verschoben (oder der letzte Eintrag in die Lücke gesetzt) werden, und der Index sagt nichts mehr über das Beet aus – die Beetnummer müsste als zusätzliches Attribut in Pflanze gespeichert und gesucht werden.

Entscheidung: Für das Gewächshaus ist die Variante mit Lücken geeigneter, weil die Beete räumlich fest sind und die Sensoren beetweise arbeiten; die zusätzliche null-Prüfung ist ein geringer Preis. Die lückenlose Variante passt eher zu Sammlungen ohne feste Plätze, z. B. einer Liste von Anmeldungen.