Übungsaufgaben zu Entwurfsmustern: Strategie, Zustand, Proxy und Dekorierer

Je Vorteil 2 Punkte (Nennung 1 Punkt, Beschreibung 1 Punkt), z. B.:

• Bewährte Lösungen: Entwurfsmuster sind vielfach erprobte Lösungsschablonen für wiederkehrende Entwurfsprobleme. Man vermeidet typische Fehler und muss keine eigene Lösung erfinden.

• Gemeinsame Fachsprache: Mit dem Namen eines Musters („Rabattregeln als Strategie“) ist für alle im Team klar, wie die Klassen aufgebaut sind und zusammenarbeiten. Das erleichtert Absprachen, Dokumentation und die Einarbeitung neuer Teammitglieder.

• Wartbarkeit und Erweiterbarkeit: Veränderliche Teile (z. B. Rabattregeln) sind in eigene Klassen ausgelagert. Neue Varianten werden als neue Klassen ergänzt, ohne bestehende Klassen zu ändern.

• Lose Kopplung und Testbarkeit: Klassen kennen sich nur über Interfaces. Implementierungen sind austauschbar und lassen sich einzeln testen.

• Wiederverwendbarkeit: Die kleinen, klar abgegrenzten Klassen lassen sich in anderen Programmteilen wiederverwenden.

Je richtiger Zeile 0,5 Punkte:

Bewertung (7 Punkte):

• Aggregation (oder Komposition) zwischen Bestellung und Rabattregel, Raute an Bestellung (1 Punkt)

• je Realisierung von Rabattregel durch eine der vier Klassen (gestrichelte Linie, hohles Dreieck am Interface) 0,5 Punkte (2 Punkte)

• je Klasse die Methode + berechne(b: Bestellung): Real mit vollständiger Signatur (4 × 1 Punkt)

Typische Fehler: Vererbungspfeil (durchgezogen) statt Realisierung; Raute am Interface statt an der Bestellung; die Methode nur im Interface, nicht aber in den realisierenden Klassen eingetragen; Aktionsrabatt vergessen, weil die Klasse schon Einträge hat.

JANA Pseudo-Pascal Pseudo-Pascal (deutsch) Pseudo-Python all none

float berechneRabatt() {
    return rabattregel.berechne(this)
}

FUNCTION berechneRabatt() : real
    RETURN rabattregel.berechne(this)
END berechneRabatt

Funktion berechneRabatt(): double
    Rückgabe rabattregel.berechne(this)
Ende berechneRabatt

def berechneRabatt(self):  # Rückgabe: Gleitkommazahl
    return self.rabattregel.berechne(self)
# Ende berechneRabatt

Bewertung: 1 Punkt Rückgabe, 1 Punkt Methodenaufruf über die Referenz rabattregel, 1 Punkt Übergabe der aktuellen Instanz (this bzw. self). Ohne this kann die Rabattregel weder Warenwert noch Anzahl der Räder abfragen.

JANA Pseudo-Pascal Pseudo-Pascal (deutsch) Pseudo-Python all none

float berechne(Bestellung b) {
    if (b.getAnzahlRaeder() >= 5) {
        return b.getWarenwert() * 0.08
    } else {
        return b.getWarenwert() * 0.04
    }
}

FUNCTION berechne(b: Bestellung) : real
    if (b.getAnzahlRaeder() >= 5) then
        RETURN b.getWarenwert() * 0.08
    else
        RETURN b.getWarenwert() * 0.04
    end if
END berechne

Funktion berechne(b: Bestellung): double
    wenn b.getAnzahlRaeder() >= 5 dann
        Rückgabe b.getWarenwert() * 0.08
    sonst
        Rückgabe b.getWarenwert() * 0.04
    Ende wenn
Ende berechne

def berechne(self, b):  # Rückgabe: Gleitkommazahl
    if b.getAnzahlRaeder() >= 5:
        return b.getWarenwert() * 0.08
    else:
        return b.getWarenwert() * 0.04
    # Ende if
