Software Quality Management

Transcription

1 Marco Scotto

2 Course Outline Creational Patterns Singleton Builder 2

3 Design pattern space Purpose Creational Structural Behavioral Scope Class Factory Method Adapter Interpreter Template Method Object Abstract Factory Adapter Chain of Responsibility Builder Bridge Command Prototype Composite Iterator Singleton Decorator Mediator Façade Memento Proxy Flyweight Observer State Strategy Visitor 3

4 Singleton Pattern (1/2) Intent Ensure a class only has one instance, and provide a global point of access to it Motivation Sometimes we want just a single instance of a class to exist in the system For example, we want just one window manager. Or just one factory for a family of products We need to have that one instance easily accessible And we want to ensure that additional instances of the class can not be created 4

5 Structure Singleton Pattern (2/2) Consequences Benefits Controlled access to sole instance Permits a variable number of instances 5

6 Singleton With No Subclassing (1/4) First, let's look at the case where we are not concerned with subclassing the Singleton class We use a static method to allow clients to get a reference to the single instance /** * Class Singleton is an implementation of a class that * only allows one instantiation. */ public class Singleton { // The private reference to the one and only instance. private static Singleton uniqueinstance = null; // An instance attribute. private int data = 0; 6

7 Singleton With No Subclassing (2/4) /** * Returns a reference to the single instance. * Creates the instance if it does not yet exist. * (This is called lazy instantiation.) */ public static Singleton instance() { if(uniqueinstance == null) uniqueinstance = new Singleton(); return uniqueinstance; /** * The Singleton Constructor. * Note that it is private! * No client can instantiate a Singleton object! */ private Singleton() { // Accessors and mutators here! 7

8 Singleton With No Subclassing (3/4) Here's a test program: public class TestSingleton { public static void main(string args[]) { // Get a reference to the single instance of Singleton. Singleton s = Singleton.instance(); // Set the data value. s.setdata(34); System.out.println("First reference: " + s); System.out.println("Singleton data value is: " + s.getdata()); 8

9 Singleton With No Subclassing (4/4) // Get another reference to the Singleton. // Is it the same object? s = null; s = Singleton.instance(); System.out.println("\nSecond reference: " + s); System.out.println("Singleton data value is: " + s.getdata()); And the test program output: First reference: Singleton@1cc810 Singleton data value is: 34 Second reference: Singleton@1cc810 Singleton data value is: 34 9

10 Singleton With Subclassing What if we want to be able to subclass Singleton and have the single instance be a subclass instance? For example, suppose MazeFactory had subclasses EnchantedMazeFactory and AgentMazeFactory. We want to instantiate just one factory, either an EnchantedMazeFactory or an AgentMazeFactory Several methods: Have the static instance() method of MazeFactory determine the particular subclass instance to instantiate. This could be done via an argument or environment variable. The constructors of the subclasses can not be private in this case, and thus clients could instantiate other instances of the subclasses Have each subclass provide a static instance() method. Now the subclass constructors can be private 10

11 Singleton With Subclassing Method 1 (1/4) Method 1: Have the MazeFactory instance() method determine the subclass to instantiate /** * Class MazeFactory is an implementation of a class that * only allows one instantiation of a subclass. */ public abstract class MazeFactory { // The private reference to the one and only instance. private static MazeFactory uniqueinstance = null; // The MazeFactory constructor. // If you have a default constructor, it can not be private // here! protected MazeFactory() { 11

12 Singleton With Subclassing Method 1 (2/4) // Return a reference to the single instance. // If instance not yet created, create "enchanted" as default. public static MazeFactory instance() { If (uniqueinstance == null) return instance("enchanted"); else return uniqueinstance; // Create the instance using the specified String name. public static MazeFactory instance(string name) { if(uniqueinstance == null) If (name.equals("enchanted")) uniqueinstance = new EnchantedMazeFactory(); else if (name.equals("agent")) uniqueinstance = new AgentMazeFactory(); return uniqueinstance; 12

13 Singleton With Subclassing Method 1 (3/4) Client code to create factory the first time: MazeFactory factory = MazeFactory.instance("enchanted"); Client code to access the factory: MazeFactory factory = MazeFactory.instance(); Note that the constructors of EnchantedMazeFactory and AgentMazeFactory can not be private, since MazeFactory must be able to instantiate them Thus, clients could potentially instantiate other instances of these subclasses 13

14 Singleton With Subclassing Method 1 (4/4) The instance(string) methods violates the Open- Closed Principle, since it must be modified for each new MazeFactory subclass We could use Java class names as the argument to the instance(string) method, yielding simpler code: public static MazeFactory instance(string name) { if (uniqueinstance == null) uniqueinstance = Class.forName(name).newInstance(); return uniqueinstance; 14

15 Singleton With Subclassing Method 2 (1/3) Method 2: Have each subclass provide a static instance method() /** * Class MazeFactory is an implementation of a class that * only allows one instantiation of a subclass. This version * requires its subclasses to provide an implementation of * a static instance() method. */ public abstract class MazeFactory { // The protected reference to the one and only instance. protected static MazeFactory uniqueinstance = null; // The MazeFactory constructor. // If you have a default constructor, it can not be private // here! protected MazeFactory() { // Return a reference to the single instance. public static MazeFactory instance() {return uniqueinstance; 15

16 Singleton With Subclassing Method 2 (2/3) /** * Class EnchantedMazeFactory is an implementation of a * class that only allows one instantiation. */ public class EnchantedMazeFactory extends MazeFactory { // Return a reference to the single instance. public static MazeFactory instance() { if(uniqueinstance == null) uniqueinstance = new EnchantedMazeFactory(); return uniqueinstance; // Private subclass constructor!! private EnchantedMazeFactory() { 16

17 Singleton With Subclassing Method 2 (3/3) Client code to create factory the first time: MazeFactory factory = EnchantedMazeFactory.instance(); Client code to access the factory: MazeFactory factory = MazeFactory.instance(); Note that now the constructors of the subclasses are private. Only one subclass instance can be created! Also note that the client can get a null reference if it invokes MazeFactory.instance() before the unique subclass instance is first created Finally, note that uniqueinstance is now protected! 17

18 Builder (1/4) Intent Separate the construction of a complex object from its representation so that the same construction process can create different representations 18

19 Builder (2/4) Motivation A reader for the RTF (Rich Text Format) document exchange format should be able to convert RTF to many text formats. The reader might convert RTF documents into plain ASCII text or into a text widget that can be edited interactively The problem, however, is that the number of possible conversions is open-ended. So it should be easy to add a new conversion without modifying the reader 19

20 Builder (3/4) Solution Configure the RTFReader class with a TextConverter object that converts RTF to another textual representation As the RTFReader parses the RTF document, it uses the TextConverter to perform the conversion. Whenever the RTFReader recognizes an RTF token (either plain text or an RTF control word), it issues a request to the TextConverter to convert the token TextConverter objects are responsible both for performing the data conversion and for representing the token in a particular format 20

21 Builder (4/4) Example 21

22 Applicability Use the Builder pattern when: The algorithm for creating a complex object should be independent of the parts that make up the object and how they are assembled The construction process must allow different representations for the object that's constructed 22

23 Structure 23

24 Participants Builder (TextConverter) Specifies an abstract interface for creating parts of a Product object ConcreteBuilder (ASCIIConverter, TeXConverter, TextWidgetConverter) Constructs and assembles parts of the product by implementing the Builder interface Defines and keeps track of the representation it creates Provides an interface for retrieving the product (e.g., GetASCIIText, GetTextWidget) 24

25 Participants (1/2) Director (RTFReader) Constructs an object using the Builder interface Product (ASCIIText, TeXText, TextWidget) Represents the complex object under construction. ConcreteBuilder builds the product's internal representation and defines the process by which it is assembled Includes classes that define the constituent parts, including interfaces for assembling the parts into the final result 25

26 Collaborations (2/2) The client creates the Director object and configures it with the desired Builder object Director notifies the builder whenever a part of the product should be built Builder handles requests from the director and adds parts to the product The client retrieves the product from the builder 26

27 Builder Example (1/8) public interface MazeBuilder { public void buildmaze(); public void buildroom(int room); public void builddoor(int roomfrom, int roomto); public Maze getmaze(); 27

28 Builder Example (2/8) Given the MazeBuilder interface, we can change the createmaze member function of class Game to take this builder as a parameter public Maze createmaze(mazebuilder builder) { builder.buildmaze(); builder.buildroom(1); builder.buildroom(2); builder.builddoor(1, 2); return builder.getmaze(); 28

29 Builder Example (3/8) The following interaction diagram illustrates how Builder and Director cooperate with a client 29

30 Builder Example (4/8) public class StandardMazeBuilder implements MazeBuilder { private Maze _currentmaze; public StandardMazeBuilder() { public void buildmaze() { _currentmaze = new Maze(); public void buildroom(int n) { if (!_currentmaze.roomno(n)) { Room room = new Room(n); _currentmaze->addroom(room); room.setside(north, new Wall()); room.setside(south, new Wall()); room.setside(east, new Wall()); room.setside(west, new Wall()); 30

31 Builder Example (5/8) public void builddoor(int n1, int n2) { Room r1 = _currentmaze.roomno(n1); Room r2 = _currentmaze.roomno(n2); Door d = new Door(r1, r2); r1.setside(commonwall(r1,r2), d); r2.setside(commonwall(r2,r1), d); public Maze* getmaze() { return _currentmaze; private Direction commonwall(room r1, Room r2) { /*... */ 31

32 Builder Example (6/8) public class CountingMazeBuilder implements MazeBuilder { private int _doors; private int _rooms; public CountingMazeBuilder() { _rooms = _doors = 0; public void buildmaze() { public void buildroom(int n) { _rooms++; public void builddoor(int n1, int n2) { _doors++; 32

33 Builder Example (7/8) public int getroomcount() { return _rooms; public int getdoorscount() { return _doors; 33

34 Builder Example (8/8) Here is how a client might use a CountingMazeBuilder: int rooms, doors; MazeGame game; CountingMazeBuilder builder; game.createmaze(builder); System.out.println( The maze has + builder.getroomcount() + rooms and + builder.getdoorcount() + doors ); 34