Entwurfsmuster

Kurz gesagt: Ein Entwurfsmuster ist eine bewährte Lösung für ein Problem, das in vielen Programmen wiederkehrt, zum Beispiel Strategy, Observer, Factory Method, Singleton und Adapter.

Problem

Die Methode, die mit jeder Aktion wächst

Der Preis im Shop hängt von der Aktion ab:

static double finalPrice(double price, String promo) {
    if (promo.equals("student")) {
        return price * 0.9;
    } else if (promo.equals("black friday")) {
        return Math.max(price - 20, 0);
    } else if (promo.equals("stammkunde")) {
        return price * 0.95;
    }
    return price;
}

System.out.printf("%.2f €%n", finalPrice(120, "student"));
System.out.printf("%.2f €%n", finalPrice(120, "black friday"));
System.out.printf("%.2f €%n", finalPrice(120, "keine"));

Ausgabe

108.00 €
100.00 €
120.00 €

Es funktioniert. Aber das Marketing denkt sich jeden Monat eine neue Aktion aus. Jede bedeutet ein neues else if in dieser Methode, und oft in zwei weiteren: in der für die Rechnung und in der für die Bestätigungs-E-Mail. Die Methode kennt alle Aktionen auf einmal, und jede Änderung fasst sie an. Dieses Problem ist so häufig, dass seine Lösung einen Namen hat.

Die Idee

Entwurfsmuster

Ein Entwurfsmuster (englisch design pattern) ist eine bewährte Lösung für ein Problem, das in vielen Programmen wiederkehrt. Es ist keine Bibliothek und kein Code zum Kopieren. Es ist eine Art, die Klassen und Interfaces anzuordnen, die schon durch Tausende Projekte gegangen ist.

Die Muster teilen sich in drei Gruppen:

• Erzeugungsmuster: wie Objekte entstehen. Zum Beispiel Singleton (nur ein Objekt der Klasse) und Factory Method (welche Klasse erzeugt wird, entscheidet jemand anderes).
• Strukturmuster: wie Klassen und Objekte zu größeren zusammengesetzt werden. Zum Beispiel Adapter (verbindet unverträgliche Interfaces) und Composite (ein Baum aus Teilen, mit dem man wie mit einem Ganzen arbeitet).
• Verhaltensmuster: wie Objekte die Arbeit aufteilen und miteinander reden. Zum Beispiel Strategy (eine austauschbare Regel) und Observer (Abonnenten für ein Ereignis).

Warum es sich lohnt, sie zu kennen:

• du erfindest keine Lösung neu, die andere schon erprobt haben;
• der Code ändert sich mit weniger Risiko, weil der Teil, der sich ändert, abgetrennt ist;
• die Namen sind eine gemeinsame Sprache. „Setz hier einen Adapter ein“ sagt einer Kollegin eine ganze Struktur in einem Wort.

Genauer, für Neugierige

Der klassische Katalog ist das Buch „Design Patterns“ von 1994, geschrieben von vier Autoren, die man die „Viererbande“ nennt (Gang of Four, GoF). Es enthält 23 Muster. Hier sind die fünf, denen du in Java-Code am häufigsten begegnest. Ein Muster ist kein Ziel: Wenn ein einziges if die Arbeit erledigt, brauchst du kein Muster.

Sieh es dir an

Strategy: eine austauschbare Regel

Der Rabatt wird ein Interface. Die Kasse weiß nicht, welche Aktion es ist, sie ruft nur apply auf:

interface DiscountStrategy {
    double apply(double price);
}

class Checkout {
    private DiscountStrategy discount;

    public Checkout(DiscountStrategy discount) {
        this.discount = discount;
    }

    public void setDiscount(DiscountStrategy discount) {
        this.discount = discount;
    }

    public double total(double price) {
        return Math.max(discount.apply(price), 0);
    }
}

Das Interface ist funktional, darum ist jeder Rabatt ein Lambda:

Checkout checkout = new Checkout(price -> price);
System.out.printf("Ohne Rabatt: %.2f €%n", checkout.total(120));

