Factory Pattern

  • This pattern is used when it must be decided at run time which one of several compatible classes is to be instantiated.
  • For example, the abstract Collator class's getInstance() method returns a collation object that is appropriate for the default locale, as determined by java.util.Locale.getDefault():
  • Like other locale-sensitive classes, you can use the static factory method, getInstance, to obtain the appropriate Collator object for a given locale. 
  • The following example shows how to compare two strings using the Collator for the default locale.
  • Compare two strings in the default locale
    • Collator myCollator = Collator.getInstance();
    • if("abc", "ABC") < 0 )
    • System.out.println("abc is less than ABC");
    • else
    • System.out.println("abc is greater than or equal to ABC");

Singleton Pattern

Lazy Initialization:-The instantiation of an object can be delayed until it is actually needed.

Usage: This especially beneficial when the constructor is doing a costly job like, accessing a remote database.


This code demonstrates how the Singleton pattern can be used to create a counter to provide unique sequential numbers, such as might be required for use as primary keys in a



public class Sequence {

private static Sequence instance;

private static int counter;

private Sequence()


counter = 0; // May be necessary to obtain

// starting value elsewhere...


public static synchronized Sequence getInstance()


if(instance==null) // Lazy instantiation


instance = new Sequence();


return instance;


public static synchronized int getNext()


return ++counter;




Some things to note about this implementation:

  • Synchronized methods are used to ensure that the class is thread-safe.
  • This class cannot be subclassed because the constructor is private. This may or may not be a good thing depending on the resource being protected. To allow subclassing, the visibility of the constructor should be changed to protected.
  • Object serialization can cause problems; if a Singleton is serialized and then deserialized more than once, there will be multiple objects and not a singleton