In object-oriented programming, a singleton class is a class that can have only one object (an instance of the class) at a time.
After first time, if we try to instantiate the Singleton class, the new
variable also points to the first instance created. So whatever
modifications we do to any variable inside the class through any
instance, it affects the variable of the single instance created and is
visible if we access that variable through any variable of that class
type defined.
To design a singleton class:
- Make constructor as private.
- Write a static method that has return type object of this singleton class. Here, the concept of Lazy initialization in used to write this static method
public class Singleton {
private static final Singleton instance = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
return instance;
}
}
In terms of practical use Singleton patterns are used in logging, caches, thread pools, configuration settings, device driver objects.
Configuration File: This is another usage of Singleton
pattern because this has a performance benefit as it prevents multiple
users to repeatedly access and read the configuration file or properties
file. It creates a single instance of the configuration file which can
be accessed by multiple calls concurrently as it will provide static
config data loaded into in-memory objects. The application only reads
from the configuration file at the first time and there after from
second call onwards the client applications read the data from in-memory
objects
We can use the cache as a singleton object as it can have a global point
of reference and for all future calls to the cache object the client
application will use the in-memory object
Why can’t we use a static class instead of singleton?
- One of the key advantages of singleton over static class is that it
can implement interfaces and extend classes while the static class
cannot (it can extend classes, but it does not inherit their instance
members). If we consider a static class it can only be a nested static
class as top level class cannot be a static class. Static means that it
belongs to a class it is in and not to any instance. So it cannot be a
top level class.
- Another difference is that static class will have all its member as static only unlike Singleton.
- Another advantage of Singleton is that it can be lazily loaded whereas static will be initialized whenever it is first loaded.
- Singleton object stores in Heap but, static object stores in stack.
- We can clone the object of Singleton but, we can not clone the static class object.
- Singleton can use the Object Oriented feature of polymorphism but static class cannot.
References Used :- singleton-class by geeksforgeeks
dzone.com- singleton-design-pattern
Version :- 1.1.0
