Skip to content

Lazy Initialization

Singleton class can be instantiated by two methods:

Early / Eager initialization

  • In this method, class is initialized whether it is to be used or not.
  • The main advantage of this method is its simplicity.
  • Its drawback is that class is always initialized whether it is being used or not.
  • Early initialization is just reverse, you initialize a singleton upfront at the time of class loading.

Implmentation (Early)

Step 1

Create a Singleton Class.

public class SingleObject {
   //create an object of SingleObject
   private static SingleObject instance = new SingleObject();

   //make the constructor private so that this class cannot be
   private SingleObject(){}

   //Get the only object available
   public static SingleObject getInstance(){
      return instance;

   public void showMessage(){
      System.out.println("Hello World!");

Step 2

Get the only object from the singleton class.

public class SingletonPatternDemo {
   public static void main(String[] args) {
      //illegal construct
      //Compile Time Error: The constructor SingleObject() is not visible
      //SingleObject object = new SingleObject();

      //Get the only object available
      SingleObject object = SingleObject.getInstance();

      //show the message

Lazy initialization

  • In this method, class in initialized only when it is required.
  • It can save you from instantiating the class when you don’t need it.
  • Generally, lazy initialization is used when we create a singleton class.
  • Lazy initialization means that you do not initialize objects until the first time they are used.

Implmentation (Lazy)

class LazySingleObject {

    // create static object and declare it
    // the object is declared not initialized
    // it is called lazy initialization as initializaiton is done when needed, not early
    private static LazySingleObject object;

    // Make the constructor private so that the object cannot be instantiated.
    // It can only be accessed through getInstance()
    private LazySingleObject(){};

    // method to initialized and return the object of the class
    public static LazySingleObject getInstance() {
        if (object == null) {
            // if object is null, initialize
            object = new LazySingleObject();
        return object;

    public void displayMessage(){
        System.out.println("Object is instantiated");

public class LazySingletonPattern {
    public static void main(String[] args) {

        // since the constructor is private, the statement below gives error
        // LazySingleObject object = new LazySingleObject();

        // getInstance() is static, so it doesn't need any object to be initialized for it to be called
        LazySingleObject object = LazySingleObject.getInstance();