CSC 480 Software Engineering Design With Patterns

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

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)

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

Design Pattern Space

The COMMAND Pattern behavioral object 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.

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.

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

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

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

The OBSERVER Pattern behavioral object 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.

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.

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

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()

The FACTORY METHOD Pattern creational class 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.

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.   

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.

Structure

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)

The ABSTRACT FACTORY Pattern creational object 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.

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.

Structure

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

Composite Design Pattern