Sometimes it is important to have only one instance of a class. Singleton Pattern means that a class is responsible to instantiate itself, so that it can make sure it creates no more than one instance. In the same time, it should provide a global access to that instance.

*Something Important:

1. A static member in the “Singleton” class(Since the getInstance method is static, the instance should be static)

2. A private constructor (so that only the class itself can instantiate an instance)

3. A static public method that returns a reference to the static member

There are two main kinds of implementation of Singleton Pattern.

1. Lazy Instantiation

public class Singleton {
	private static Singleton instance = null;
	private Singleton(){

	}
	public static synchronized Singleton getInstance(){
		if(instance==null){
			instance = new Singleton();
		}
		return instance;
	}

        public void doSomething() {
		System.out.println("doSomething(): Singleton does something!");
	}

}

2. Early Instantiation

//Early instantiation using implementation with static field.
class Singleton {
	private static Singleton instance = new Singleton();

	private Singleton() {
		System.out.println("Singleton(): Initializing Instance");
	}

	public static Singleton getInstance() {
		return instance;
	}

	public void doSomething() {
		System.out.println("doSomething(): Singleton does something!");
	}
}

Protected constructor

It is possible to use a protected constructor to in order to permit the subclassing of the singleton. This techique has 2 drawbacks that makes singleton inheritance impractical:
1.  If the constructor is protected, it means that the class can be instantiated by calling the constructor from another class in the same package. A possible solution to avoid it is to create a separate package for the singleton.
2. In order to use the derived class all the getInstance calls should be changed in the existing code from Singleton.getInstance() to NewSingleton.getInstance().

Share