Decorator Pattern

[GentStudent]

Hey iedereen,
 
Ik hoop hier een antwoord te krijgen op mijn vraag omtrent design patterns. Het is een iets meer geavanceerde vraag dan hier normaal wordt gesteld, maar ik hoop toch een antwoord te vinden. Volgende vraag staat op het voorbeeldexamen over design patterns, ik moet het domeinmodel opstellen:
 
Gegeven zijn de interface Model en een bijhorende implementatieklasse MyModel. 

Code: Selecteer alles

public interface Model {
    Object getValue();
    void setValue(Object newValue);
}  
public class MyModel implements Model {
    private Object value;
    public Object getValue() {return value;  }
    public void setValue(Object newValue) {value = newValue;}
}  

Aan deze implementatie dien je logging-functionaliteit toe te voegen: elke wijziging aan het model moet worden afgedrukt naar System.out. Je moet hierbij rekening houden met de volgende vereisten:

• De interface Model en de klasse MyModel mogen niet aangepast worden. Je zal dus een nieuwe klasse moeten maken.
• Deze nieuwe klasse moet gebruikt kunnen worden alsof het een gewoon Model is. M.a.w.: overal waar een Model kon gebruikt worden, moet ook een object van de nieuwe klasse kunnen gebruikt worden.
• Wanneer er later nieuwe implementaties van de interface Model bijkomen dan moeten deze ook voorzien kunnen worden van logging-functionaliteit, zonder dat hiervoor aanpassingen aan bestaande klassen nodig zijn.
 
Welk patroon kan je hiervoor gebruiken? -> Het decorator pattern
 
Ik moet hier nu dus het nieuwe domeinmodel van opstellen, maar ik weet niet hoe. Ik dacht dus met een abstracte klasse "Decorator" te werken en dan een concrete klassen "LogModel" maar dan kan deze concrete klasse dus niet als gewoon model gebruikt worden...  Kan er iemand helpen?

[physicalattraction]

Je moet je Decorator in dat geval ook van Model laten erven, dan kan het alles wat een normaal Model ook kan. Op Wikipedia staat een plaatje hoe de klassen dan uitzien.

[Xenion]

Zoals op de Wikipedia pagina wordt uitgelegd en ook in dit voorbeeld, werkt een decorator als volgt:
 
Je decorator klasse zal dezelfde interface implementeren als de klasse die je wil decoraten (in jouw geval MyModel). Vervolgens zal de klasse ook een referentie naar een object van MyModel.
 
Dus heel eenvoudig:

Code: Selecteer alles

public class MyModelDecorator implements Model {
    private final Model decorated_object;

    public MyModelDecorator(Model m) {
        decorated_object = m;
    }

    // implementeer zelf de nodige interface methodes
    // deze moeten de functie-calls delegeren naar decorated_object
    // daarbovenop moet de logging functionaliteit erin komen

}

Model en MyModel moeten niet aangepast worden. Als er later nieuwe implementaties van de Model interface toegevoegd worden, moet er niks aan deze klasse veranderd worden. Overal waar nu een new MyModel(...) aangemaakt werd kan nu in de plaats een new MyModelDecorator(new MyModel(...)) gebruikt worden.