笔记：设计模式总结

一.面向对象设计原则：

1. 单一职责原则  Single Responsibility Principle

应该有且只有一个原因引起类的变更。

2. 里氏替换原则 Liskov Substitution Principle

所有引用基类的地方必须能透明地使用其子类对象。子类中方法的前置条件范围 >= 父类中被复写方法 的前置条件。

如果子类不能完整地实现父类的方法，或者父类的方法在子类中已经发生变异，则建议断开父子继承关系，采用依赖、聚集、组合等关系替换继承。

3.依赖倒置原则  Dependence Inversion Principle

模块间依赖通过接口发生，实现类之间不发生直接的依赖

接口不依赖于实现

实现依赖于接口

总而言之，就是“面向接口编程”

4.接口隔离原则  Interface Segregation Principle 

接口尽量细化，同时接口中的方法尽量少。接口尽量小、高类聚、定制服务。

5.迪米特法则、最少知识原则  Least Knowledge Principle

一个类应该对自己需要耦合或调用的类知道得最少。

类与类之间的关系是建立在类间的，而不是方法内，因此一个方法应该尽量不引入一个类中不存在的对象。

类应该尽量不要对外公布太多的public方法，应该多使用private、protected等访问权限

6.开闭原则 Open-Closed Principle

软件实体应该对扩展开放，对修改关闭。

二.最简单的设计模式

1. 单例模式 Singlton

要点：构造函数私有，只返回一个实例

public class Foo

{

    private static Foo foo = new Foo();

   

    private Foo()

    {

    }

   

    public static Foo getInstance()

    {

      return foo;

    }

   

}

在Spring中，每个Bean默认是单例的，这样可以使得Spring容器管理Bean的生命周期，决定何时创建、何时销毁、销毁时如何处理等。

例子： java.lang.Runtime#getRuntime()  

2.迭代器模式 iterater 

要点：使用迭代器代替数组循环，关键方法是 hasNext(), next(). Java 集合类中有该接口。一般很少自己写。

class Iterator

{

    private T[] foos;

    private int index;

    public  Iterator( T[] foos )

   {

       this. foos =  foos;

       index = 0;

   }

  

   public boolean hasNext()

   {

      return  index  <  foos.length;

   }

   public T next()

   {

      return  foos[index++];

   }

}

3.原型模式  Prototype

要点：就是克隆。调用 clone() 方法，要注意每一个成员对象都必须克隆一遍，不能是浅拷贝。

class A implement Clonable

{ 

    B b;

    C c;

    public A clone()

    {

        anothor = super.clone();

        anothor.b = this.b.clone();  // B is also  clonable

       another.c = this.c.clone();   // C is also  clonable

       return another;

    }

}

注意：调用clone方法，构造函数不会被执行。

4.轻量级方法 Flyweight

要点：就是缓存

Class Foo

{

    private Map map = new HashMap<S,T>();

   

    public T getFooValue(S s)

    {  

          T t =  map.get(s);

          if(t==null)

          {

              t = createNewbyKey(s);   // create a new instance of T

              map.put(s,t); 

          }

          retun t;

    }

   

}

5. 备忘录 Memento

要点：将以前的历史记录保存下来，在需要的时候恢复

6.模板方法  Template Method

要点： 父类规定流程，子类实现细节

abstract class A

{

    abstract protected void s1();

    abstract protected void s2);

    abstract protected void s3();

   public void execute()

   {

         //按照一定流程分别调用 s1();  s2();  s3();

    }

  } 

B extends A

{

      protected void s1()

   {  //实现具体的方法

    }

      protected void s2)

    {  //实现具体的方法

    }

      protected void s3()

    {  //实现具体的方法

    }

}

例子：

  java.util.Collections#sort()  

   java.io.InputStream#skip()  

  java.io.InputStream#read()  

7.适配器 Adapter

要点：消除阻抗不匹配

Class A

{

    public A(T t)

    {

    }

    public void   s1();

}

Class B

{

    A a;

   public B(T t)

    {

      a = super(t);

    }

    public void s2()

  {

      // 调用 a.s1();

  }

}

调用

B b =new B(t);

b.s2(); 

例子：  java.io.InputStreamReader(InputStream)

       java.io.OutputStreamWriter(OutputStream)

三.一般难度的设计模式

8.工厂  Factory

优点：良好封装性、扩展性；屏蔽产品类，调用者只关心产品接口，不关心产品类如何变化。

例子： java.sql.DriverManager#getConnection()  

java.sql.Connection#createStatement()

java.lang.Class#newInstance()

 

 

9.代理  Proxy

为其他对象提供一种代理以控制对这个对象的访问。许多其他模式，如状态模式、策略模式、访问者模式则在本质上在更特殊的场合采用了代理模式。

动态代理：实现阶段不用关心代理谁，而在运行阶段才制定代理哪一个对象。相对来说，自己写代理类的方式就是静态代理。

AOP 面向切面编程就是利用了动态代理机制。 

10.责任链 Chain of Responsibility

Web开发中的过滤器链： javax.servlet.Filter#doFilter()

 

11.命令  Command

在GUI开发中(Javascript \ Flex \ Swing)，点击一个按钮即触发一个命令。

如 javax.swing.Action

12.状态  State 

如  javax.faces.lifecycle.LifeCycle#execute()

 

四.较复杂的设计模式

 

13. 抽象工厂  Abstract Factpry

工厂模式的升级版。用于创建一系列产品族。

14.构建  Builder

属于创建型模式，与工厂方法相似，但是Builder模式主要功能是基本方法的调用顺序安排，也就是这些基本方法已经实现了，通俗地说就是零件的装配，顺序不同产生的对象不同；而工厂方法则重点是创建，创建零件是其主要职责，组装顺序则不是它所关心的。

其实现代码与模板方法模式相似。

例子： java.lang.StringBuilder#append()  

15.桥接  Bridge

把抽象和实现解藕，于是接口和实现可在完全独立开来。

例子：JDBC

16.组合  Composite

部分-整体模式，用户对单个对象和组合对象的使用具有一致性。

  Java的文件系统、树结构等。

17.装饰  Decorator

为一个对象动态的加上一系列的动作，而不需要因为这些动作的不同而产生大量的继承类

例子：

java.io.BufferedInputStream(InputStream)

java.util.zip.ZipOutputStream(OutputStream)

18.门面 Facade

比如Swing中的一个panel，什么东西都放在上面

19.中介 Mediator

用一个中介对象封装一系列的对象交互，中介者使得各对象不需要显示地相互作用，从而使得其耦合松散，而且可以独立地改变它们之间的交互。

MVC框架中的Controller就是中介者，也即前端控制器。

如： java.util.concurrent.Executor#execute()

 

20.观察者  Observer

就是监听器，例子比如session监听器，EJB中的Message Driven Bean等。

21.策略 Strategy

定义一组算法，将每个算法都封装起来，并且使他们之间可以互换。

如：      java.util.Comparator#compare()  

 

22.访问者  Visitor 

例子：

 javax.lang.model.element.Element 和javax.lang.model.element.ElementVisitor  

   javax.lang.model.type.TypeMirror 和javax.lang.model.type.TypeVisitor  

 23. 解释器模式  Interpreter

开发中很少使用。

五.GOF之外

24. Null Object:

这个模式用来解决如果一个Collection中没有元素的情况。

   java.util.Collections#emptyList()  

 java.util.Collections#emptyMap()  

   java.util.Collections#emptySet()