Wie verwende ich das Decorator-Muster, um großen Objekten kleine Funktionen hinzuzufügen?

Diese Frage betrifft die Verwendung des Decorator-Musters, um Objekten großer Klassen wenig Funktionalität hinzuzufügen.

Beachten Sie nach dem klassischen Decorator-Muster die folgende Klassenstruktur:

Stellen Sie sich zum Beispiel vor, dies passiert innerhalb eines Spiels. Instanzen von ConcreteCharacterDecoratorsollen dem ConcreteCharacter"Wrapping" wenig Funktionalität hinzufügen .

Gibt beispielsweise methodA()einen intWert zurück, der den Schaden darstellt, den der Charakter Feinden zufügt. Das ConcreteCharacterDecoratorerhöht einfach diesen Wert. Daher muss nur Code hinzugefügt werden methodA(). Die Funktionalität von methodB()bleibt gleich.

ConcreteCharacterDecorator wird so aussehen:

class ConcreteCharacterDecorator extends AbstractCharacterDecorator{

    ConcreteCharacter character;

    public ConcreteCharacterDecorator(ConcreteCharacter character){
        this.character = character;
    }

    public int methodA(){
        return 10 + character.methodA();
    }

    public int methodB(){
        character.methodB(); // simply delegate to the wrapped object.
    }

}

Dies ist kein Problem bei kleinen Klassen mit zwei Methoden.

Aber was ist, wenn AbstractCharacter15 Methoden definiert sind? ConcreteCharacterDecoratormüsste sie alle implementieren, obwohl es nur dazu gedacht ist, wenig Funktionalität hinzuzufügen.

Am Ende werde ich eine Klasse haben, die eine Methode enthält, die ein wenig Funktionalität hinzufügt, und weitere 14 Methoden, die einfach an das innere Objekt delegieren.

Es würde so aussehen:

class ConcreteCharacterDecorator extends AbstractCharacterDecorator{

    ConcreteCharacter character;

    public ConcreteCharacterDecorator(ConcreteCharacter character){
        this.character = character;
    }

    public int methodA(){
        return 10 + character.methodA();
    }

    public int methodB(){
        character.methodB(); // simply delegate to the wrapped object.
    }
    public int methodC(){
        character.methodC(); // simply delegate to the wrapped object.
    }
    public int methodD(){
        character.methodD(); // simply delegate to the wrapped object.
    }
    public int methodE(){
        character.methodE(); // simply delegate to the wrapped object.
    }
    public int methodF(){
        character.methodF(); // simply delegate to the wrapped object.
    }
    public int methodG(){
        character.methodG(); // simply delegate to the wrapped object.
    }
    public int methodH(){
        character.methodH(); // simply delegate to the wrapped object.
    }
    public int methodI(){
        character.methodI(); // simply delegate to the wrapped object.
    }
    public int methodJ(){
        character.methodJ(); // simply delegate to the wrapped object.
    }
    public int methodK(){
        character.methodK(); // simply delegate to the wrapped object.
    }
    public int methodL(){
        character.methodL(); // simply delegate to the wrapped object.
    }
    public int methodM(){
        character.methodM(); // simply delegate to the wrapped object.
    }
    public int methodN(){
        character.methodN(); // simply delegate to the wrapped object.
    }
    public int methodO(){
        character.methodO(); // simply delegate to the wrapped object.
    }

}

Offensichtlich sehr hässlich.

Ich bin wahrscheinlich nicht der erste, der dieses Problem mit dem Dekorateur hat. Wie kann ich das vermeiden?

Schnell und einfach: AbstractCharacterDelegatorhat keine abstrakten Funktionen, sondern virtuelle. Standardmäßig werden sie an das umschlossene Zeichen übergeben und können überschrieben werden. Dann erben Sie und überschreiben nur die wenigen, die Sie wollen.

Diese Art von Dingen ist nicht besonders nützlich, es sei denn, Sie machen einiges an Dekoration und Ihre gemeinsame Oberfläche ist besonders breit. Das sollte nicht zu häufig sein. Und dieser Ansatz ist vielleicht nicht der Dekorateur, aber er verwendet das Konzept und wird von Programmierern, die das Muster kennen, als Dekorateur verstanden.

Wenn AbstractCharacter über 15 Methoden verfügt, muss es wahrscheinlich in kleinere Klassen unterteilt werden. Abgesehen davon gibt es nicht viel anderes, als dass die Sprache eine spezielle Syntaxunterstützung für die Delegierung bietet. Hinterlassen Sie einfach einen Kommentar, in dem die gesamte Delegation beginnt, damit der Leser weiß, dass er nicht weiter nach unten schauen muss. Was das Schreiben aller Weiterleitungsmethoden betrifft, kann Ihre IDE dort helfen.

Abgesehen davon bin ich der Meinung, dass Decorator am besten mit Schnittstellen funktioniert. Im Allgemeinen möchten Sie Ihre Abstraktion entweder auf eine endliche (möglicherweise 0) Anzahl von Unterklassen beschränken oder eine Schnittstelle verwenden. Unbegrenzte Vererbung hat alle Nachteile von Schnittstellen (Ihnen könnte eine falsche Implementierung übergeben werden), aber Sie erhalten nicht die volle Flexibilität (Sie können nur eine Unterklasse unterteilen). Schlimmer noch, es öffnet Sie für das Problem der fragilen Basisklasse und es ist nicht so flexibel wie Komposition (Sie erstellen SubclassA und SubclassB, können dann aber nicht von beiden erben, um SubclassAB mit Funktionen von beiden zu erstellen). Ich finde es also ein Kludge, in einen Erbbaum gezwungen zu werden, nur um die Dekoration zu unterstützen.