javaSE-(设计模式)

1、什么叫设计模式：设计模式的概念首先来源于其它行业：建筑业，在早起建房子的时候，肯定是经验缺乏、显得杂乱无序的，这就会造成很多问题，在行业发展过程，通过不断的经验积累，前辈们针对这些问题提出了合理解决方案，这就是设计模式，参照设计模式往往可以解决很多问题，在计算机编程方面，也会出现类似问题，所以牛人们把这些解决问题的方案进行归类和总结，形成了面向对象编程的23种设计模式。

2、单例模式（特点）：

Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”通过使用设计模式可以让我们的代码复用性更高，可维护性更高，让你的代码写的更优雅。

一、（饿汉式）：

[java]  view plain  copy

1. public class Singleton {  
2.     private static Singleton instance = new Singleton();  
3.     private Singleton(){};  
4.     public static Singleton getInstance(){  
5.         return instance;  
6.     }  
7. }  

这个时候我们以为掌握了单例模式，其实是掌握了，但仅仅是单例设计模式的一种写法，如上写法称为”饿汉式“，因instance是静态成员变量，所以在jvm对该类加载过程中，就进行对象的实例化，所以是提前创建实例。

另外一种写法，就是在getInstance调用时才进行对象的创建，这种写法又称为”延迟加载“或者”懒汉式“。

二、懒汉式（延迟加载）。

[java]  view plain  copy

1. public class Singleton {  
2.     private static Singleton instance = null;  
3.     private Singleton(){};  
4.     public static Singleton getInstance(){  
5.         if(instance == null){  
6.             instance = new Singleton();  
7.         }  
8.         return instance;  
9.     }  
10. }  

问题：懒汉式的写法，在多线程中会出现问题，即创建多个对象，如下图所示：

[java]  view plain  copy

1. public class Singleton {  
2.     private static Singleton instance = null;  
3.     private Singleton(){};  
4.     public static Singleton getInstance(){  
5.         if(instance == null){  
6.             --> 一个A线程进入并挂起。  
7.             --> 此时一个B线程进入，这种情况会造成两个线程都会执行new Singleton操作，这样就会在内存存在多个该类对象。  
8.             instance = new Singleton();  
9.         }  
10.         return instance;  
11.     }  
12. }  

解决方案：加锁。

三、懒汉式同步锁（懒汉式线程不安全的解决方案）。

[java]  view plain  copy

1. public class Singleton {  
2.     private static Singleton instance = null;  
3.     private Singleton(){};  
4.     public static synchronized Singleton getInstance(){  
5.         if(instance == null){  
6.             instance = new Singleton();  
7.         }  
8.         return instance;  
9.     }  
10. }  

5、单例模式的使用：

如果仅仅如上面所示的方式 ，去创建这些代码是没有意义，正确使用单例模式的方式就是在原有代码上，加上这些代码。

添加单例模式前：

[java]  view plain  copy

1. public class Test {  
2.     public static void main(String[] args){  
3.         Person p1 = new Person();  
4.         p1.setName("Jack");  
5.         p1.setAge(18) ;  
6.         Person p2 = new Person();  
7.         p2.setName("David");  
8.         p2.setAge(20);  
9.           
10.         System.out.println(p1.getName() + ":" + p1.getAge());  
11.         System.out.println(p2.getName() + ":" + p2.getAge());  
12.     }  
13. }  
14.   
15. class Person{  
16.     private String name ;  
17.     private int age;  
18.           
19.     public void setName(String name){  
20.         this.name = name;  
21.     }  
22.     public String getName(){  
23.         return name;  
24.     }  
25.       
26.     public void setAge(int age){  
27.         this.age = age;  
28.     }  
29.     public int getAge(){  
30.         return age;  
31.     }  
32.       
33. }  

运行结果：

Jack:18
David:20

单例模式后：

[java]  view plain  copy

1. public class Test {  
2.     public static void main(String[] args){  
3.         Person p1 = Person.getInstance();  
4.         p1.setName("Jack");  
5.         p1.setAge(18) ;  
6.         Person p2 = Person.getInstance();  
7.         p2.setName("David");  
8.         p2.setAge(20);  
9.           
10.         System.out.println(p1.getName() + ":" + p1.getAge());  
11.         System.out.println(p2.getName() + ":" + p2.getAge());  
12.     }  
13. }  
14.   
15. class Person{  
16.     private String name ;  
17.     private int age;  
18.       
19.     private static Person instance = new Person();//2.本类中创建该类的对象  
20.     private Person(){};//1.私有构造函数  
21.     public static Person getInstance(){//3.创建一个方法，向外部提供该类的对象  
22.         return instance;  
23.     }  
24.       
25.     public void setName(String name){  
26.         this.name = name;  
27.     }  
28.     public String getName(){  
29.         return name;  
30.     }  
31.       
32.     public void setAge(int age){  
33.         this.age = age;  
34.     }  
35.     public int getAge(){  
36.         return age;  
37.     }  
38.       
39. }  

运行结果：

David:20
David:20

目的：保证了对象的唯一性