设计模式--浅谈

设计模式

设计模式：解决某一类问题最有效的方法。

设计模式主要分三个类型：

1.创建型

2.结构型

3.行为型

java中23种设计模式

一、创建型

1.Singleton（单例模式）：保证一个类中有一个实例，并提供一个访问它的全局访问点。

2.Abstract Factory（抽象工厂）：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。

3.Factory Method（工厂方法）：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。

4.Builder（建造模式）：将一个复杂对象的构建与它的表示相分离，使得同样的构建过程可以创建不同的表示。

5.Prototype（原型模式）：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。

二、结构型

6.Composite（组合模式）：将对象组合成树形结构以表示部分整体的关系，Composite使得用户对单个对象和组合对象的使用具有一致性。

7.Facade（外观模式）：为子系统中的一组接口提供一致的界面，Facade提供了高层接口，这个接口使得子系统更容易使用。

8.Proxy（代理模式）：为其他对象提供一种代理以控制对这个对象的访问。

9.Adapter（适配器模式）：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

10.Decorator（装饰模式）：动态地给一个对象增加一些额外的职责，就增加的功能来说，Decorator模式相比生成子类更加灵活。

11.Bridge（桥模式）：将抽象部分与它的实现部分相分离，使他们可以独立的变化。

12.Flyweight（享元模式）：运用共享技术有效的支持大量细粒度的对象，它适合用于当大量物件只是重复因而导致无法令人接受的使用大量内存。

三、行为型

13.Iterator（迭代器模式）：提供一个方法，顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。

14.Observer（观察者模式）：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。

15.Template Method（模版方法）：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，Template Method使得子类可以不改变一个算法的结构既可以重定义该算法的某些特定步骤。

16.Command（命令模式）：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。

17.State（状态模式）：允许对象在其内部状态改变时改变它的行为，对象看起来似乎改变了它的类。

18.Strategy（策略模式）：定义一系列的算法，把它们一个个封装起来，并使它们可以互相替换，本模式使得算法可以独立于使用它们的客户。

19.China of Responsibility（职责链模式）：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。

20.Mediator（中介者模式）：用一个中介对象封装一些列的对象交互。

21.Visitor（访问者模式）：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作。

22.Interpreter（解释器模式）：给定一个语言，定义它的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

23.Memento（备忘录模式）：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

单例设计模式

解决的问题：保证一个类在内存中对象的唯一性。

例如：多个程序读取一个配置文件时，建议将配置文件封装成对象，这样会方便操作其中数据。但是，又要保证多个程序读到的是同一个配置文件对象，这就需要该配置文件对象在内存中是唯一的了。

如何保证对象唯一性呢？

思想：

1.不让其它程序创建该类对象

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

3.对外提供一个公有方法，让其它程序获取这个对象

步骤：

1.因为创建对象都需要构造函数初始化，所以只要将本类中的构造函数私有化，其它程序就无法在创建该类对象了。

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

3.定义一个方法，返回该对象。让其它程序可以通过这个方法就得到本类对象。(作用：可控)

代码体现：

1.私有化构造函数 private 类名(){}

2.创建私有并静态的本类对象 private static类名 s = new类名();

3.定义公有并静态的方法，返回该对象 public static返回值(类类型)方法名()｛return s;｝

单例设计模式使用的注意

1.不要使用单例模式存取全局变量。这违背了单列模式的用意，最好放到对应类的静态成员中。

2.不要将数据库连接做成单例，因为一个系统可能与数据库有多个连接，并且在有连接池的情况下，应当尽可能及时释放连接。

   单例设计模式由于使用静态成员存储类实例，所以可能会造成资源无法及时释放。

单例设计模式分为两种表现形式

单例设计模式——饿汉式

[java]  view plain copy

1. public class Single{      
2.     private Single(){}//私有化构造函数  
3.     private static Single s = new Singl();//私有并静态本类对象  
4.     public static Single getInstance(){//定义公有并静态的方法，返回本类对象  
5.         return s;  
6.     }  
7. }  

特点：Single类一进入内存，就已经创建好了对象。

好处：线程安全。

缺点：效率比较低，因为一开始就要加载类new一个对象。

 

单例设计模式——懒汉式

懒汉式：对象是方法被调用时才初始化，也叫对象的延迟加载。

特点：Single类进入内存时，对象还没有存在，只有调用了所提供的方法，才建立对象。

(1).缺点：有多个线程访问时会不安全，返回的会是不同对象。

[java]  view plain copy

1. public class Single{  
2.     private Single(){}  
3.     private static Single s = null;  
4.     public static Single getInstance(){  
5.         If(s==null)  
6.             s = new Single();  
7.         return s;   
8.     }  
9. }  

(2).改良第一种方法：加一个锁（synchronized）。

    缺点：虽然安全了，但效率非常低，因为在同一时间只有一个线程能访问，同时返回一个对象。

 

[java]  view plain copy

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

(3).改良第二种方法：用双重判断。  线程安全，效率高，可以有多个线程访问。

[java]  view plain copy

1. public class Single{  
2.     private Single(){}  
3.     private static Single s = null;  
4.     public static Single getInstance(){  
5.         if (s == null) {  
6.             synchronized (Single.class) {  
7.                 if (s == null) {   
8.                     s = new Single();  
9.                 }           }  
10.         }  
11.         return s;  
12.     }  
13. }  

 

 

总结：

            在实际开发中常用的是饿汉式，因为如果解决了懒汉式中的问题后，代码的复杂程度提高，所以建立单例时建议用饿汉式。