# Ende berechne

Bewertung: 1 Punkt Methodenkopf mit Parameter, 1 Punkt Bedingung über b.getAnzahlRaeder() (Grenze „ab 5“, also >= 5), je 1 Punkt für die beiden Rückgaben mit Aufruf von b.getWarenwert().

Kontrolle mit einem Beispiel: Eine Händlerbestellung über 7 Stadträder „Promenade“ zu je 671,43 € hat einen Warenwert von 4.700,01 €; der Rabatt beträgt 8 % davon, also 376,00 €.

JANA Pseudo-Pascal Pseudo-Pascal (deutsch) Pseudo-Python all none

Bestellung(Kunde kunde) {
    this.kunde = kunde
    positionen = new Liste<Bestellposition>()
    String typ = kunde.getKundentyp()
    if (typ == "haendler") {
        rabattregel = new Haendlerrabatt()
    } else if (typ == "oeffentlich") {
        rabattregel = new Rahmenvertragsrabatt()
    } else {
        rabattregel = new KeinRabatt()
    }
}

CONSTRUCTOR Bestellung(kunde: Kunde)
    this.kunde := kunde
    positionen := new Liste<Bestellposition>()
    typ: String := kunde.getKundentyp()
    if (typ = "haendler") then
        rabattregel := new Haendlerrabatt()
    else if (typ = "oeffentlich") then
        rabattregel := new Rahmenvertragsrabatt()
    else
        rabattregel := new KeinRabatt()
    end if
END Bestellung

Konstruktor Bestellung(kunde: Kunde)
    this.kunde := kunde
    positionen := new Liste<Bestellposition>()
    typ: string := kunde.getKundentyp()
    wenn typ = "haendler" dann
        rabattregel := new Haendlerrabatt()
    sonst wenn typ = "oeffentlich" dann
        rabattregel := new Rahmenvertragsrabatt()
    sonst
        rabattregel := new KeinRabatt()
    Ende wenn
Ende Bestellung

def __init__(self, kunde):  # Konstruktor Bestellung
    self.kunde = kunde
    self.positionen = []  # leere Liste von Bestellpositionen
    typ = kunde.getKundentyp()
    if typ == "haendler":
        self.rabattregel = Haendlerrabatt()
    elif typ == "oeffentlich":
        self.rabattregel = Rahmenvertragsrabatt()
    else:
        self.rabattregel = KeinRabatt()
    # Ende if
# Ende __init__

Bewertung: 1 Punkt Konstruktorkopf, 1 Punkt Zuweisung des Kunden (mit this bzw. self zur Unterscheidung vom Parameter), 1 Punkt leere Liste, 2 Punkte Fallunterscheidung mit Erzeugung der passenden Rabattregel (auch als Mehrfachauswahl oder über setRabattregel(...)).

Hinweis: Die Fallunterscheidung steht hier nur einmal beim Erzeugen. Das ist im Strategiemuster in Ordnung; vermieden werden soll eine Fallunterscheidung bei jeder Berechnung.

JANA Pseudo-Pascal Pseudo-Pascal (deutsch) Pseudo-Python all none

best4711.setRabattregel(new Aktionsrabatt(10.0))

best4711.setRabattregel(new Aktionsrabatt(10.0))

best4711.setRabattregel(new Aktionsrabatt(10.0))

best4711.setRabattregel(Aktionsrabatt(10.0))

Bewertung: 1 Punkt Aufruf von setRabattregel am Objekt best4711, 1 Punkt Erzeugung eines Aktionsrabatt-Objekts mit dem Prozentsatz als Argument.

• Die Zahl der Unterklassen wächst exponentiell: Bei 3 Optionen gibt es 2³ = 8 Kombinationen (inklusive „ohne Option“), mit jeder weiteren Option verdoppelt sich die Zahl („Klassenexplosion“). (1 Punkt)

• Derselbe Code (z. B. der Aufpreis der Gravur) steht in vielen Klassen; eine Preisänderung muss überall nachgezogen werden. (1 Punkt)