checkout.setDiscount(price -> price * 0.9);
System.out.printf("Student: %.2f €%n", checkout.total(120));

checkout.setDiscount(price -> price - 20);
System.out.printf("Black Friday: %.2f €%n", checkout.total(120));

Ausgabe

Ohne Rabatt: 120.00 €
Student: 108.00 €
Black Friday: 100.00 €

Eine neue Aktion ist ein neues Lambda. Checkout ändert sich nicht. Die Regel lässt sich auch wechseln, während das Programm läuft, mit setDiscount.Das ist Strategy: eine Familie von Regeln, jede hinter demselben Interface, sodass sie austauschbar sind. Der Comparator, den du an sort übergibst, ist auch eine Strategie: sort weiß, wie man sortiert, und du sagst, wonach.

Genauer, für Neugierige

Vor den Lambdas war jede Strategie eine eigene Klasse, und die Klasse, die sie benutzt, heißt in den Büchern „Kontext“ (hier Checkout):

class StudentDiscount implements DiscountStrategy {
    @Override
    public double apply(double price) {
        return price * 0.9;
    }
}

Checkout checkout = new Checkout(new StudentDiscount());
System.out.printf("Student: %.2f €%n", checkout.total(120));

Ausgabe

Student: 108.00 €

Eine Klasse ist die bessere Wahl, wenn die Strategie eigene Felder hat oder lang ist. Ein Lambda, wenn sie eine Zeile ist.

Sieh es dir an

Observer: Abonnenten für ein Ereignis

Wenn sich der Bestand eines Produkts ändert, muss die Website die neue Anzahl zeigen, und das Lager muss nachbestellen, wenn nur noch wenige Stück da sind. Morgen kommt vielleicht noch eine E-Mail an die Kunden dazu. Das Produkt soll von keinem von ihnen wissen.

interface StockListener {
    void stockChanged(String product, int quantity);
}

class Product {
    private String name;
    private int quantity;
    private List<StockListener> listeners = new ArrayList<>();

    public Product(String name, int quantity) {
        this.name = name;
        this.quantity = quantity;
    }

    public void subscribe(StockListener listener) {
        listeners.add(listener);
    }

    public void setQuantity(int quantity) {
        if (quantity == this.quantity) {
            return;
        }
        this.quantity = quantity;
        for (StockListener listener : listeners) {
            listener.stockChanged(name, quantity);
        }
    }
}

Product phone = new Product("Telefon", 0);
phone.subscribe((name, qty) -> System.out.println("Website: " + name + ", Bestand " + qty + " Stk."));
phone.subscribe((name, qty) -> {
    if (qty < 3) {
        System.out.println("Lager: Nachbestellung " + name);
    }
});

phone.setQuantity(10);
phone.setQuantity(2);

Ausgabe

Website: Telefon, Bestand 10 Stk.
Website: Telefon, Bestand 2 Stk.
Lager: Nachbestellung Telefon

• Wer Bescheid wissen will, abonniert mit subscribe.
• Bei einer Änderung geht das Produkt die Liste durch und benachrichtigt jeden Abonnenten. Wer sie sind und was sie tun, geht es nichts an.
• Hat sich die Anzahl nicht geändert, wird niemand gestört.

Product phone = new Product("Telefon", 0);
phone.subscribe((name, qty) -> System.out.println("Website: " + name + ", Bestand " + qty + " Stk."));
phone.subscribe((name, qty) -> {
    if (qty < 3) {
        System.out.println("Lager: Nachbestellung " + name);
    }
});

phone.setQuantity(10);
phone.setQuantity(2);

Schritt für Schritt, in Worten

1. Telefon mit Bestand 0 und einer leeren Liste listeners.
2. Die Website abonniert: das Lambda kommt in die Liste.
3. Das Lager auch. Das Produkt weiß nicht, wer sie sind, nur dass sie stockChanged hören können.
4. Der Bestand ändert sich auf 10. Das Produkt geht die Liste durch und ruft jeden Abonnenten in der Reihenfolge des Abonnierens auf. Die Website zeigt die neue Anzahl.
5. Das Lager prüft 10 < 3: nein, also tut es nichts.
6. Der Bestand ändert sich auf 2. Das Produkt geht die Liste durch und ruft jeden Abonnenten in der Reihenfolge des Abonnierens auf. Die Website zeigt die neue Anzahl.
7. Das Lager prüft 2 < 3: ja, also bestellt es nach.

