ActionScript 3.0 Design Patterns.pdf - VideoTutorials-bg.com

Figure 8-2. Observer pattern class diagram
the observer from the notification process. In fact, every single Subject method references
the Observer. Likewise, the Observer interface, with its single update( ) method,
references the notification process from the subject. The ConcreteSubject provides a
property, stateWork, for holding the state about which the observers are notified. It is
also responsible for notifying the subscribed observers. Finally, through the update( )
method, the ConcreteObserver keeps a state value consistent with the subject, and,
through a state property, stores the current state.
Key OOP Concepts Used with the Observer Pattern
One object-oriented design principle put forth in the original design pattern book by
Gamma et al is to favor object composition over class inheritance. That is, when possible,
design your programs using object composition instead of beginning with a
superclass and then accomplishing reuse through inheritance. To understand the reason
for this dictum, we need to look at object composition.
To appreciate the advantage of object composition over inheritance, we need to
understand another principle put forth by Gamma, Helm, Johnson and Vlissides:
Program to an interface, not an implementation.
Let’s first look at why programming to an interface is favored over programming to
an implementation.
Choose the Interface
Subject
‹‹interface››
Subscribe Observer
Unsubscribe Observer
Notify Observer
ConcreteSubject
Subscribe Observer
Unsubscribe Observer
Notify Observer
state work
observers
Observer
‹‹interface››
Update()
ConcreteObserver
Update()
subjects
In a nutshell, according to Gamma et al, programming to an interface is better than
programming to an implementation because it reduces implementation dependencies
between subsystems. This increases software flexibility. As a result, changes can
be made at runtime.
The idea of programming to an interface does not literally mean an ActionScript 3.0
construct interface as opposed to a class. That is, you can program to the interface
Key OOP Concepts Used with the Observer Pattern | 285