Übungsaufgaben zum Implementieren von Klassen: Konstruktor, Getter, Setter und Objekterzeugung

Kopiere den Text in ein KI-Sprachmodell Deiner Wahl und passe Kompetenzstufe, Anzahl, Bearbeitungszeit und Szenario bei Bedarf an. Wie die Aufgaben aufgebaut sind, beschreibt der Artikel Wie sind die Aufgaben aufgebaut?. Prüfe die Ergebnisse mit dem Lehrartikel: KI-Sprachmodelle machen Fehler.

Erstelle neue Übungsaufgaben zum Thema „Implementieren von Klassen:
Konstruktor, Getter, Setter und Objekterzeugung“.

Bauplan: Halte Dich an Aufbau, Kompetenzstufen, Operatoren,
Anforderungsbereiche, Punkte und Zeitschätzung, die im Artikel
https://oer-informatik.de/aufgaben-aufbau beschrieben sind.

Fachliche Grundlage:
- https://oer-informatik.de/klassen-implementieren
- https://oer-informatik.de/uml-klassendiagramm
- https://oer-informatik.de/pseudocode
- Stilbeispiel: https://oer-informatik.de/klassen-implementieren-uebungsaufgaben

Die Aufgaben sollen Inhalte zu diesen Schlagwörtern abdecken:
- Objektorientierte Programmierung
- Klassen
- Konstruktor
- Getter und Setter
- Kapselung
- Vererbung
- Pseudocode
- Call by Reference

Kompetenzstufe: Profilkompetenz (alternativ: Basiskompetenz, Kernkompetenz, Expertise)
Anzahl: 1 Aufgabe mit Teilaufgaben
Bearbeitungszeit in Minuten ca.: <5 bis 30 min>
Szenario: eines der Szenarien aus dem Bauplan

Vorgehen:
1. Lies zuerst die verlinkten Artikel. Kannst Du keine Webseiten
   abrufen, sag mir das, statt zu raten.
2. Steht bei einer Angabe noch ein Platzhalter in <…>, frag mich
   zuerst danach. Richte Punkte und Zahl der Teilaufgaben nach der
   Bearbeitungszeit (ca. 0,9 min je Punkt).
3. Gib je Aufgabe Titel mit Kompetenzstufe, Ausgangssituation und
   Teilaufgaben mit Operator und Punktzahl aus, dazu die geschätzte
   Bearbeitungszeit.
4. Gib die Beispiellösungen mit Punkteverteilung erst aus, wenn ich
   danach frage.

Abweichungen (je 0,5 Punkte, zusammen 3,5 Punkte):

1. hobby ist öffentlich; „niemand soll direkt an die Daten herankommen“ verlangt - hobby.

2. prioritaet ist als String angelegt; für Zahlenvergleiche (unter null, Begrenzung auf −100 bis 100) braucht es Integer.

3. Dem Konstruktor fehlt der Parameter für die Kategorie, obwohl ein Interesse immer komplett angelegt wird.

4. Der Konstruktor hat mit void einen Rückgabetyp; Konstruktoren haben keinen.

5. getPrioritaet(): Integer fehlt, obwohl andere Klassen alles lesen dürfen.

6. setKategorie widerspricht Yusufs Nachricht, dass die Kategorie feststeht.

7. istAbneigung hat einen Parameter; die Methode soll aber die eigene Priorität des Objekts prüfen und braucht deshalb keinen.

Korrigiertes Klassendiagramm (3,5 Punkte):

Bewertung des Diagramms: drei private Attribute mit Datentyp 1 Punkt; Konstruktor mit drei typisierten Parametern und ohne Rückgabetyp 1 Punkt; drei Getter und nur ein Setter 1 Punkt; istAbneigung(): Boolean ohne Parameter 0,5 Punkte.

Ebenfalls richtig: kategorie als Aufzählung (Kategorie <<enumeration>>), Getter für Wahrheitswerte in der Form isAbneigung().

+ getPrioritaet(): Integer {
    return prioritaet
}

+ setPrioritaet(Integer prioritaet) {
    if (prioritaet > 100) {
        this.prioritaet = 100
    } else if (prioritaet < -100) {
        this.prioritaet = -100
    } else {
        this.prioritaet = prioritaet
    }
}