Das ist Observer (Beobachter). Das Produkt ist das beobachtete Objekt (das Subject), und die Listener sind die Observer. Buttons in grafischen Programmen funktionieren genau so: „Beim Klick ruf das hier auf“.

Genauer, für Neugierige

• Du brauchst auch ein unsubscribe, das den Listener aus der Liste entfernt. Ein Abonnent, den niemand entfernt, bleibt im Speicher, solange das Produkt lebt.
• In der alten Vorlesung heißt die beobachtete Klasse Subject, mit den Methoden attach und notifyAllObservers, und der Observer ist eine abstrakte Klasse mit einer Methode update(). Die Idee ist dieselbe, und das Interface erlaubt Lambdas.
• Die Listener werden nacheinander aufgerufen, in dem Thread, der die Anzahl geändert hat. Ist einer von ihnen langsam, warten alle.

Probier es aus

Wer hört es?

Product ist das aus der Karte davor.

Was gibt das Programm aus?

Product coffee = new Product("Kaffee", 5);
coffee.subscribe((name, qty) -> System.out.println("A: " + qty));
coffee.setQuantity(4);
coffee.setQuantity(4);
coffee.subscribe((name, qty) -> System.out.println("B: " + qty));
coffee.setQuantity(0);

Antwort

A: 4
A: 4
A: 0
B: 0

A: 4
A: 0
B: 0

A: 4
A: 0

A: 4
B: 4
A: 0
B: 0

Prüfen

Sieh es dir an

Factory Method: welche Klasse erzeugt wird

Der Kunde hat gewählt, wie wir ihn benachrichtigen: per E-Mail oder SMS. Der Code, der sendet, soll nicht an zehn Stellen new EmailNotification() schreiben, jede mit ihrem eigenen if.

interface Notification {
    void send(String to, String text);
}

class EmailNotification implements Notification {
    @Override
    public void send(String to, String text) {
        System.out.println("E-Mail an " + to + ": " + text);
    }
}

class SmsNotification implements Notification {
    @Override
    public void send(String to, String text) {
        System.out.println("SMS an " + to + ": " + text);
    }
}

Die Wahl steht an einer Stelle, in einer Fabrik:

class NotificationFactory {
    public static Notification create(String channel) {
        return switch (channel) {
            case "email" -> new EmailNotification();
            case "sms" -> new SmsNotification();
            default -> throw new IllegalArgumentException("Unbekannter Kanal: " + channel);
        };
    }
}

String[][] customers = {
        { "email", "maria@example.com" },
        { "sms", "+49 151 2345678" },
        { "taube", "Hauptstraße 5" },
};
for (String[] c : customers) {
    try {
        Notification n = NotificationFactory.create(c[0]);
        n.send(c[1], "Deine Bestellung wurde versandt.");
    } catch (IllegalArgumentException e) {
        System.out.println(e.getMessage());
    }
}

Ausgabe

E-Mail an maria@example.com: Deine Bestellung wurde versandt.
SMS an +49 151 2345678: Deine Bestellung wurde versandt.
Unbekannter Kanal: taube

Der Aufrufer sagt, was er will („email“), und bekommt eine Notification. Welche Klasse genau dahintersteht, weiß nur die Fabrik. Ein neuer Kanal, zum Beispiel Push, ist eine neue Klasse und eine neue Zeile im switch. Das Senden wird nicht angefasst.

Genauer, für Neugierige

• Das ist die häufigste Form in der Praxis. Ihr genauerer Name ist „einfache Fabrik“ (simple factory). Die Factory Method aus dem GoF-Buch ist etwas anderes: Die Basisklasse hat eine abstrakte Methode, die das Objekt erzeugt, und die Unterklassen entscheiden, welches:

abstract class Shop {
    protected abstract Notification createNotification();

