黑马程序员——Java设计模式之单例模式

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

java设计模式

设计模式：解决某一类问题最行之有效的方法，java中有23种设计模式。

一个程序员对设计模式的理解：

“不懂”为什么要把很简单的东西搞得那么复杂。后来随着软件开发经验的增加才开始明白我所看到的“复杂”恰恰就是设计模式的精髓所在，我所理解的“简单”就是一把钥匙开一把锁的模式，目的仅仅是着眼于解决现在的问题，而设计模式的“复杂”就在于它是构造一个“万能钥匙”，目的是提出一种对所有锁的开锁方案。在真正理解设计模式之前我一直在编写“简单”的代码。

这个“简单”不是功能的简单，二是设计的简单。简单的设计意味着缺少灵活性，代码很钢硬，只在这个项目里有用，拿到其它的项目中就是垃圾，我将其称为“一次性代码”。

要使代码可被反复使用，就需要使用“设计模式”对代码进行设计。

设计原则（重要）：

1. 逻辑代码独立到单独的方法中，注重封装性-易读，易复用。

不要在一个方法中，写下上百行的逻辑代码。把各小逻辑代码独立出来，写于其他方法中，易读其可重复调用。

2. 写类，写方法，写功能时，应考虑其移植性，复用性：防止一次性代码。

是否可以拿到其他同类事物中应用？是否可以拿到其他系统中应用？

3. 熟练运用继承的思想：

找出应用中相同之处，且不容易发生变化的东西，把他们抽取到抽象类中，让子类去继承他们；

4. 熟练运用接口的思想：

找出应用中可能需要变化之处，把他们独立出来，不要和那些不需要变化的代码混在一起。

单例模式：解决一个类在内存中只存在一个对象

想要保证对象唯一：

1. 为了避免其他程序过多建立该类对象。先禁止其他程序建立该对象。

2. 为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。

3. 为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三步如何用代码体现？

1. 将构造函数私有化

2. 在类中创建一个本类对象

3. 提供一个方法可以获取到该对象

当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。

原则：定义单例，建议使用饿汉式

[java]  view plain  copy

 

1. //先初始化对象。  single类一进入内存，就已经创建好了对象  
2. //称为：饿汉式  
3. class Single1{  
4.     private Single1(){};  
5.       
6.     private static Single1 s = new Single1();  
7.       
8.     public static Single1 getInstance(){  
9.         return s;  
10.     }  
11. }  

[java]  view plain  copy

 

1. //对象是方法调用时，才初始化，也叫对象的延时加载  
2. //single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象  
3. //称为：懒汉式  
4. class Single2{  
5.     private static Single2 s = null;  
6.     private Single2(){}  
7.     public static  Single2 getInstance(){  
8.         if(s == null)  
9.             /* 
10.              * -->A 
11.              * -->B  多线程容易导致产生多个对象 
12.              */  
13.             s = new Single2();  
14.         return s;  
15.     }  
16. }  
17.   
18. /* 
19.  //解决方法： 
20.  class Single2{ 
21.     private static Single2 s = null; 
22.     private Single2(){} 
23.     public static  Single2 getInstance(){ 
24.         if(s == null){ 
25.             synchronized(Single2.class) 
26.             { 
27.                 if(s == null） 
28.                     s = new Single2(); 
29.             } 
30.         } 
31.         return s; 
32.     } 
33. } 
34.  */  
35.   
36. public class 设计模式 {  
37.   
38.     public static void main(String[] args) {  
39.         // TODO Auto-generated method stub  
40.         Single1 ss = Single1.getInstance();  
41.           
42.     //  Student s1 = new Student();  
43.     //  s1.setAge(30);  
44.           
45.     //  Student s2 = new Student();  
46.     //  s2.setAge(23);  
47.         Student s1 = Student.getStudentInstance();  
48.         Student s2 = Student.getStudentInstance();  
49.     }  
50.   
51. }  
52.   
53. class Student{  
54.     private int age;  
55.       
56.     //加上三步，保证类在内存中的唯一性  
57.     private static Student s = new Student();  
58.     private Student(){};  
59.     public static Student getStudentInstance(){  
60.         return s;  
61.     }  
62.       
63.     public void setAge(int age)  
64.     {  
65.         this.age = age;  
66.     }  
67.     public int getAge(){  
68.         return age;  
69.     }  
70.       
71. }  

虽然说，使用synchronized可以解决出现的问题，但是当使用了synchronized后必然导致程序运行效率的地下，所以定义单例，建议使用饿汉式。