Design Patterns. State. Oliver Haase

Transcription

1 Design Patterns State Oliver Haase 1

2 Description Object based behavioral pattern Purpose: Allow an object to alter its behavior when its internal state changes. The object will appear to change its class. Also Known As: Object for States 2

3 Example Consider a class TCPConnection with several different states: Established, Listening, Closed. TCPConnection responds differently to method invocations depending on its current state. E.g. the effect of an open request depends on whether the connection is in its Closed state or its Established state. 3

4 Example - First Attempt public class TCPConnection { private enum State { ESTABLISHED, LISTENING, CLOSED; private State currentstate = CLOSED; public void open() { switch (currentstate) { case ESTABLISHED:... break;... public void close() {... switch (currentstate) { case ESTABLISHED:... break;... 4

5 Example - First Attempt Hard to read. Even harder if state consists of more than one variable. Hard to discover each state transition. What happens if we want to add a new state? Modify TCPConnection Add new case to every switch-case statement Hard to test. Better solution? 5

6 Idea Encapsulate each case of the switch-case statement in its own state class. The class TCPConnection maintains a state object that represents the current state of the TCP connection. The class TCPConnection delegates all state-specific requests to this state object. Whenever the connection changes state, the TCPConnection object changes the state object it uses. 6

7 Sample Structure TCPConnection open() close() acknowledge() state TCPState open() close() acknowledge() state.open() TCPEstablished open() close() acknowledge() TCPListen open() close() acknowledge() TCPClosed open() close() acknowledge() 7

8 General Structure defines the interface of interest to clients maintains an instance of a ConcreteState subclass that defines the current state Context request() state defines an interface for encapsulating the behavior associated with a particular state of the Context State handle() state.handle() ConcreteStateA handle() ConcreteStateB handle() each subclass implements a behavior associated with a state of the Context 8

9 Applicability Use the State pattern in either of the following cases: An object's behavior depends on its state, and it must change its behavior at run-time depending on that state. Operations have large, multipart conditional statements that depend on the object's state. remember the smell of multipart conditional statements! 9

10 Who defines the state transitions? Context Context needs to know rules for state transitions. State transition all in one place. Context needs to know all State implementations. State classes State object needs to modify its Context. Decentralization of state transitions. State needs to know its successor state. 10

11 Pros & Cons Pro: Elimination of hard to read conditional statements. Easy to add further states. Simplified maintenance. Explicit state transitions. State objects can be shared. Easier testing of each individual state. Con: Significant overhead, not sensible for simple applications. State information is distributed among many classes. 11

12 Relationship with other Patterns State objects can be implemented as Flyweight (without intrinsic state). State objects are often Singletons. 12

13 Template Method 13

14 Motivation Two classes have similar code. This leads to code duplication and duplicate effort if a change common to both classes becomes necessary. public class Coffee { public void preparerecipe() { boilwater(); brewcoffeegrinds(); pourincup(); addsugarandmilk(); public class Tea { public void preparerecipe() { boilwater(); steepteabag(); pourincup(); addlemon(); 14

15 Idea Pull similarities of both classes into a common abstract superclass and let subclasses implement only the differences. 15

16 Motivation public class HotBeverage { public final void preparerecipe() { boilwater(); brew(); pourincup(); addcondiments(); protected abstract void brew(); protected abstract void addcondiments(); private final void boilwater() {... private final void pourincup() {... public class Tea extends HotBeverage { protected void brew() {... protected void addcondiments() {... public class Coffee extends HotBeverage { protected void brew() {... protected void addcondiments() {... 16

17 Description Class based behavioral pattern Purpose: Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without allowing them to change the structure of the algorithm. 17

18 General Structure defines abstract primitive operations implements a template method which defines the skeleton of an algorithm AbstractClass TemplateMethod() PrimitiveOperation1() PrimitiveOperation2()... PrimitiveOperation1()... PrimitiveOperation2()... ConcreteClass PrimitiveOperation1() PrimitiveOperation2() implements the primitive operations to carry out subclassspecific steps of the algorithm 18

19 Remarks Often used in frameworks and class libraries. This principle (inversion of control) is often referred to as the Hollywood Principle: "Don't call us, we'll call you." Template method should be final. Superclass can implement hook methods which are optional to override for subclasses. If there is a useful default implementation for the primitive operations, the superclass need not be abstract. 19

20 Applicability The Template Method pattern should be used to implement the invariant parts of an algorithm once and leave it up to subclasses to implement the behavior that can vary. when refactoring is performed and common behavior is identified among classes. An abstract base class containing all the common code (in the template method) should be created to avoid code duplication. 20

21 Real World Examples Examples for Template Methods in Java: HttpServlet (Template Method is service()) AbstractList (Template Method is addall()) SwingWorker (Template Method is execute()) InputStream and OutputStream 21

22 Relationship with other Patterns Factory Methods get often invoked by Template Methods. Strategy Pattern uses delegation to vary the whole algorithm. Template Methods use inheritance to vary parts of the algorithm. Skeletal Implementations often define some (template) methods in terms of other (primitive) operations. 22