Component ConcreateComponent Decorator ConcreateDecoratorA ConcreteDecoratorB

Transcription

1 Comp435 Object-Oriented Design Week 12 Computer Science PSU HBG Attach additional responsibilities to an object dynamically Provide a flexible alternative to subclassing for extending functionality Attach responsibilities / functionality Subclassing: Every object of the subclass : Individual objects Confirms to the component s interface Remains transparent Can add unlimited number of responsibility with nested s 1 2 To add responsibilities to individual objects Dynamically and transparently For responsibility that can be withdrawn When extension by subclassing is impractical Avoid explosion of subclasses Component ConcreateComponent component component operation() ConcreateA addedstate ConcreteB AddedBehavior() ::; AddedBehavior() 3 4 Component / ConcreteComponent / Concrete Forwards request to its Component object Optionally perform additional operations Before / after forwarding the reques Benefits More flexible than static inheritance Responsibility can be added/remove at run-time Avoid explosion of subclasses Liabilities acts as a transparent enclosure Objects differ in the way they are interconnected Easy to customize 5 6 1

2 Convert the interface of a class into anther interface Let incompatible classes work together Want to reuse an existing class Client uses different interface Example Existing class has: int aclass::getx() Client uses: int atarget::get( x ) : class my : public Target, private aclass { public: int get( x ) { return getx(); }... } 7 8 Want to use existing class Interface does not match the one we need Want to create a reusable class that cooperates With unrelated/unforeseen classes With classes of incompatible interfaces : Class Client Target Adaptee Specific (implementation) Specific 9 10 : Object Client Target Adaptee Specific adaptee adaptee Specific Client, Target, Adaptee, Client Uses operations on an Calls corresponding operation on an Adaptee

3 Adapts Adaptee to Target Class adapter Works with Adaptee, but not its subclasses Object adapter Works with Adaptee and all its subclasses Can overrides Adaptee s behavior Harder to override with Object Decouple an abstraction from its implementation so that the two can vary independently Decouple abstraction from implementation Inheritance Provides different implementation for an abstraction Binds implementation to the abstraction permanently Separates abstraction and implementation To avoid permanent binding between abstraction and its implementation Abstraction and implementation should be extensible by subclassing independently Implementation change should have no effect on clients Want to hide implementation from client Want to share an implementation among multiple objects Abstraction RefinedAbstraction imp imp ; ConcreteImplementorA Implementor ConcreteImplementorB Abstraction / RefinedAbstraction Implementor / ConcreteImplementor Abstraction Forwards client requests to its implementation objects

4 Decoupling interface and implementation can be configured at run-time can be changed at run-time Encourages layering leading to better structured system Improved extensibility Can extend Abstraction and Implementation independently Hiding implementation details from clients Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically Object changes its state upon changes in other object Need to check when the other object changes Polling the data for changes is wasteful The other object notifies the object when changes occur When a change to one object requires changing many other objects When an object need to notify other objects without knowing the other objects Avoid tight coupling between them Subject Attach() Dettach() Notify() ConcreteSubject GetState() SetState() subjectstate observers for all o in observers { o Update() } return subjectstate subject Update() Concrete Update() observerstate observerstate=subject GetState() 23 Subject / ConcreteSubject / Concrete ConcreteSubject Notifies observers when a change occurs Concrete May query the subject for information Uses this information to change its own state 24 4

5 Decouple Subjects and s Reuse subjects with different observers Add observers without modifying subject or other objects Abstract coupling between Subjects and s Loose coupling Support for broadcast communication