Difference Between Singleton Pattern and Static Class in Java

In Java, the Singleton pattern and static classes are used for managing class instances and functionality, but they serve distinct purposes and possess different characteristics. Understanding the differences between the Singleton pattern and static classes is crucial for designing and implementing the appropriate solution for a given scenario.

Singleton Pattern:

The Singleton pattern in Java is a design pattern that guarantees the existence of only one instance of a class and provides a centralized access point to that instance. It is used when there should be exactly one instance of a class available to all parts of the application, and the instance needs to be easily accessible. The Singleton pattern in Java involves the creation of a class with a private constructor, which prevents direct instantiation of multiple instances. Instead, a static method is provided to access and return the single instance of the class. The Singleton pattern can have both static and instance members, allowing flexibility in its implementation. It is commonly used when centralized control over a shared resource or state is required.

Filename: SingletonExample.java

class SingletonEager {
    // Eager initialization
    private static SingletonEager instance = new SingletonEager();

    private SingletonEager() {}

    public static SingletonEager getInstance() {
        return instance;
    }
}

class SingletonLazy {
    private static SingletonLazy instance;

    private SingletonLazy() {}

    public static SingletonLazy getInstance() {
        if (instance == null) {
            // Lazy initialization
            instance = new SingletonLazy();
        }
        return instance;
    }
}

class SingletonSynchronizedMethod {
    private static SingletonSynchronizedMethod instance;

    private SingletonSynchronizedMethod() {}

    public static synchronized SingletonSynchronizedMethod getInstance() {
        if (instance == null) {
            // Lazy initialization with the synchronized method
            instance = new SingletonSynchronizedMethod();
        }
        return instance;
    }
}

class SingletonSynchronized {
    private static SingletonSynchronized instance;

    private SingletonSynchronized() {}

    public static SingletonSynchronized getInstance() {
        if (instance == null) {
            synchronized (SingletonSynchronized.class) {
                if (instance == null) {
                    // Lazy initialization with double-checked locking
                    instance = new SingletonSynchronized();
                }
            }
        }
        return instance;
    }
}

public class SingletonExample {
    public static void main(String[] args) {
        // Creating instance using SingletonEager class
        SingletonEager instance1 = SingletonEager.getInstance();
        System.out.println(instance1 + " : Singleton Eager initialization");

        // Creating instance using SingletonLazy class
        SingletonLazy instance2 = SingletonLazy.getInstance();
        System.out.println(instance2 + " : Singleton Lazy initialization");

        // Creating instance using SingletonSynchronizedMethod class
        SingletonSynchronizedMethod instance3 = SingletonSynchronizedMethod.getInstance();
        System.out.println(instance3 + " : Synchronized Singleton (Method)");

        // Creating instance using SingletonSynchronized class
        SingletonSynchronized instance4 = SingletonSynchronized.getInstance();
        System.out.println(instance4 + " : Synchronized Singleton (Double-Checked Locking)");
    }
}

Output:

SingletonEager@19469ea2 : Singleton Eager initialization
SingletonLazy@2f2c9b19 : Singleton Lazy initialization
SingletonSynchronizedMethod@1c20c684 : Synchronized Singleton (Method)
SingletonSynchronized@548c4f57 : Synchronized Singleton (Double-Checked Locking)

Static class

A static class is a class that contains only static members. All class instances share static members, and subclasses cannot override them.

Filename: OuterClass.java

class OuterClass {
    static int myVariable = 32;

    // Static method in the outer class
    public static void display() {
        System.out.println("Value of myVariable: " + myVariable);
    }

    // Static inner class
    static class InnerClass {
        InnerClass() {
            System.out.println("It is the Inner Class Constructor");
            System.out.println("Value of myVariable from inside Inner Class: " + myVariable);
        }
    }

    // Main method of the program
    public static void main(String[] args) {
        // Accessing the static variable of the outer class
        System.out.println("Value of myVariable: " + OuterClass.myVariable);

        // Calling the static method of the outer class
        OuterClass.display();

        // Creating an object of the static inner class
        OuterClass.InnerClass object = new OuterClass.InnerClass();
    }
}

Output:

Value of myVariable: 32
Value of myVariable: 32
It is the Inner Class Constructor
Value of myVariable from inside Inner Class: 32

Difference Between Singleton Pattern and Static Class

Feature	Singleton Pattern	Static Class
Definition	A design pattern that ensures that only one instance of a class exists	A class that contains only static members
Creation	The instance is created using a private constructor	The instance is created when the class is loaded
Access	The instance is accessed using a static method	The instance is accessed directly
Inheritance	The class can be inherited	The class cannot be inherited
Polymorphism	The class can be used polymorphically	The class cannot be used polymorphically
Thread safety	The instance is thread-safe	The instance is not thread-safe
Testability	The class is easy to test	The class is difficult to test