Factory Method Pattern

The Factory Method Pattern encapsulates object creation by letting subclasses decide what objects to create. The creator class defines an abstract factory method that the subclasses implement to produce products. Factory method is known as a creational pattern - it's used to construct objects such that they can be decoupled from the implementing system.

The GoF book on Design Patterns defines it as -
Define an interface for creating an object, but let the subclasses decide which class to instantitate. The Factory method lets a class defer instantiation to subclasses.
In this definition the term "interface" is used in the general sense, meaning - a concrete class implementing a method from a supertype (a class or interface).

The Factory method builds on the concept of a Simple Factory, but lets the sub-classes decide which implementation of the concrete class to use. Simple factory is a programming idiom rather than a pattern, where object creation is relegated to a method. Factory Method pattern builds on it - deferring object creation to sub-classes.

A simple factory can also be defined as a static method and is often called a static factory. This way we don’t have to instantiate an object to make use of the create method. But the disadvantage is that, we can’t subclass and change the behavior of the create method.

Example code from http://java.dzone.com/articles/design-patterns-factory. First an interface and an implementation for the product:

view plainprint?

1. public interface Logger {  
2.     public void log(String message);  
3. }  

public interface Logger {
	public void log(String message);
}

view plainprint?

1. public class XmlLogger implements Logger {  
2.   
3.     @Override  
4.     public void log(String message) {  
5.         System.err.println(message);  
6.     }  
7.   
8. }  

public class XmlLogger implements Logger {

	@Override
	public void log(String message) {
		System.err.println(message);
	}

}

Creator with the abstract factory method:

view plainprint?

1. public abstract class AbstractLoggerCreator {  
2.       
3.     //factory method  
4.     public abstract Logger createLogger();  
5.       
6.     public Logger getLogger() {  
7.         Logger logger = new XmlLogger();  
8.         return logger;  
9.     }  
10. }  

public abstract class AbstractLoggerCreator {
	
	//factory method
	public abstract Logger createLogger();
	
	public Logger getLogger() {
		Logger logger = new XmlLogger();
		return logger;
	}
}

Now the concrete creator class:

view plainprint?

1. public class XmlLoggerCreator extends AbstractLoggerCreator {  
2.     @Override  
3.     public Logger createLogger() {  
4.         XmlLogger logger = new XmlLogger();  
5.         return logger;  
6.     }  
7. }  

public class XmlLoggerCreator extends AbstractLoggerCreator {
	@Override
	public Logger createLogger() {
		XmlLogger logger = new XmlLogger();
		return logger;
	}
}

Finally the client code to test the pattern:

view plainprint?

1. public class FactoryMethodClient {  
2.     private void methodA(AbstractLoggerCreator creator) {  
3.         Logger logger = creator.createLogger();  
4.         logger.log("message");  
5.     }  
6.   
7.     public static void main(String[] args) {  
8.         AbstractLoggerCreator creator = new XmlLoggerCreator();  
9.         FactoryMethodClient client = new FactoryMethodClient();  
10.         client.methodA(creator);  
11.     }  
12.   
13. }  

public class FactoryMethodClient {
	private void methodA(AbstractLoggerCreator creator) {
		Logger logger = creator.createLogger();
		logger.log("message");
	}

	public static void main(String[] args) {
		AbstractLoggerCreator creator = new XmlLoggerCreator();
		FactoryMethodClient client = new FactoryMethodClient();
		client.methodA(creator);
	}

}

Downside of the pattern is that it might be over-complicated. In a lot of cases, a simple factory pattern will work fine. The FactoryMethod just allows further decoupling, leaving it to the sub-classes of the Creator to decide which type of concrete Product to create.

Data Structures - Queue

A Queue is an example of a linear data structure - a sequential
collection, and it is a FIFO structure. Anything that's inserted
first, will be the first to leave. We need to maintain two pointers,
the start and the end. An efficient implementation of Queue performs
the operations - enqueue (insert) and dequeue (remove) - in O(1) time.

Below is a sample implementation of a Queue (Java Data Structures (2nd edition))

view plainprint?

1. public class Queue {  
2.  private Object[] objArray;  
3.  private int start, end;  
4.  private boolean full;  
5.   
6.  public Queue(final int maxSize) {  
7.   objArray = new Object[maxSize];  
8.   start = end = 0;  
9.   full = false;  
10.  }  
11.   
12.  public boolean isEmpty() {  
13.   return (start == end) && !full;  
14.  }  
15.   
16.  public boolean isFull() {  
17.   return full;  
18.  }  
19.   
20.  public void insert(final Object o) {  
21.   if (!full) {  
22.    objArray[start = (++start % objArray.length)] = o;  
23.   }  
24.     
25.   
26.   if (start == end) {  
27.    full = true;  
28.   }  
29.  }  
30.   
31.  public Object remove() {  
32.   if (full) {  
33.    full = false;  
34.   } else if (isEmpty()) {  
35.    return null;  
36.   }  
37.   
38.   return objArray[end = (++end % objArray.length)];  
39.  }  
40.   
41.  public String toString() {  
42.   StringBuilder sbr = new StringBuilder();  
43.   for (int i = 0; i < objArray.length; i++) {  
44.    sbr.append(objArray[i]);  
45.   }  
46.   return sbr.toString();  
47.  }  
48. }  

public class Queue {
 private Object[] objArray;
 private int start, end;
 private boolean full;

 public Queue(final int maxSize) {
  objArray = new Object[maxSize];
  start = end = 0;
  full = false;
 }

 public boolean isEmpty() {
  return (start == end) && !full;
 }

 public boolean isFull() {
  return full;
 }

 public void insert(final Object o) {
  if (!full) {
   objArray[start = (++start % objArray.length)] = o;
  }
  

  if (start == end) {
   full = true;
  }
 }

 public Object remove() {
  if (full) {
   full = false;
  } else if (isEmpty()) {
   return null;
  }

  return objArray[end = (++end % objArray.length)];
 }

 public String toString() {
  StringBuilder sbr = new StringBuilder();
  for (int i = 0; i < objArray.length; i++) {
   sbr.append(objArray[i]);
  }
  return sbr.toString();
 }
}