• Die Kombination ist zur Übersetzungszeit festgelegt; die Kundschaft stellt ihre Ausstattung aber erst zur Laufzeit im Konfigurator zusammen. Eine Option mehrfach (z. B. zwei Schlösser) ginge gar nicht. (1 Punkt)

Bewertung (7 Punkte):

• Realisierung von Radangebot durch Grundrad und durch Option (je 0,5 Punkte, 1 Punkt)

• Aggregation zwischen Option und Radangebot mit Raute an Option (1,5 Punkte; Komposition ebenfalls richtig)

• Vererbung von Option zu den drei Optionsklassen (durchgezogene Linie, hohles Dreieck an Option) (1,5 Punkte)

• je Optionsklasse + getPreis(): Real und + getBeschreibung(): String (3 × 1 Punkt)

Typische Fehler: Die Optionsklassen realisieren das Interface direkt (dann fehlt die gemeinsame Referenz basis); die Raute sitzt am Interface; Option wird mit Grundrad statt mit Radangebot verbunden – dann könnte eine Option kein bereits dekoriertes Rad umhüllen.

JANA Pseudo-Pascal Pseudo-Pascal (deutsch) Pseudo-Python all none

Option(Radangebot basis) {
    this.basis = basis
}

Lasergravur(Radangebot basis, String text) {
    super(basis)
    this.text = text
}

CONSTRUCTOR Option(basis: Radangebot)
    this.basis := basis
END Option

CONSTRUCTOR Lasergravur(basis: Radangebot, text: String)
    super(basis)
    this.text := text
END Lasergravur

Konstruktor Option(basis: Radangebot)
    this.basis := basis
Ende Option

Konstruktor Lasergravur(basis: Radangebot, text: string)
    super(basis)
    this.text := text
Ende Lasergravur

def __init__(self, basis):  # Konstruktor Option
    self.basis = basis
# Ende __init__

def __init__(self, basis, text):  # Konstruktor Lasergravur
    super().__init__(basis)
    self.text = text
# Ende __init__

Bewertung: je 1 Punkt pro Konstruktorkopf mit Parametern, 1 Punkt Zuweisung in Option, 1 Punkt für super(basis) und Zuweisung von text in Lasergravur (Aufruf des Basisklassenkonstruktors in Worten ist ebenfalls richtig).

JANA Pseudo-Pascal Pseudo-Pascal (deutsch) Pseudo-Python all none

float getPreis() {
    return basis.getPreis() + 39.00
}

String getBeschreibung() {
    return basis.getBeschreibung() + " + Lasergravur '" + text + "'"
}

FUNCTION getPreis() : real
    RETURN basis.getPreis() + 39.00
END getPreis

FUNCTION getBeschreibung() : String
    RETURN basis.getBeschreibung() & " + Lasergravur '" & text & "'"
END getBeschreibung

Funktion getPreis(): double
    Rückgabe basis.getPreis() + 39.00
Ende getPreis

Funktion getBeschreibung(): string
    Rückgabe basis.getBeschreibung() & " + Lasergravur '" & text & "'"
Ende getBeschreibung

def getPreis(self):  # Rückgabe: Gleitkommazahl
    return self.basis.getPreis() + 39.00
# Ende getPreis

def getBeschreibung(self):  # Rückgabe: Zeichenkette
    return self.basis.getBeschreibung() + " + Lasergravur '" + self.text + "'"
# Ende getBeschreibung

Bewertung: je Methode 1 Punkt für den Aufruf beim umhüllten Objekt basis und 1 Punkt für die Ergänzung (Aufpreis bzw. Text) mit Rückgabe.

Typischer Fehler: nur Rückgabe 39.00 – dann ginge der Preis des umhüllten Rades verloren.

JANA Pseudo-Pascal Pseudo-Pascal (deutsch) Pseudo-Python all none

Radangebot rad = new Grundrad("Lastenrad Long John", 3780.67)
rad = new Regenverdeck(rad)
rad = new Lasergravur(rad, "Okafor-Schmidt")
write(rad.getPreis())

