1. 
   
2. //饿汉式
   
3. //单例模式 一个类只有一个对象
   
4. //就像音乐播放器或者迅雷
   
5. //无论打开多少次 只有一个主程序（一个实例）（梦幻就不是）
   
6. public class DemoSingleTest01 {
   
7.         public static void main(String[] args) {
   
8.                 //不能直接new
   
9.                 //无论调用多少都返回同一个静态变量
   
10.                 Single01 s1 = Single01.getInstance();
    
11.                 Single01 s2 = Single01.getInstance();
    
12.                 System.out.println(s1==s2);
    
13.                
    
14.         }
    
15. }
    
16. class Single01{
    
17. //构造方法私有化  
    
18. //        外部类不能直接调用
    
19.         private Single01(){
    
20.         }
    
21.         //声明一个静态变量 是当前对象 并且也是被private修饰
    
22.         //private修饰目的是为了避免恶意置空
    
23.         private static Single01 instance = new Single01();
    
24.         //提供公开的访问方式
    
25.         public static Single01 getInstance() {
    
26.                 return instance;
    
27.         }
    
28.        
    
29. }

复制代码

饿汉式就是上来就new对象
懒汉式是能不new就不new
如果记不住的话
可以理解成 两个单身的人 一个很懒 找对象都懒得找
另一个人反而“饿”的不行了 离不开对象。。
下面是懒汉式的代码

1. 
   
2. 
   
3. //懒汉式
   
4. public class DemoSingleTest02 {
   
5.         public static void main(String[] args) {
   
6.                 Single02 s1= Single02.getInstance();
   
7.                 Single02 s2= Single02.getInstance();
   
8.                 System.out.println(s1==s2);
   
9.         }
   
10. }
    
11. class Single02{
    
12.         private Single02(){
    
13.         }
    
14.         private static Single02 instance;
    
15.         public static Single02 getInstance() {
    
16.                 if(instance==null){
    
17.                         instance = new Single02();
    
18.                 }
    
19.                 return instance;
    
20.         }
    
21.        
    
22. }

复制代码

忘了说了 以上两者都是单例设计模式