1. CSC 480 Software Engineering
Design With Patterns

2. The Essence of Patterns
Each pattern describes a problem which occurs over and over again, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice.
Christopher Alexander

3. What Is a Design Pattern?
In general, a pattern has four essential elements
The pattern name – abstracts a design problem, its solutions, and consequences (vocabulary)
The problem – explains the context and describes how to represent algorithm as objects
The solution – describes the elements that make up the design, their relationships, responsibilities, and collaborations
The consequences – the results and trade-offs of applying the pattern (evaluation)

4. The Catalog of GoF Patterns
Design patterns are first classified by their purpose
Creational – the process of object creation
Structural – composition of classes and objects
Behavioral – the ways in which classes and objects interact and distribute responsibilities
The second criterion is scope
Class – static, fixed at compile-time
Object – more dynamic, changeable at run-time

5. Design Pattern Space

6. The COMMAND Pattern
The COMMAND pattern defines a method that all subclasses needs to do, while deferring details of the algorithms to each subclass to allow for additional information being provided.

7. Solution
Define a command interface with a method to execute the command.
Supply methods in the command interface type to manipulate the state of the command objects.
Each concrete command class implement the command interface.
To invoke the command, call the execute method.

8. <<interface>>
Structure
<<interface>>
Command
Client
execute()
Concrete
Command
state
execute()

9. Example The java.awt.Component class Name in Command Pattern
Actual Name
Command
Component
ConcreteCommand
MyTankPanel
execute()
paintComponent()
state
myTank, road, shell

10. How to Memorize?
The Hollywood Principle Don’t call us, we’ll call you.
When we design with the Template Method pattern, we’re telling subclasses the same thing
Other patterns (to be discussed shortly) that make use of the Hollywood Principle
Observer
Factory method

11. The OBSERVER Pattern
The OBSERVER pattern provides a mechanism to monitor and notify changes in an source object to one or more objects (known as the “observers”) that need to update themselves with the latest state from the source.

12. Solution
Define an observer interface type. All concrete observer classes must implement this interface type.
The subject (source) maintains a collection of observer objects.
The subject class supplies the method(s) for attaching observers.
Whenever an event (change) occurs, the subject notifies all observers, which in turn update themselves.

13. <<interface>>
Structure
<<interface>>
Observer
Subject
attach()
notify()
Concrete
Observer
notify()

14. Example
The java.awt.event.ActionListener interface (as well as other XxxListener interfaces)
Name in Command Pattern
Actual Name
Subject
JButton
Observer
ActionListener
ConcreteObserver
Specific classes implementing ActionListener
attach()
addActionListener ()
notify()
actionPerformed()

15. The FACTORY METHOD Pattern
The Factory Method pattern defines an interface for creating an object, but lets subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

16. Context
A type (the creator) creates objects of another type (the product).
Subclasses of the creator type need to create different kinds of product objects.
Clients do not need to know the exact type of product objects.   

17. Solution
Define a creator type that expresses the commonality of all creators.
Define a product type that expresses the commonality of all products.
Define a method, called the factory method, in the creator type. The factory method yields a product object.
Each concrete creator class implements the factory method so that it returns an object of a concrete product class.

18. Structure

19. Example
The java.util.Collection interface (or the java.util. Iterable interface as available since Java5)
Name in Command Pattern
Actual Name
Creator
Collection
Product
Iterator
factorMethod()
iterator()
ConcreteCreator
Any specific Collection class
ConcreteProduct
Any specific Iterator class (which is often anonymous)

20. The ABSTRACT FACTORY Pattern
Similar to the FACTORY METHOD, the ABSTRACT FACTORY pattern defines methods that construct a family of related products. A concrete factory class is needed for each family of related products.

21. Solution
Define an AbstractFactory interface type. All concrete Factory classes must implement this interface type.
Define two or more product types that expresses the commonality of family of related products.
Define a create method for each kind of related products in the family in the AbstractFactory type. Each create method yields a product object in the desired type.
Each concrete factory class implements all set of the factory methods so that it returns an set of related product objects for the specific style.

22. Structure

23. Example
The java.awt.event.ActionListener interface (as well as other XxxListener interfaces)
Name in Command Pattern
Actual Name
AbstractFactory
AbstractTankFactory
AbstractProduct
AbstractTank (may be broken down to tank body, canon, and shell, etc)
factorMethod()
createTank()
ConcreteFactory
EET1TankFactory, MyGameTankFactory
ConcreteProduct
EET1Tank, MyGameTank