A singleton is simply a class that is instantiated exactly once.
Before release 1.5, there were two ways to implement singletons. Both are based on keeping the constructor private and exporting a public static member to provide access to the sole instance.
In one approach, the member is a final field:
The main advantage of the public field approach is that the declarations make it clear that the class is a singleton: the public static field is final, so it will always contain the same object reference. The private constructor can be called only once, to initialize the public static final field Singleton.INSTANCE. Singleton instance will exist once the Singleton class is initialized—no more, no less. However, a privileged client can invoke the private constructor using Reflection by AccessibleObject.setAccessible(true) method.
In the second approach to implementing singletons, the public member is a static factory method:
One advantage of the factory-method approach is that it gives you the flexibility to change your mind about whether the class should be a singleton without changing its API. The factory method returns the sole instance but could easily be modified to return, say, a unique instance for each thread that invokes it. A second advantage, concerning generic types.
To make a singleton class that is implemented using either of the previous approaches serializable, it is not sufficient merely to add implements Serializable to its declaration.
Each time a serialized instance is deserialized, a new instance will be created. To maintain the singleton guarantee, you have to declare all instance fields transient and provide a readResolve method.
In Java, a privileged client can invoke the private constructor using Reflection by AccessibleObject.setAccessible(true) method and we can instantiate the Singleton class again. To avoid it, we can use an enum based approach.
Singleton using enum
As of release 1.5, there is a third approach to implementing singletons. This approach is functionally equivalent to the public field approach, except that it is more concise, provides the serialization machinery for free, and provides the guarantee against multiple instantiations, even in the face of sophisticated serialization or reflection attacks.
Enum is thread-safe which helps us to avoid double checking (=less code for better results).
While this approach has yet to be widely adopted, a single-element enum type is the best way to implement a singleton.
And this can be called from clients,