Effective Java

// Singleton with static factory
public class Elvis {
private
static final Elvis INSTANCE = new Elvis();
private Elvis() { ... }
public static Elvis getInstance()
{ return INSTANCE; }
public void leaveTheBuilding() { ... }
}
All calls to 
Elvis.getInstance
return the same object reference, and no other
Elvis
instance will ever be created (with the same caveat mentioned earlier).

---

CHAPTER 2
CREATING AND DESTROYING OBJECTS
18
The main advantage of the public field approach is that the API makes it clear
that the class is a singleton: the public static field is final, so it will always contain
the same object reference. The second advantage is that it’s simpler.
One advantage of the static factory approach is that it gives you the flexibility
to change your mind about whether the class is a singleton without changing its
API. The factory method returns the sole instance, but it could be modified to
return, say, a separate instance for each thread that invokes it. A second advantage
is that you can write a 
generic singleton factory
if your application requires it
(Item 30). A final advantage of using a static factory is that a 
method reference
can
be used as a supplier, for example 
Elvis::instance
is a 
Supplier
.
Unless one of these advantages is relevant, the public field approach is preferable.
To make a singleton class that uses either of these approaches 
serializable
(Chapter 12), it is not sufficient merely to add 
implements
Serializable
to its
declaration. To maintain the singleton guarantee, declare all instance fields
transient
and provide a 
readResolve
method (Item 89). Otherwise, each time a
serialized instance is deserialized, a new instance will be created, leading, in the
case of our example, to spurious 
Elvis
sightings. To prevent this from happening,
add this 
readResolve
method to the 
Elvis
class: