Decorator-Muster

Teil des Abschnitts Objektorientierte Programmierung der Dart-Journey von Coddy — Lektion 96 von 110.

Das Decorator-Pattern ermöglicht es Ihnen, Objekten dynamisch neue Verhaltensweisen hinzuzufügen, indem Sie diese in spezielle Objekte, sogenannte Decorator, einhüllen. Im Gegensatz zur Vererbung, die Verhalten zur Kompilierzeit hinzufügt, hängen Decorator zusätzliche Verantwortlichkeiten zur Laufzeit an, ohne die ursprüngliche Klasse zu verändern.

Die Kernidee ist, dass sowohl das ursprüngliche Objekt als auch Dekoratoren dieselbe Schnittstelle implementieren.

Ein Decorator umhüllt das ursprüngliche Objekt, delegiert an dieses und fügt davor oder danach eigenes Verhalten hinzu:

abstract class Coffee {
  String getDescription();
  double getCost();
}

class SimpleCoffee implements Coffee {
  @override
  String getDescription() => 'Simple Coffee';

  @override
  double getCost() => 2.0;
}

class MilkDecorator implements Coffee {
  final Coffee _coffee;
  MilkDecorator(this._coffee);

  @override
  String getDescription() => '${_coffee.getDescription()}, Milk';

  @override
  double getCost() => _coffee.getCost() + 0.5;
}

class SugarDecorator implements Coffee {
  final Coffee _coffee;
  SugarDecorator(this._coffee);

  @override
  String getDescription() => '${_coffee.getDescription()}, Sugar';

  @override
  double getCost() => _coffee.getCost() + 0.2;
}

void main() {
  Coffee coffee = SimpleCoffee();
  coffee = MilkDecorator(coffee);
  coffee = SugarDecorator(coffee);

  print(coffee.getDescription());  // Simple Coffee, Milk, Sugar
  print(coffee.getCost());         // 2.7
}

Jeder Decorator umhüllt das vorherige Objekt und erweitert es. Sie können mehrere Decorator in beliebiger Kombination stapeln und so ein flexibles Verhalten erzeugen, ohne für jede mögliche Kombination eine Unterklasse erstellen zu müssen. Dieses Muster ist ideal, wenn Sie Objekten Funktionen hinzufügen müssen, ohne andere Objekte derselben Klasse zu beeinflussen.

Aufgabe

Einfach

Lassen Sie uns ein Pizza-Bestellsystem mit dem Decorator-Pattern bauen! Sie werden eine Basis-Pizza erstellen, die mit verschiedenen Belägen erweitert werden kann, wobei jeder Belag das vorherige Element umschließt und sowohl die Beschreibung als auch den Preis ergänzt.

Sie werden Ihren Code in zwei Dateien organisieren:

pizza.dart: Diese Datei enthält Ihr Pizza-Interface und alle Decorator-Klassen. Beginnen Sie mit einer abstrakten Klasse Pizza, die zwei Methoden definiert: String getDescription() und double getPrice(). Erstellen Sie dann eine Klasse PlainPizza, die Pizza implementiert - sie gibt Plain Pizza als Beschreibung zurück und kostet 8.0. Erstellen Sie nun drei Decorator-Klassen, die jeweils eine Pizza umschließen und diese erweitern:
- CheeseDecorator - fügt , Cheese zur Beschreibung und 1.5 zum Preis hinzu
- PepperoniDecorator - fügt , Pepperoni zur Beschreibung und 2.0 zum Preis hinzu
- MushroomDecorator - fügt , Mushrooms zur Beschreibung und 1.25 zum Preis hinzu
Jeder Decorator sollte Pizza implementieren, eine Pizza in seinem Konstruktor akzeptieren und an die umschlossene Pizza delegieren, bevor er seinen eigenen Beitrag hinzufügt.
main.dart: Importieren Sie Ihre Pizza-Datei und demonstrieren Sie, wie Decorator gestapelt werden, um eine individuelle Bestellung aufzubauen. Beginnen Sie mit einer PlainPizza, umschließen Sie diese dann mit CheeseDecorator, umschließen Sie das Ergebnis mit PepperoniDecorator und umschließen Sie schließlich alles mit MushroomDecorator. Geben Sie die Beschreibung der fertigen Pizza aus und geben Sie dann Total: $ gefolgt vom Preis aus.

Beachten Sie, wie jeder Decorator auf dem vorherigen aufbaut - Sie erstellen eine voll belegte Pizza, indem Sie einfache Decorator mit einer einzigen Verantwortlichkeit stapeln!

Erwartete Ausgabe:

Plain Pizza, Cheese, Pepperoni, Mushrooms
Total: $12.75

Spickzettel

Das Decorator-Muster fügt Objekten dynamisch neue Verhaltensweisen hinzu, indem es sie in Dekorierer-Objekte einhüllt. Sowohl das ursprüngliche Objekt als auch die Dekorierer implementieren dieselbe Schnittstelle.

Hauptkomponenten:

Eine abstrakte Klasse oder Schnittstelle, die die gemeinsamen Methoden definiert
Eine konkrete Klasse, die die Basisfunktionalität implementiert
Dekorierer-Klassen, die das ursprüngliche Objekt einhüllen und erweitern

Jeder Dekorierer:

Implementiert dieselbe Schnittstelle wie das Objekt, das er dekoriert
Hält eine Referenz auf das eingehüllte Objekt
Delegiert Aufrufe an das eingehüllte Objekt
Fügt sein eigenes Verhalten vor oder nach der Delegation hinzu

abstract class Coffee {
  String getDescription();
  double getCost();
}

class SimpleCoffee implements Coffee {
  @override
  String getDescription() => 'Simple Coffee';

  @override
  double getCost() => 2.0;
}

class MilkDecorator implements Coffee {
  final Coffee _coffee;
  MilkDecorator(this._coffee);

  @override
  String getDescription() => '${_coffee.getDescription()}, Milk';

  @override
  double getCost() => _coffee.getCost() + 0.5;
}

// Mehrere Dekorierer stapeln
Coffee coffee = SimpleCoffee();
coffee = MilkDecorator(coffee);
coffee = SugarDecorator(coffee);

Dekorierer können in beliebiger Kombination gestapelt werden, was flexibles Verhalten ermöglicht, ohne für jede mögliche Kombination Unterklassen erstellen zu müssen.

Probier es selbst

import 'pizza.dart';

void main() {
  // TODO: Erstelle eine PlainPizza
  
  // TODO: Umhülle sie mit CheeseDecorator
  
  // TODO: Umhülle das mit PepperoniDecorator
  
  // TODO: Umhülle alles mit MushroomDecorator
  
  // TODO: Gib die Beschreibung der fertigen Pizza aus
  
  // TODO: Gib "Total: $" gefolgt vom Preis aus
}