    public void confirmOrder(String to) {
        createNotification().send(to, "Die Bestellung ist eingegangen.");
    }
}

class OnlineShop extends Shop {
    @Override
    protected Notification createNotification() {
        return new EmailNotification();
    }
}

class PhoneShop extends Shop {
    @Override
    protected Notification createNotification() {
        return new SmsNotification();
    }
}

new OnlineShop().confirmOrder("maria@example.com");
new PhoneShop().confirmOrder("+49 151 2345678");

Ausgabe

E-Mail an maria@example.com: Die Bestellung ist eingegangen.
SMS an +49 151 2345678: Die Bestellung ist eingegangen.

confirmOrder ist einmal geschrieben, in Shop, und weiß nicht, welche Benachrichtigung es sendet.

• In alten Beispielen gibt die Fabrik für eine unbekannte Art null zurück. Dann stürzt der Aufrufer mit einer NullPointerException ab, weit weg von der eigentlichen Ursache. Eine Exception mit einer klaren Meldung ist besser.

Sieh es dir an

Singleton: nur ein Objekt

Die Einstellungen der Anwendung, etwa die Währung, werden einmal gelesen. Macht sich jeder Teil des Programms sein eigenes Einstellungsobjekt, werden sie viele Male gelesen und können auseinanderlaufen.

class AppConfig {
    private static AppConfig instance;
    private String currency = "EUR";

    private AppConfig() {
        System.out.println("Einstellungen werden gelesen...");
    }

    public static AppConfig getInstance() {
        if (instance == null) {
            instance = new AppConfig();
        }
        return instance;
    }

    public String getCurrency() {
        return currency;
    }
}

AppConfig a = AppConfig.getInstance();
AppConfig b = AppConfig.getInstance();
System.out.println(a == b);
System.out.println(b.getCurrency());

Ausgabe

Einstellungen werden gelesen...
true
EUR

• Der Konstruktor ist private. Niemand außerhalb der Klasse kann new AppConfig() schreiben.
• Das einzige Objekt steht im statischen Feld instance. getInstance() erzeugt es beim ersten Aufruf und gibt danach immer dieses zurück.
• „Einstellungen werden gelesen...“ erscheint einmal, und a == b ist true: Es gibt ein Objekt.

Das ist Singleton.

Genauer, für Neugierige

• Rufen zwei Threads getInstance() im selben Moment auf, können zwei Objekte entstehen. Threads kommen im Modul „Programme in der echten Welt“.
• Der sicherste Singleton in Java ist ein enum mit einem Wert. Ein enum ist ein Typ mit vorab aufgezählten Objekten. Java erzeugt jedes genau einmal und erlaubt kein new:

enum Settings {
    INSTANCE;

    private String currency = "EUR";

    public String getCurrency() {
        return currency;
    }
}

System.out.println(Settings.INSTANCE.getCurrency());
System.out.println(Settings.INSTANCE == Settings.INSTANCE);

Ausgabe

EUR
true

• Ein Singleton ist eine globale Variable für das ganze Programm mit einem schönen Namen. Jeder kann ihn von überall benutzen, darum ist er schwer zu testen und schwer zu ersetzen. Oft ist es besser, das Objekt einmal in main zu erzeugen und es über den Konstruktor denen zu übergeben, die es benutzen.

Probier es aus

Finde den Fehler

Bestellnummern müssen eindeutig sein, darum ist der Zähler ein Singleton. Das Programm hat aber die Nummer 1001 zweimal vergeben:

System.out.println(OrderNumbers.getInstance().nextNumber());
System.out.println(OrderNumbers.getInstance().nextNumber());
System.out.println(new OrderNumbers().nextNumber());

Ausgabe

1001
1002
1001

In welcher Zeile der Klasse steckt der Fehler?

Wähle die Zeile mit dem Fehler.

1class OrderNumbers {2 private static OrderNumbers instance;3 private int next = 1001;45 public OrderNumbers() {6 }78 public static OrderNumbers getInstance() {9 if (instance == null) {10 instance = new OrderNumbers();11 }12 return instance;13 }1415 public int nextNumber() {16 return next++;17 }18}

Prüfen

