//: c01:SingletonPattern.java
// The Singleton design pattern: you can
// never instantiate more than one.

// Since this isn't inherited from a Cloneable
// base class and cloneability isn't added,
// making it final prevents cloneability from
// being added through inheritance:
final class Singleton {
  private static Singleton s = new Singleton(47);
  private int i;
  private Singleton(int x) { i = x; }
  public static Singleton getReference() { 
    return s; 
  }
  public int getValue() { return i; }
  public void setValue(int x) { i = x; }
}

public class SingletonPattern {
  public static void main(String[] args) {
    Singleton s = Singleton.getReference();
    System.out.println(s.getValue());
    Singleton s2 = Singleton.getReference();
    s2.setValue(9);
    System.out.println(s.getValue());
    try {
      // Can't do this: compile-time error.
      // Singleton s3 = (Singleton)s2.clone();
    } catch(Exception e) {
      e.printStackTrace(System.err);
    }
  }
} ///:~

SingletonPattern.java always creates an object, even if it’s never used. Modify this program to use lazy initialization, so the singleton object is only created the first time that it is needed.

使用lazy initialization在第一次调用getReference()是创建对象

public static Singleton getReference() { 
  return s; 
}
改为：
public static Singleton getReference() { 
  if(s==null){
     s = new Singleton(47);
  }
  return s; 
}

public class LazySingleton {

  private static LazySingleton lazy = null;
  private int i;
  public LazySingleton() {
  }
  private LazySingleton(int x)
  {
      i=x;
  }

  public static LazySingleton getInstance()
  {
      if(lazy==null)
      {
          lazy = new LazySingleton(47);
      }
      return lazy;
  }

  public int getValue()
  {
      return i;
  }
  public void setValue(int x)
  {
      i = x;
  }

}