不管使用者是否需要这个对象，它都上来先给创建好这个唯一的对象。
（1）方式一：枚举类型
1 enum SingleEnum{
2 INSTANCE;
3 public static void test(){
4 //..
5 }
6 }
7
8 @Test
9 public void test1(){
10 SingleEnum s1 = SingleEnum.INSTANCE;
11 SingleEnum s2 = SingleEnum.INSTANCE;
12 System.out.println(s1 == s2); // true
13
14 SingleEnum.test();//此时并没有需要用到这个对象，但是它也创建出来了
15 }
（2）方式二
① 构造器私有化
② 用一个全局的静态的常量，来保存这个唯一的实例对象
Demo:
1 class SingleClass{
2 public static final SingleClass INSTANCE = new SingleClass();
3 private SingleClass(){
4
5 }
6 }
7
8 @Test
9 public void test(){
10 SingleClass s1 = SingleClass.INSTANCE;
11 SingleClass s2 = SingleClass.INSTANCE;
12 System.out.println(s1==s2); // true
13 }
（3）方式三
① 构造器私有化
② 用一个私有的静态的常量，来保存这个唯一的实例对象
③ 提供一个公共静态方法，来返回这个常量对象
Demo:
1 class Single{
2 private static final Single INSTANCE = new Single();
3 private Single(){
4
5 }
6 public static Single getInstance(){
7 return INSTANCE;
8 }
9 }
10
11 @Test
12 public void test(){
13 Single s1 = Single.getInstance();
14 Single s2 = Single.getInstance();
15 System.out.println(s1 == s2); // true
16 }
延迟创建对象，当使用者需要用到对象时，再创建这个对象。
（1）方式一：需要考虑线程安全问题和性能问题
Demo:
1 class LazyClass{
2 private static LazyClass instance;
3 private LazyClass(){
4
5 }
6
7 public static LazyClass getInstance(){
8 if(instance == null){//提高效率
9 synchronized(LazyClass.class){ //当前类的Class对象
10 if(instance == null){ //安全判断，线程的安全问题
11 try {
12 Thread.sleep(100);
13 } catch (InterruptedException e) {
14 e.printStackTrace();
15 }
16 instance = new LazyClass();
17 }
18 }
19 }
20 return instance;
21 }
22 }
23
24 @Test
25 public void test(){
26 LazyClass s1 = LazyClass.getInstance();
27 LazyClass s2 = LazyClass.getInstance();
28 System.out.println(s2 == s1);
29 }
（2）方式二：内部类形式
Demo:
1 class Lazy{
2 private Lazy(){
3
4 }
5
6 private static class Inner{
7 public static final Lazy INSTANCE = new Lazy();//在内部类中，创建外部类的唯一对象
8 }
9
10 public static Lazy getInstance(){
11 return Inner.INSTANCE;
12 }
13 }
原文：https://www.cnblogs.com/niujifei/p/12022757.html