Bewertung: Getter-Kopf ohne Parameter mit Rückgabetyp 0,5 Punkte, Rückgabe des Attributs 1 Punkt; Setter-Kopf mit typisiertem Parameter und ohne Rückgabetyp 1 Punkt; je Grenze 1 Punkt (2); Zuweisung an das Attribut (mit this, wenn Parameter und Attribut gleich heißen) 0,5 Punkte. Fehlt this bei gleichem Namen, wird das Attribut nie gesetzt: 0,5 Punkte Abzug.

+ Interesse(String hobby, String kategorie, Integer prioritaet) {
    this.hobby = hobby
    this.kategorie = kategorie
    setPrioritaet(prioritaet)
}

Bewertung: Kopf mit Klassennamen, drei typisierten Parametern und ohne Rückgabetyp 1 Punkt; Zuweisung von hobby und kategorie mit this 1 Punkt; Aufruf des Setters statt direkter Zuweisung 1 Punkt. So kann auch ein neu erzeugtes Interesse keine ungültige Priorität bekommen (new Interesse("Klettern", "Sport", 130) speichert 100).

+ istAbneigung(): Boolean {
    return prioritaet < 0
}

Bewertung: Kopf mit Rückgabetyp Boolean 1 Punkt; Rückgabe des Vergleichs 1 Punkt. Eine Lösung mit if (prioritaet < 0) { return true } else { return false } ist ebenso richtig.

Bewertung: je Fehler mit Zeile, Begründung und Korrektur 1 Punkt. Als weiterer Fehler zählt auch der Hinweis, dass setProfilSichtbar beliebige Texte und für Minderjährige die Sichtbarkeit „alle“ zulässt (siehe eb).

+ setProfilSichtbar(String wert): Boolean {
    if (not wert.equals("alle") and not wert.equals("kontakte")) {
        return false
    }
    if (wert.equals("alle") and getAlter() < 18) {
        return false
    }
    profilSichtbar = wert
    return true
}

Bewertung: Kopf mit Parameter und Rückgabetyp Boolean 1 Punkt; Prüfung der zulässigen Werte 1 Punkt; Altersprüfung über getAlter() (nicht über ein eigenes Attribut alter) 1 Punkt; Zuweisung und beide Rückgaben 1 Punkt.

Für Sabine Hoffmann (geboren 14.05.1963) liefert setProfilSichtbar("alle") true, setProfilSichtbar("niemand") dagegen false; die Sichtbarkeit bleibt „alle“.

+ interesseHinzufuegen(String hobby, String kategorie, Integer prioritaet) {
    foreach (Interesse i in interessen) {
        if (i.getHobby().equals(hobby)) {
            i.setPrioritaet(prioritaet)
            return
        }
    }
    Interesse neu = new Interesse(hobby, kategorie, prioritaet)
    interessen.add(neu)
}

Der Ablauf als Aktivitätsdiagramm:

Bewertung: Kopf 1 Punkt; Schleife über die Liste 1 Punkt; Vergleich über den Getter mit equals 1 Punkt; Änderung über setPrioritaet und Beenden der Methode (oder eine Merkvariable gefunden) 1 Punkt; Objekterzeugung mit new und den Parametern in der Reihenfolge des Konstruktors 1 Punkt; Hinzufügen zur Liste 1 Punkt.

Nicht richtig: i.hobby == hobby (privates Attribut einer anderen Klasse und Vergleich der Referenzen statt der Inhalte) und i.prioritaet = prioritaet (umgeht die Begrenzung).

• Kapselung und Gültigkeit: Weil die Attribute privat sind, kann die Priorität nur über den Setter oder den Konstruktor geändert werden. Die Begrenzung auf −100 bis 100 lässt sich deshalb nicht umgehen; ungültige Objekte können nicht entstehen. Außerdem kann die interne Darstellung später geändert werden, ohne dass andere Klassen angepasst werden müssen.

• Unveränderliche Identität: Die Hobbybezeichnung bestimmt, um welches Interesse es sich handelt (interesseHinzufuegen sucht danach). Könnte man sie ändern, würde aus „Wandern 90“ unbemerkt „Klettern 90“, und es könnten zwei Interessen mit derselben Bezeichnung entstehen. Ein neues Hobby wird deshalb als neues Objekt angelegt; die Bezeichnung wird nur im Konstruktor gesetzt und ist danach nur lesbar.

Bewertung: erster Grund 1,5 Punkte, zweiter Grund 1,5 Punkte. Andere schlüssige Gründe (z. B. Bezug zur Datenbank, in der hobby_id Teil des Primärschlüssels ist) sind ebenfalls richtig.