Sieh es dir an

Adapter: verbindet unverträgliche Interfaces

Der Shop bezahlt über ein Interface mit einem Betrag in Euro und einer Antwort „ja oder nein“. Die Bank gibt dir eine alte Bibliothek, die Cent will und einen Fehlercode zurückgibt. Die Bibliothek gehört nicht dir, und du kannst sie nicht ändern.

// Die alte Bibliothek der Bank. Du kannst sie nicht ändern.
class LegacyBankClient {
    // Der Betrag ist in Cent. Gibt bei Erfolg 0 zurück, sonst einen Fehlercode.
    public int charge(long cents, String reference) {
        System.out.println("Bank: " + cents + " Cent für " + reference);
        return cents <= 50000 ? 0 : 51;
    }
}

Du schreibst eine Klasse, die so aussieht, wie der Shop es erwartet, und darin die Bank aufruft:

// Das erwartet der Shop.
interface PaymentGateway {
    boolean pay(String orderId, double amountEur);
}

class BankAdapter implements PaymentGateway {
    private LegacyBankClient bank;

    public BankAdapter(LegacyBankClient bank) {
        this.bank = bank;
    }

    @Override
    public boolean pay(String orderId, double amountEur) {
        long cents = Math.round(amountEur * 100);
        return bank.charge(cents, "ORDER-" + orderId) == 0;
    }
}

PaymentGateway gateway = new BankAdapter(new LegacyBankClient());
System.out.println(gateway.pay("1001", 49.90));
System.out.println(gateway.pay("1002", 1299.00));

Ausgabe

Bank: 4990 Cent für ORDER-1001
true
Bank: 129900 Cent für ORDER-1002
false

Der Adapter übersetzt in beide Richtungen: Euro in Cent und eine Nummer in Text auf dem Hinweg, Code 0 in true auf dem Rückweg. Der Shop weiß nicht, dass eine alte Bibliothek dahintersteht. Wechselst du morgen die Bank, schreibst du einen neuen Adapter, und der Shop wird nicht angefasst.

Das ist Adapter: wie ein Reisestecker-Adapter, der weder den Stecker noch die Steckdose verändert.

Genauer, für Neugierige

Das klassische Beispiel in den Büchern, und in der alten Vorlesung, ist ein Mediaplayer. AudioPlayer kann nur mp3 abspielen, und eine vorhandene Klasse AdvancedMediaPlayer hat die Methoden playVlc und playMp4. MediaAdapter implementiert das Interface des Players und leitet an die richtige Methode weiter. Die Struktur ist dieselbe wie hier.

Übung

Muster im Shop

Löse die Aufgaben in deinem Editor.

1. Rabatte als Strategien. Ein Interface DiscountStrategy mit statischen Methoden, die ein Lambda zurückgeben (ein Interface kann static Methoden mit Rumpf haben, genau wie default): none(), percent(double p) und fixed(double amount) (nie unter 0 €). Eine Klasse Cart mit einer Liste von Preisen und einem austauschbaren Rabatt. Füge Kaffeebohnen (18,50 €), Honig (12 €) und Tee (4,20 €) hinzu und gib die Summe aus: ohne Rabatt, mit −10 %, mit −5 € und mit −50 €.

Ausgabe

Ohne Rabatt: 34.70 €
-10%: 31.23 €
-5 €: 29.70 €
-50 €: 0.00 €

2. „Benachrichtige mich, wenn es wieder da ist“. Das Produkt hält eine Liste von Kunden, die warten. Wenn der Bestand von 0 auf mehr als 0 geht, benachrichtigt es alle und leert die Liste, denn die Benachrichtigung kommt nur einmal. Die Konsole hat 0 Stück auf Lager, Maria und Jonas abonnieren, dann wird der Bestand 5, 0 und 3.

Ausgabe

E-Mail an Maria: Konsole ist verfügbar (5 Stk.)
SMS an Jonas: Konsole ist verfügbar
Ende