rad: Radangebot := new Grundrad("Lastenrad Long John", 3780.67)
rad := new Regenverdeck(rad)
rad := new Lasergravur(rad, "Okafor-Schmidt")
writeln(rad.getPreis())

rad: Radangebot := new Grundrad("Lastenrad Long John", 3780.67)
rad := new Regenverdeck(rad)
rad := new Lasergravur(rad, "Okafor-Schmidt")
Ausgabe rad.getPreis()

rad = Grundrad("Lastenrad Long John", 3780.67)
rad = Regenverdeck(rad)
rad = Lasergravur(rad, "Okafor-Schmidt")
print(rad.getPreis())

oder als Einzeiler: rad : Radangebot := new Lasergravur(new Regenverdeck(new Grundrad("Lastenrad Long John", 3780.67)), "Okafor-Schmidt")

Ausgegeben wird 3.780,67 € + 289,00 € + 39,00 € = 4.108,67 € (netto).

Bewertung: 1 Punkt Grundrad erzeugen, 1 Punkt Umhüllung mit beiden Optionen in einer gültigen Reihenfolge, 1 Punkt Referenz vom Typ Radangebot und Ausgabe über getPreis(), 1 Punkt richtiger Preis.

Die Aussage ist falsch (1 Punkt). Begründung (2 Punkte), z. B.:

• Ein Adapter passt eine unpassende Schnittstelle an eine erwartete an: Er realisiert ein anderes Interface als das Objekt, das er umhüllt.

• Hier realisieren die Optionen dasselbe Interface Radangebot, das sie auch umhüllen, und ergänzen Verhalten (Aufpreis, Beschreibung). Sie lassen sich beliebig verschachteln. Das ist ein Dekorierer. Das alltagssprachliche „anpassen an Kundenwünsche“ hat mit dem Adapter-Muster nichts zu tun.

JANA Pseudo-Pascal Pseudo-Pascal (deutsch) Pseudo-Python all none

Aktivitaet(int min, int max) {
    this.min = min
    this.max = max
    angemeldete = 0
    zustand = Offen.getInstanz()
}

CONSTRUCTOR Aktivitaet(min: integer, max: integer)
    this.min := min
    this.max := max
    angemeldete := 0
    zustand := Offen.getInstanz()
END Aktivitaet

Konstruktor Aktivitaet(min: integer, max: integer)
    this.min := min
    this.max := max
    angemeldete := 0
    zustand := Offen.getInstanz()
Ende Aktivitaet

def __init__(self, min, max):  # Konstruktor Aktivitaet
    self.min = min
    self.max = max
    self.angemeldete = 0
    self.zustand = Offen.getInstanz()
# Ende __init__

Bewertung: 1 Punkt für die Zuweisungen von min, max und angemeldete, 2 Punkte für die Initialisierung von zustand über die statische Methode Offen.getInstanz().

Typischer Fehler: zustand := new Offen() – der Konstruktor von Offen ist privat und kann außerhalb der Klasse nicht aufgerufen werden (höchstens 1 Punkt).

JANA Pseudo-Pascal Pseudo-Pascal (deutsch) Pseudo-Python all none

pruefen(Aktivitaet a) {
    if (a.getAngemeldete() >= a.getMax()) {
        a.setZustand(Ausgebucht.getInstanz())
    } else if (a.getAngemeldete() >= a.getMin()) {
        a.setZustand(Bestaetigt.getInstanz())
    } else if (a.stundenBisBeginn() <= 24) {
        a.setZustand(Abgesagt.getInstanz())
    }
}

PROCEDURE pruefen(a: Aktivitaet)
    if (a.getAngemeldete() >= a.getMax()) then
        a.setZustand(Ausgebucht.getInstanz())
    else if (a.getAngemeldete() >= a.getMin()) then
        a.setZustand(Bestaetigt.getInstanz())
    else if (a.stundenBisBeginn() <= 24) then
        a.setZustand(Abgesagt.getInstanz())
    end if