Benutzer noah = new Benutzer(13, "Noah", new Datum(2009, 3, 12))
noah.interesseHinzufuegen("Brettspiele", "Spiele", 85)
noah.interesseHinzufuegen("Programmieren", "Kreativ", 90)

Bewertung: Objekterzeugung mit new, Datum-Objekt und richtiger Reihenfolge der Argumente 1 Punkt; beide Aufrufe 1 Punkt. Wer die Interesse-Objekte selbst erzeugt, braucht dafür eine öffentliche Methode zum Hinzufügen; ein direkter Zugriff auf noah.interessen ist falsch.

• Die Liste enthält weiterhin zwei Objekte: „Brettspiele“ ist schon vorhanden, deshalb wird nur die Priorität geändert. Der Setter begrenzt 120 auf 100; „Programmieren“ bleibt bei 90.

• Noah ist 17 Jahre alt. setProfilSichtbar("alle") lehnt den Wert ab: ok ist false, die Sichtbarkeit bleibt „kontakte“ (Startwert).

Bewertung: Interessen (Anzahl und beide Prioritäten) 1 Punkt; ok und Sichtbarkeit 1 Punkt.

+ Schliessanlage(String code, Integer anzahlSchluessel) {
    this.code = code
    if (anzahlSchluessel < 2) {
        this.anzahlSchluessel = 2
    } else {
        this.anzahlSchluessel = anzahlSchluessel
    }
    schloesser = new List<Schloss>()
}

Bewertung: Kopf ohne Rückgabetyp 1 Punkt; Code und Schlüsselanzahl mit Mindestwert 1 Punkt; leere Liste mit new anlegen 1 Punkt. Ohne eigene Liste würde hinzufuegen später auf null zugreifen.

+ Schloss(Schliessanlage anlage) {
    this.anlage = anlage
    seriennummer = "LS-26-" + Text.fuehrendeNullen(naechsteNummer, 5)
    naechsteNummer = naechsteNummer + 1
    if (anlage != null) {
        anlage.hinzufuegen(this)
    }
}

Bewertung: Kopf 0,5 Punkte; Anlage speichern (mit this) 0,5 Punkte; Seriennummer zusammensetzen 1 Punkt; Klassenattribut erhöhen 1 Punkt; Prüfung auf null 1 Punkt; Anmeldung mit this als Argument 1 Punkt.

Die Anmeldung steht am Ende, damit die Schließanlage ein vollständig initialisiertes Schloss erhält (sonst wäre die Seriennummer bei der Anmeldung noch leer).

+ Buegelschloss(Schliessanlage anlage, Integer buegellaengeMm) {
    super(anlage)
    this.buegellaengeMm = buegellaengeMm
}

Der Ablauf beim Erzeugen eines Bügelschlosses:

Bewertung: Kopf mit beiden Parametern 1 Punkt; Aufruf des Oberklassenkonstruktors mit super(anlage) als erste Anweisung 1,5 Punkte; Bügellänge setzen 0,5 Punkte. Wer Seriennummer und Anmeldung im Konstruktor von Buegelschloss wiederholt, vergibt zwei Nummern oder meldet das Schloss doppelt an.

da)

+ getArt(): String {
    return "Rahmenschloss"
}

Bewertung: Kopf mit Rückgabetyp und Rückgabe der Zeichenkette 1 Punkt.

db)

+ getPreis(): Real {
    if (buegellaengeMm <= 230) {
        return 59.90
    }
    return 69.90
}

Bewertung: Kopf 0,5 Punkte; Bedingung mit richtiger Grenze (einschließlich 230 mm) 1 Punkt; beide Rückgaben 0,5 Punkte.

