Singleton design pattern in Java
In object-oriented programming, the Singleton pattern exerts its influence by confining the instantiation of a class and assuring the exclusive existence of a solitary instance within the Java Virtual Machine (JVM). Put simply, this pattern demands that a class guarantees the creation of just a solitary instance, serving as a unified entity accessible by all other classes.
Usage of Singleton Pattern
When the requirement arises to guarantee the presence of a single instance of an object accessible to multiple other classes, the utilization of the Singleton pattern becomes advantageous.
- Singleton Pattern can saves memory because object is not created at each request.
- Provide a global point of access to the object.
- Allow multiple instances in the future without affecting a singleton class's clients.
How to create Singleton design pattern?
In order to create a Singleton Pattern, you need the following:
- Static member: It gets memory only once because of static, it contains the instance of the Singleton class.
- Private constructor: It will prevent to instantiate the Singleton class from outside the class.
- Static factory method: It provides the global point of access to the Singleton object and returns the instance to the caller.
In the SingletonClass, first time when we request first time call getInstance() method, it creates an object of the class with name sInstance and return it to the variable.
In the SingletonClass, the initial invocation of the getInstance() method results in the creation of an object named sInstance within the class, which is subsequently returned and assigned to the variable.
As sInstance is declared as static, it undergoes a transformation from a null value to an instantiated object during the initial invocation of the getInstance() method. Subsequent calls to getInstance() will detect that sInstance is no longer null, and thus, the existing object will be returned to the variable instead of creating a new instance of the SingletonClass.
Within the main method, when the singleton class is instantiated using the static method getInstance(), three objects obj1, obj2, and obj3 are created. However, in reality, obj2 and obj3 are assigned references to the same object as obj1. As a result, any modifications made to the variables of obj1 will be reflected when accessing the variables of obj2 and obj3. Similarly, changes made to the variables of obj3 will be observed when accessing the variables of obj1 and obj2, due to their shared reference to the same underlying object.
Difference between Normal class and Singleton class
There is a distinction in the instantiation process between a normal class and a singleton class.
In a normal class, object instantiation is typically performed using a constructor. You can create multiple instances of the class by invoking the constructor with the new keyword, allowing you to have multiple independent objects of that class.
On the other hand, a singleton class enforces the presence of only a single instance throughout the application. Instead of directly calling the constructor, you use a specialized method, often named getInstance(), to retrieve the sole instance of the class. This method is responsible for ensuring that only one instance is created and returned, regardless of the number of times it is invoked.
The use of the getInstance() method in a singleton class allows for centralized control over the object's creation, ensuring that multiple instances are not inadvertently created. This design pattern is often employed when there is a need to have a single, shared instance that can be accessed globally within the application.
Difference between static class and singleton pattern
- Singleton objects are stored in Heap, but static objects are stored in stack.
- We can clone the singleton object, but we cannot clone the static class object .
- Singleton classes follow the OOP concepts), static classes do not.
- You can create one instance of the object and reuse it whereas you cannot create the instance of static class.
The Singleton design pattern in Java ensures that only one instance of a class is created and provides a global point of access to that instance.