Non sono sicuro del motivo di progettazione del decoratore

Pensa al decoratore come a un oggetto con più funzionalità . Ora questo nuovo oggetto ha un oggetto al suo interno, e l'oggetto esterno gli dà più funzionalità.

Ecco una piccola pseudo rappresentazione di esso.

class Watch implements Clock
{
    private Clock clockToBeDecorated;

    public Watch(Clock clock)
    {
        clockToBeDecorated = clock;
    }

    public void StrappToWrist()
    {
        //strap the watch to your wrist
    }

    public DateTime GetTime()
    {
        return clock.GetTime();
    }
}

interface Clock
{
    DateTime GetTime();
}

Quindi ora abbiamo tutte le funzionalità di un orologio ma possiamo anche legarlo al polso (come ti aspetteresti da un polso). Questo è utile quando desideri passare dinamicamente l'oggetto in un altro, quindi potremmo desiderare di inserire quel clic in un Guarda o in un PocketWatch ecc.

Wikipedia ha un buon esempio utilizzando Scrolling Windows in Java e può essere d'aiuto.

I decoratori hanno molti usi ma ciò non significa che il decoratore sia lo schema appropriato da utilizzare per ogni situazione. Dati gli stessi requisiti, un programmatore può sempre provare ad implementare gli stessi requisiti in diversi modelli per vedere quale si adatta meglio.

Nell'esempio di OP, penso che ci sia una situazione in cui il sistema attack, health, speed può essere aumentato con un pattern di decoratore.

Per i vantaggi dell'OP, si prega di leggere l'esempio del motivo decoratore Coffee Condiment in Head First Design Patterns.

• link

La situazione in cui immagino che sia utile è:

• Esiste già una classe NPC sottostante, che fornisce meccanismi di base per getAttack() , getHealth() e getSpeed() .
• Esistono numerosi gadget che potrebbero essere acquisiti da un oggetto NPC e questi gadget modificheranno temporaneamente le proprietà dell'acquirente.

Esempio di codice
(Disclaimer: codice di esempio in C #, non C ++)

// Just the statistics. We are not claiming that "CaffeinePack" is a character.
interface CharacterStat
{
    int getAttack();
    int getHealth();
    int getSpeed();
}

interface Character : CharacterStat, CharacterPlanner, ...
{
    // a bunch of other stuff
}

class NPC : Character
{
    public int getAttack() { ... concrete implementation ... }
    public int getHealth() { ... concrete implementation ... }
    public int getSpeed() { ... concrete implementation ... }
}

class CaffeinePack : CharacterStat
{
    private CharacterStat realObject;
    public CaffeinePack(CharacterStat realObject) { this.realObject = realObject; }
    public int getAttack() 
    { 
        return realObject.getAttack(); 
    }
    public int getHealth() 
    { 
        return (int)(realObject.getHealth() * 0.8); 
    }
    public int getSpeed() 
    { 
        return (int)(realObject.getSpeed() * 1.2);
    }
}