END pruefen

Prozedur pruefen(a: Aktivitaet)
    wenn a.getAngemeldete() >= a.getMax() dann
        a.setZustand(Ausgebucht.getInstanz())
    sonst wenn a.getAngemeldete() >= a.getMin() dann
        a.setZustand(Bestaetigt.getInstanz())
    sonst wenn a.stundenBisBeginn() <= 24 dann
        a.setZustand(Abgesagt.getInstanz())
    Ende wenn
Ende pruefen

def pruefen(self, a):
    if a.getAngemeldete() >= a.getMax():
        a.setZustand(Ausgebucht.getInstanz())
    elif a.getAngemeldete() >= a.getMin():
        a.setZustand(Bestaetigt.getInstanz())
    elif a.stundenBisBeginn() <= 24:
        a.setZustand(Abgesagt.getInstanz())
    # Ende if
# Ende pruefen

Bewertung (5 Punkte): 1 Punkt verschachtelte bzw. mehrstufige Fallunterscheidung in der richtigen Reihenfolge, je 1 Punkt für die drei Bedingungen mit Gettern des übergebenen Objekts a, 1 Punkt für die Zustandswechsel über a.setZustand(...) mit den Singleton-Objekten. Der Fall „bleibt offen“ braucht keine Anweisung.

Beispiel: Lea Schmitts Brettspielabend hat min = 3 und max = 5. Mit 3 Anmeldungen wechselt er beim nächsten Prüfen nach „bestätigt“, mit 5 direkt nach „ausgebucht“.

• Polymorphie (Vielgestaltigkeit) bedeutet, dass eine Referenz eines allgemeinen Typs auf Objekte verschiedener Unterklassen verweisen kann und ein Methodenaufruf je nach tatsächlichem Objekt unterschiedliches Verhalten auslöst. (1 Punkt)

• Das Attribut zustand hat den Typ der abstrakten Klasse Aktivitaetszustand. Zur Laufzeit verweist es auf ein Objekt von Offen, Bestaetigt, Ausgebucht, Abgesagt oder Stattgefunden. (1 Punkt)

• In Aktivitaet.pruefen() steht nur der eine Aufruf zustand.pruefen(this). Welche der überschriebenen pruefen-Methoden ausgeführt wird, entscheidet sich erst zur Laufzeit anhand des Objekts, auf das zustand gerade verweist (späte bzw. dynamische Bindung). (1 Punkt)

• Dadurch verhält sich dieselbe Aktivität je nach Zustand anders, ohne dass Aktivitaet eine Fallunterscheidung über die Zustände enthält. (1 Punkt)

• Der private Konstruktor verhindert, dass außerhalb der Klasse mit new Objekte erzeugt werden. Die statische Methode getInstanz() erzeugt beim ersten Aufruf das einzige Objekt, speichert es im statischen Attribut instanz und gibt bei jedem weiteren Aufruf dieses Objekt zurück. (1 Punkt)

• Von jeder Zustandsklasse gibt es also genau ein Objekt (Entwurfsmuster Singleton, ein Erzeugungsmuster). (1 Punkt)

• Sinnvoll, weil die Zustandsobjekte keine eigenen Daten speichern – alle Daten stehen in der Aktivitaet. Tausende Aktivitäten können sich dieselben fünf Zustandsobjekte teilen; bei jedem Zustandswechsel muss kein neues Objekt erzeugt werden (Speicher, Laufzeit). (1 Punkt)

Zwei Unterschiede, z. B. (1,5 Punkte je Unterschied):

• Zweck: Eine Strategie kapselt einen austauschbaren Algorithmus für dieselbe Aufgabe; ein Zustand kapselt das gesamte Verhalten eines Objekts in einer bestimmten Situation seines Lebenszyklus.

