CS 4773 Object Oriented Systems Factory Patterns

• Error checking can be simpler
• We can create multiple objects in an atomic fashion.
  Either all are created or none are.
• We want to delegate certain decisions about what to create to another object.
• We can have the object be responsible for some of its own properties.
  (e.g. the singletone pattern, below)

• The abstract factory pattern
  To create sets or families of objects
  Removes the rules for creation from the client.
• The factory method pattern
  You need to create an object corresponding to a derived class. Let the derived class create it using a method in the derived class.
• The singleton pattern
  You want to create only a single item but you want multiple objects to have access to it.
• The prototype pattern
  Create new objects by cloning an existing object and then changing its properties.
  Example: The Graphics objects used for painting in Java.
  paintComponent is passed a Graphics object that is used for drawing.
  You can create additional one with gc.create.
• The builder pattern
  This is similar to the abstract factory pattern.
  Instead of building families of objects, it usually makes a single object from a number of parts.

The abstract factory pattern
An Example: Choosing a look-and-feel for a windowing system.
Possibilities: rectangular objects or rounded corners.
We will consider only two kinds of widgets: buttons and scrollbars.
The Abstarct Factory:

public abstract class LookAndFeel {
   public abstract Button makeButton(String s);
   public abstract Scrollbar makeScrollbar(boolean horizontal);
}

public class RectangularLookAndFeel extends LookAndFeel {
   public Button makeButton(String s) {
      return new RectangularButton(s);
   }
   public Scrollbar make Screollbar(boolean horizontal) {
      return new RectangularScrollbar(horizontal);
   }
}

public class RoundedLookAndFeel extends LookAndFeel { 
   public Button makeButton(String s) { 
      return new RoundedButton(s); 
   }
   public Scrollbar make Screollbar(boolean horizontal) {
      return new RoundedScrollbar(horizontal);
   } 
} 

public class GUI {
   public GUI (LookAndFeel laf) {
   }
}

The factory method pattern
Problem: We have two parallel hierarchies of derived classes. For a given member of the first hierarchy we need a corresponding member of the second.

Solution: Have the elements of the first hierarchy create the corresponding element of the second hierarchy.

Example: Collections

ArrayList x = new ArrayList();
PriorityQueue y = new PriorityQueue();
TreeSet z = new TreeSet();

Method 1: (using new)
Iterator xi = new Iterator(x);
Iterator yi = new Iterator(y);
Iterator zi = new Iterator(z);

Method 2: (The Factory Method)
Iterator xi = x.iterator();
Iterator yi = y.iterator();
Iterator zi = z.iterator();

The singleton pattern
Multple objects have access to a single object.

Method 1:
Create the singleton object in another class before any the the objects using it need access.
This is what we do in the editor for the error handler.
In this case they gain access by use of a static method.

Method 2: the singleton pattern
Have each object attempt to create the singleton object.
The first one actually does the creation.
The others just get access to the one already created.

Example:

public class MySingleton {

   private static MySingleton mySingleton = null;

   private MySingleton() {
      // rest of constructor here
      mySingleton = this;
   }

   public static synchronized MySingleton getIt() {
      if (mySingleton == null)
         new MySingleton();
      return mySingleton;
   }

}