1. /*
   
2. 设计模式：解决某一类问题最行之有效的方法。
   
3. java中23种设计模式
   
4. 单例设计模式：解决一个类在内存中只存在一个对象。
   
5. */
   
6. 
   
7. /*
   
8. 1，为了避免其他程序过多简历该类对象，先禁止其他程序建立该对象。
   
9. 2，还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象。
   
10. 3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
    
11. 
    
12. 代码体现：
    
13. 1，将构造函数私有化。
    
14. 2，在类中创建一个本类对象。
    
15. 3，提供方法可以获取到该对象。
    
16. */
    
17. class Single_1     //饿汉式
    
18. {
    
19.         private int num;
    
20.        
    
21.         public void setNum(int num)
    
22.         {
    
23.                 this.num = num;
    
24.         }
    
25.         public int getNum()
    
26.         {
    
27.                 return this.num;
    
28.         }
    
29.         private Single_1(){}
    
30.         private static Single_1 s = new Single_1();
    
31. 
    
32.         public static Single_1 getInstance()
    
33.         {
    
34.                 return s;
    
35.         }
    
36. }
    
37. 
    
38. class Single_2     //懒汉式
    
39. {
    
40.         private int num;
    
41.        
    
42.         public void setNum(int num)
    
43.         {
    
44.                 this.num = num;
    
45.         }
    
46.         public int getNum()
    
47.         {
    
48.                 return this.num;
    
49.         }
    
50.         private Single_2(){}
    
51.         private static Single_2 s = null;
    
52. 
    
53.         public static Single_2 getInstance()
    
54.         {
    
55.                 if(s == null)
    
56.                 {
    
57.                         synchronized(Single_2.class)
    
58.                         {
    
59.                                 if(s == null)
    
60.                                         s = new Single_2();
    
61.                         }
    
62.                 }               
    
63.                 return s;
    
64.         }
    
65. }
    
66. 
    
67. class SingleDemo
    
68. {
    
69.         public static void main(String[] arg)
    
70.         {
    
71.                 Single_1 s1 = Single_1.getInstance();
    
72.                 Single_1 s2 = Single_1.getInstance();
    
73.                 System.out.println(s2.getNum());
    
74.                 s1.setNum(30);
    
75.                 System.out.println(s2.getNum());
    
76.                 Single_2 s3 = Single_2.getInstance();
    
77.                 Single_2 s4 = Single_2.getInstance();
    
78.                 System.out.println(s4.getNum());
    
79.                 s3.setNum(30);
    
80.                 System.out.println(s4.getNum());
    
81.         }
    
82. }

复制代码

懒汉式的双检测性能不好，你可以考虑一下静态内部类，也可以实现单例

我也看到这了，觉得好奇妙啊