• Wer wechselt: Die Strategie wird meist von außen gesetzt (Client, Konstruktor, Setter). Beim Zustandsmuster wechseln die Zustandsobjekte selbst den Zustand des Kontexts (a.setZustand(...)), wenn ein Übergang aus dem Zustandsdiagramm eintritt.

• Abhängigkeiten: Konkrete Strategien kennen einander nicht. Konkrete Zustände kennen ihre Folgezustände.

fa) Zwei Aspekte, je 2 Punkte, z. B.:

• Stellvertreter mit gleicher Schnittstelle: Ein Proxy steht als Stellvertreter zwischen Client und echtem Objekt. Weil er dasselbe Interface implementiert, kann der Client ihn nicht vom echten Objekt unterscheiden und muss nicht geändert werden.

• Schutzproxy: Er prüft vor dem Weiterleiten, ob der Aufrufer die Methode nutzen darf, und leitet den Aufruf nur dann an das echte Objekt weiter.

• Virtueller Proxy: Er erzeugt ein aufwendiges Objekt erst, wenn es tatsächlich benötigt wird (verzögerte Erzeugung, lazy initialization).

• Abgrenzung zum Dekorierer: Ein Proxy verwaltet meist selbst den Lebenszyklus des echten Objekts (erzeugt es) und fügt für den Client keine neuen Funktionen hinzu; ein Dekorierer ergänzt Funktionen.

fb) Schutzproxy (protection proxy) und virtueller Proxy (virtual proxy) (je 1 Punkt).

Bewertung (8 Punkte):

• drei private Instanzvariablen in EchtesProfil, hobbys mit Multiplizität [0..*] (je 0,5 Punkte, 1,5 Punkte)

• je Konstruktor mit Parametern und Sichtbarkeit + (2 × 1 Punkt)

• Methoden getAnzeigename() und getSteckbrief() in ProfilProxy (1 Punkt) und in EchtesProfil (1 Punkt)

• Realisierung von Profil durch beide Klassen (1 Punkt)

• Aggregation (oder Komposition) zwischen ProfilProxy und EchtesProfil, Raute am Proxy (1,5 Punkte)

JANA Pseudo-Pascal Pseudo-Pascal (deutsch) Pseudo-Python all none

String getSteckbrief() {
    if (!darfSehen()) {
        return "Dieses Profil ist nur für Kontakte sichtbar."
    }
    if (echtesProfil == null) {
        echtesProfil = new EchtesProfil(benutzerId)
    }
    return echtesProfil.getSteckbrief()
}

FUNCTION getSteckbrief() : String
    if (NOT darfSehen()) then
        RETURN "Dieses Profil ist nur für Kontakte sichtbar."
    end if
    if (echtesProfil = nil) then
        echtesProfil := new EchtesProfil(benutzerId)
    end if
    RETURN echtesProfil.getSteckbrief()
END getSteckbrief

Funktion getSteckbrief(): string
    wenn nicht darfSehen() dann
        Rückgabe "Dieses Profil ist nur für Kontakte sichtbar."
    Ende wenn
    wenn echtesProfil = null dann
        echtesProfil := new EchtesProfil(benutzerId)
    Ende wenn
    Rückgabe echtesProfil.getSteckbrief()
Ende getSteckbrief

def getSteckbrief(self):  # Rückgabe: Zeichenkette
    if not self.darfSehen():
        return "Dieses Profil ist nur für Kontakte sichtbar."
    # Ende if
    if self.echtesProfil is None:
        self.echtesProfil = EchtesProfil(self.benutzerId)
    # Ende if
    return self.echtesProfil.getSteckbrief()
# Ende getSteckbrief

Bewertung (5 Punkte): 1 Punkt Prüfung über darfSehen(), 1 Punkt Ersatztext als Rückgabe, 1 Punkt Prüfung auf null, 1 Punkt Erzeugung von EchtesProfil mit der Benutzer-ID, 1 Punkt Weiterleitung an echtesProfil.getSteckbrief() mit Rückgabe.

Typischer Fehler: Das echte Profil wird vor der Berechtigungsprüfung geladen – dann gehen personenbezogene Daten unnötig über die Leitung (Datenminimierung) und der Vorteil des virtuellen Proxys ist verloren.