3. Eine Fabrik für Benachrichtigungen. Füge PushNotification hinzu und eine Fabrik für die drei Kanäle, der Groß- und Kleinschreibung egal ist. Lies eine Anzahl von Zeilen und dann Zeilen „Kanal;Adresse“. Schick an jede Adresse „Deine Reservierung ist bestätigt.“, und gib für einen unbekannten Kanal die Meldung der Exception aus.

Eingabe

4
Email;maria@example.com
sms;+49 151 2345678
push;Lauras Handy
fax;030 123456

Ausgabe

E-Mail an maria@example.com: Deine Reservierung ist bestätigt.
SMS an +49 151 2345678: Deine Reservierung ist bestätigt.
Push an Lauras Handy: Deine Reservierung ist bestätigt.
Unbekannter Kanal: fax

4. Ein altes Thermometer. Eine Klasse OldThermometer liefert die Temperatur in Fahrenheit mit readFahrenheit(). Das neue System arbeitet mit interface TemperatureSensor { double celsius(); }. Schreib ThermometerAdapter (°C = (°F − 32) × 5 / 9). Leg in eine Liste von Sensoren zwei alte Thermometer (71,6 °F und 39,2 °F) über den Adapter und einen neuen Sensor als Lambda, das 21,5 °C liefert.

Ausgabe

Büro: 22.0 °C
Lager: 4.0 °C
Serverraum: 21.5 °C

Weitere Aufgaben

• Lieferung als Strategie. Mach eine ShippingStrategy mit einem Preis für die Packstation, die Haustür und die Abholung im Laden, und setz sie zusammen mit dem Rabatt in die Kasse.
• Ein Log als Singleton. Eine Klasse Logger mit getInstance() und einer Methode log(String), die die Zeilen nummeriert. Prüf, dass die Nummern weiterlaufen, wenn du sie aus zwei verschiedenen Methoden aufrufst.
• Ein Preis-Observer. Füge dem Produkt Abonnenten für Preisänderungen hinzu und schick eine Benachrichtigung nur, wenn der Preis um mindestens 10 % fällt.

Test

Teste dich

1. Was ist ein Entwurfsmuster?

Eine fertige Bibliothek, die du ins Projekt einbindestEine Regel des CompilersEine bewährte Lösung mit Namen für ein Problem, das immer wieder vorkommt: eine Idee, wie man die Klassen anordnet

2. Jede neue Aktion im Shop fügt der Preismethode ein neues else if hinzu. Welches Muster hilft?

SingletonStrategy: Jeder Rabatt ist ein eigenes Objekt oder Lambda, und die Kasse bekommt gesagt, welches sie nehmen sollAdapter

3. Das Produkt sagt der Website, dem Lager und dem E-Mail-System Bescheid, wenn sich der Bestand ändert, ohne zu wissen, wer sie sind. Welches Muster ist das?

SingletonObserverFactory Method

4. Was verhindert Singleton?

Dass von der Klasse geerbt wirdDass ein zweites Objekt entsteht: Der Konstruktor ist private, und das einzige Objekt holt man mit getInstance()Dass die Felder geändert werden

5. Du hast eine alte Klasse, die die Temperatur in Fahrenheit liefert, und das Programm erwartet ein Interface mit Grad Celsius. Was tust du?

Adapter: Eine neue Klasse implementiert das Interface, ruft darin die alte auf und rechnet die Werte umFactory MethodDie alte Klasse neu schreiben

Prüfen

Die Idee

Weiter: die Muster aus der Nähe

Hier hast du fünf Muster kurz gesehen, mit Lambdas. Im Kurs „Softwaretechnik“ gibt es ein ganzes Modul über Muster: Jedes beginnt mit Code, der wehtut, hat eine Animation, welches Objekt welches aufruft, und sagt, wann du es nicht brauchst. Dort sind auch Builder, Decorator, Composite, Command, State, Template Method, Iterator und Repository.

Das Modul ist hier: Entwurfsmuster.

Lektion von vorn beginnen

Verwandte Lektionen

• Baut auf: Listen · Klassen in Klassen · Lambdas · record, switch und Muster
• Geht weiter in: Warum Muster · Strategy · Observer · Factory Method und Simple Factory
• Aufgaben zum Thema: Modernes Java