600. seriennummer ist in Schloss geschützt (#, protected). Geschützte Attribute sind in der eigenen Klasse und in allen Unterklassen sichtbar; Rahmenschloss erbt von Schloss und darf deshalb direkt darauf zugreifen. Schliessanlage ist keine Unterklasse von Schloss; für sie ist das Attribut nicht sichtbar, sie muss den öffentlichen Getter verwenden (Kapselung).

Bewertung: Begriff „geschützt/protected“ mit Sichtbarkeit in Unterklassen 1 Punkt; Begründung für Schliessanlage 1 Punkt. (Hinweis: In Java ist protected zusätzlich im selben Paket sichtbar; das ist hier nicht gefragt.)

Schliessanlage anlage = new Schliessanlage("VS-3T8B6L1", 12)
for (Integer i = 1; i <= 12; i++) {
    new Rahmenschloss(anlage)
}
Schloss s = new Buegelschloss(anlage, 230)

Bewertung: Schließanlage erzeugen 1 Punkt; Schleife über zwölf Durchläufe 1 Punkt; Rahmenschlösser mit der Anlage als Argument 1 Punkt; Bügelschloss mit new in einer Variablen vom Typ der abstrakten Oberklasse 1 Punkt.

Ebenfalls richtig: Rahmenschloss r = new Rahmenschloss(anlage) in der Schleife. Nicht nötig (und falsch): zusätzlich anlage.hinzufuegen(…) aufzurufen. Das erledigt schon der Konstruktor, sonst stünde jedes Schloss doppelt in der Liste. new Schloss(anlage) ist nicht möglich, weil Schloss abstrakt ist.

• anlage.getAnzahlSchloesser() liefert 13 (zwölf Rahmenschlösser und ein Bügelschloss).

• Die Rahmenschlösser erhalten die Nummern 418 bis 429, das Bügelschloss als dreizehntes Schloss die Nummer 430: LS-26-00430.

• Jedes Schloss meldet sich im Konstruktor mit anlage.hinzufuegen(this) an. Die Liste schloesser der Schließanlage speichert damit eine Referenz auf jedes Schloss. Ein Objekt bleibt erhalten, solange noch eine Referenz darauf zeigt; es ist nur nicht über eine eigene Variable, sondern über die Schließanlage erreichbar.

Bewertung: je Spiegelstrich 1 Punkt.

+ seriennummernEintragen(String[] ziel): Integer {
    Integer i = 0
    while (i < ziel.length and i < schloesser.size()) {
        ziel[i] = schloesser.get(i).getSeriennummer()
        i = i + 1
    }
    return i
}

Bewertung: Kopf mit Rückgabetyp Integer 0,5 Punkte; Schleife mit beiden Grenzen (Arraylänge und Listengröße) 1 Punkt; Eintragen über den Getter 1 Punkt; Rückgabe der Anzahl 0,5 Punkte.

• eingetragen ist 3: Das Array hat nur drei Plätze, die Anlage aber 13 Schlösser.

• liste[0] ist „storniert“: Die Methode hat in dasselbe Array geschrieben, das der Aufrufer über liste erreicht, weil beim Aufruf die Referenz auf das Array übergeben wird. Auch kopie = liste kopiert nur die Referenz; die Änderung über kopie ist deshalb über liste sichtbar.

• liste[2] ist „LS-26-00420“: Die ersten drei Schlösser der Anlage haben die Nummern 418, 419 und 420.

• kopie[0] ist null: kopie = new String[2] lässt kopie auf ein neues, leeres Array zeigen; liste und ihr Array bleiben davon unberührt, "Ersatz" landet nur im neuen Array.

• anzahl ist weiterhin 13: Ganze Zahlen werden als Wert übergeben (call by value). erhoehe ändert nur seine lokale Kopie n.

Bewertung: je Wert mit Begründung 1 Punkt.

+ nachbestellen(String art): Schloss {
    if (art.equals("Bügelschloss")) {
        return new Buegelschloss(this, 230)
    }
    if (art.equals("Rahmenschloss")) {
        return new Rahmenschloss(this)
    }
    return null
}

Bewertung: Kopf mit Rückgabetyp Schloss 0,5 Punkte; Unterscheidung der Art mit equals 1 Punkt; Bügelschloss mit this als Schließanlage 1 Punkt; Rahmenschloss mit this 1 Punkt; Rückgabe null 0,5 Punkte.

Weil sich das neue Schloss im Konstruktor selbst anmeldet, ist kein zusätzliches hinzufuegen nötig. Nach den Anweisungen aus e) liefert anlage.nachbestellen("Rahmenschloss") ein Schloss mit der Nummer LS-26-00431, die Anlage hat dann 14 Schlösser; anlage.nachbestellen("Kettenschloss") liefert null.

Bewertung: Generalisierung mit hohlem Dreieck an Schloss 1 Punkt; privates Attribut mit Datentyp und Konstruktor mit beiden Parametern 1 Punkt; Getter, Setter und die beiden geerbten abstrakten Methoden getArt und getPreis (müssen implementiert werden, sonst wäre Kettenschloss ebenfalls abstrakt) 1 Punkt.