SELECT COUNT(*) AS anzahl
FROM freundschaft
WHERE benutzer_id_1 = LEAST(3, 13)
  AND benutzer_id_2 = GREATEST(3, 13);

SELECT COUNT(*) AS anzahl
FROM freundschaft
WHERE benutzer_id_1 = MIN(3, 13)
  AND benutzer_id_2 = MAX(3, 13);

oder ohne LEAST/GREATEST (Standard-SQL, in allen DBMS gleich):

SELECT COUNT(*) AS anzahl
FROM freundschaft
WHERE (benutzer_id_1 = 3 AND benutzer_id_2 = 13)
   OR (benutzer_id_1 = 13 AND benutzer_id_2 = 3);

Ergebnis:

Lea und Noah sind nicht befreundet; Noahs Steckbrief bleibt für Lea verborgen. Zur Kontrolle: Für Lea und Kim Bauer (Benutzer-ID 5) liefert dieselbe Abfrage 1.

Bewertung (4 Punkte): 1 Punkt COUNT(*) mit Alias, 2 Punkte Bedingung, die die Reihenfolge der IDs berücksichtigt (nur benutzer_id_1 = 13 AND benutzer_id_2 = 3 wäre falsch), 1 Punkt richtiges Ergebnis.

JANA Pseudo-Pascal Pseudo-Pascal (deutsch) Pseudo-Python all none

static Profil erzeugeProfil(int benutzerId, int betrachterId) {
    return new ProfilProxy(benutzerId, betrachterId)
}

static FUNCTION erzeugeProfil(benutzerId: integer, betrachterId: integer) : Profil
    RETURN new ProfilProxy(benutzerId, betrachterId)
END erzeugeProfil

statisch Funktion erzeugeProfil(benutzerId: integer, betrachterId: integer): Profil
    Rückgabe new ProfilProxy(benutzerId, betrachterId)
Ende erzeugeProfil

def erzeugeProfil(benutzerId, betrachterId):  # statisch, Rückgabe: Profil
    return ProfilProxy(benutzerId, betrachterId)
# Ende erzeugeProfil

Bewertung: 1 Punkt Eigenschaft static, 0,5 Punkte je Übergabeparameter (1 Punkt), 1 Punkt Rückgabe mit Objekterzeugung.

Erläuterung (1 Punkt): Der Client soll nur das Interface Profil kennen. So kann die Fabrikmethode später auch andere Implementierungen liefern (z. B. für die eigene Person direkt ein EchtesProfil), ohne dass die Profilansicht geändert werden muss (lose Kopplung).

Je Zeile 1 Punkt für das Muster, 1 Punkt für die Begründung:

Andere begründete Lösungen sind möglich (z. B. Strategie für die Gestaltung der Bestätigung, wenn die Begründung passt).

1 Punkt für ein passendes Muster, 2 Punkte für die Beschreibung (Zweck und Aufbau), z. B.:

• Fassade (Strukturmuster): Eine Klasse bietet eine einfache Schnittstelle zu einem komplexen Teilsystem an. Sie nimmt Aufrufe entgegen und verteilt sie an die vielen Klassen des Teilsystems, z. B. eine Klasse AnmeldungFassade mit einer Methode anmelden(benutzer, aktivitaet), die Altersprüfung, Teilnahme, Warteliste und Benachrichtigung koordiniert.

• Kompositum (Strukturmuster): Einzelobjekte und Gruppen von Objekten werden über ein gemeinsames Interface gleich behandelt (Baumstruktur), z. B. Hobbys und Hobbykategorien.

• Abstrakte Fabrik, Erbauer, Befehl, Iterator, Schablonenmethode … mit passender Beschreibung.

Nicht gewertet werden Zustand, Strategie, Dekorierer, Singleton, Proxy, Beobachter, Adapter und Fabrikmethode, da sie in der Aufgabe bereits vorkommen.