23种设计模式UML类图

一、设计模式

设计模式就是在特定环境下，对特定问题的惯用解决之道

1.Singeton单例模式

创建单个实例，只能从众所周知的地方当问它。

2.Adapter适配器模式

适用性：为了复用一个类，但是它的接口不符合要求

3.Template method模版方法

实用性：实现一个算法的不变的部分，将可变的行为留给子类

templateMethod前加final，防止其在子类中实现

4.迭代器模式

提供一种顺序访问一个聚合中各个元素，而有不暴露该对象的内部表示

5.Factory Method工厂方法

父类提供创建对象的接口，子类决定创建哪个对象

实用性：一个类希望由子类来指定所创建的对象

 

6.Prototype原型

通过拷贝原型来创建新的对象

7.Builder

将对象的表示和创建分离，使同样的过程可以有不同的表示。

参考：http://blog.youkuaiyun.com/ahangliu/article/details/7180488

8.Abstract factory pattern抽像工厂模式

提供创建对象的接口，而无需执行他们具体的类

 

工厂方法模式和抽象工厂模式的区别

【1】工厂方法是极端情况下的抽象工厂模式【2】工厂方法是用来创建一个产品、而抽象工厂模式是创建多个

简而言之
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。

9.bridge桥

 

将抽象部分与实现部分分离，使两者都可变化

10.Decorater装饰模式

动态地给一个对象添加一些额外的职责

Java.io包中的各种Reader就是装饰模式

11.State Pattern状态模式

对象在内部状态改变时改变它的行为。适用于对象的行为取决于他的状态

12.观察者模式

定义对象中的一种一对多的依赖关系，当一个对象的状态发生变化时，与之关联的对象得到通知并自动更新。

比如按钮的事件响应

13.策略模式

定义一些列算法封装起来，能够相互替换。

14.Conposite 组合模式

画中有画，使单个对象和组合对象的使用具有一致性：比如OS中的目录，绘图系统

 

15.memento备忘录模式

可以做到undo redo history snashot

在不破坏封装的情况下，捕获一个对象的内部状态并保存，可以在以后恢复到原来的状态

 

 

public class Memento {
   private String state;

   public Memento(String state){
      this.state = state;
   }

   public String getState(){
      return state;
   }	
}

public class Originator {
   private String state;

   public void setState(String state){
      this.state = state;
   }

   public String getState(){
      return state;
   }

   public Memento saveStateToMemento(){
      return new Memento(state);
   }

   public void getStateFromMemento(Memento Memento){
      state = Memento.getState();
   }
}

import java.util.ArrayList;
import java.util.List;

public class CareTaker {
   private List<Memento> mementoList = new ArrayList<Memento>();

   public void add(Memento state){
      mementoList.add(state);
   }

   public Memento get(int index){
      return mementoList.get(index);
   }
}

 

public class MementoPatternDemo {
   public static void main(String[] args) {
      Originator originator = new Originator();
      CareTaker careTaker = new CareTaker();
      originator.setState("State #1");
      originator.setState("State #2");
      careTaker.add(originator.saveStateToMemento());
      originator.setState("State #3");
      careTaker.add(originator.saveStateToMemento());
      originator.setState("State #4");

      System.out.println("Current State: " + originator.getState());		
      originator.getStateFromMemento(careTaker.get(0));
      System.out.println("First saved State: " + originator.getState());
      originator.getStateFromMemento(careTaker.get(1));
      System.out.println("Second saved State: " + originator.getState());
   }
}

 

 

 

 

 

 

 

 

 

16.chain of responsebility责任链

 

public abstract class Handler {
    //下一级责任链
    public Handler handler;
    //设置下一级责任链
    public void setSuccessor(Handler handler){
        this.handler=handler;
    }
    public abstract void request(int request);
}

public class ConcreteHandler1 extends Handler {
    @Override
    public void request(int request) {
        if(request<10){
            System.out.println("我是handler1，我处理了请求："+request);
        }else {
            this.handler.request(request);
        }
    }
}

public class ConcreteHandler2 extends Handler {
    @Override
    public void request(int request) {
        if(request>10){
            System.out.println("我是handler2，我处理了请求："+request);
        }else {
            System.out.println("请求"+request+"没人能处理");
        }
    }
}

public class Client {
    public static void main(String[] args) {
               //创建处理器
        Handler handler1=new ConcreteHandler1();
        Handler handler2=new ConcreteHandler2();
               //客户端创建处理器的关联，形成链
        handler1.setSuccessor(handler2);
               //创建任务，此处为一些数字，不同大小，处理器处理结果不同
        int[] requests={4,10,59,2,16};
               //调用处理器处理        
        for(int request:requests){
            handler1.request(request);
        }
    }
}

 

 

 

 

 

 

 

 

 

 

 

 

 

17.facade pattern外观模式

为一组接口提供一个一致的界面

18.mediator patther中介模式

定义为一个接口可以与各同事通信

19.flyweight 享元

当需要多个对象实例的时候，会进行很多次new，可以直接使用现有的对象。

比如文档编辑中的字符，每一个字符为一个对象，则相同字符可以共享对象。

20proxy代理

为其他对象提供一个代理以控制对这个对象的访问

保护代理

21.command模式命令模式

将一个请求封装为一个对象，可用不同的请求对客户进行参数化

适用性：向对象提交请求，但不知道对象的任何信息。

 

// Command pattern -- Structural example   
using System; 
 
// "Command" 
abstract class Command 
{ 
  // Fields 
  protected Receiver receiver; 
 
  // Constructors 
  public Command( Receiver receiver ) 
  { 
    this.receiver = receiver; 
  } 
 
  // Methods 
  abstract public void Execute(); 
} 
 
// "ConcreteCommand" 
class ConcreteCommand : Command 
{ 
  // Constructors 
  public ConcreteCommand( Receiver receiver ) : 
    base ( receiver ) {} 
 
  // Methods 
  public override void Execute() 
  { 
    receiver.Action(); 
  } 
} 
 
// "Receiver" 
class Receiver 
{ 
  // Methods 
  public void Action() 
  { 
    Console.WriteLine("Called Receiver.Action()"); 
  } 
} 
 
// "Invoker" 
class Invoker 
{ 
  // Fields 
  private Command command; 
 
  // Methods 
  public void SetCommand( Command command ) 
  { 
    this.command = command; 
  } 
 
  public void ExecuteCommand() 
  { 
    command.Execute(); 
  } 
} 
 
/// <summary> 
///  Client test 
/// </summary> 
public class Client 
{ 
  public static void Main( string[] args ) 
  { 
    // Create receiver, command, and invoker 
    Receiver r = new Receiver(); 
    Command c = new ConcreteCommand( r ); 
    Invoker i = new Invoker(); 
 
    // Set and execute command 
    i.SetCommand(c); 
    i.ExecuteCommand(); 
  } 
}

 

 

 

 

 

 

22.interprreter解释器模式

23.visitor模式

将对一个对象的相关操作封装在一个类中

public class ListVisitor extends Visitor {
    private String currentdir = "";                         // 現在注目しているディレクトリ名
    public void visit(File file) {                  // ファイルを訪問したときに呼ばれる
        System.out.println(currentdir + "/" + file);
    }
    public void visit(Directory directory) {   // ディレクトリを訪問したときに呼ばれる
        System.out.println(currentdir + "/" + directory);
        String savedir = currentdir;
        currentdir = currentdir + "/" + directory.getName();
        Iterator it = directory.iterator();
        while (it.hasNext()) {
            Entry entry = (Entry)it.next();
            entry.accept(this);
        }
        currentdir = savedir;
    }
}

public class File extends Entry {
    private String name;
    private int size;
    public File(String name, int size) {
        this.name = name;
        this.size = size;
    }
    public String getName() {
        return name;
    }
    public int getSize() {
        return size;
    }
    public void accept(Visitor v) {
        v.visit(this);
    }
}

 

二、设计模式总结

1.创建型模式

（1）Sington模式解决创建对象个数问题。除了singleton，其他创建这模式解决的都是由new所带来的耦合关系

（2）factory method和abstract method，Builder都需要一个额外的工厂类来负责易变对象的创建

（3）prototype是通过原型来克隆对象

当遇到易变类时，首先从factory method开始，当遇到更复杂变化在考虑重构为其他三种工厂模式

2.结构型模式

（1）Adapter注重转换接口

（2）Bridge注重抽象与实现分离，支持多维度变化

（3）Composite，注重统一接口，将单个对象接口与多个对象接口统一

（4）Decorate在不影响对象封装的情况下扩展功能

（5）facade注重简化接口

（6）flyweight注重保留接口，在内部使用共享技术对对象存储优化

（7）proxy注重假借接口，通过添加中间层增加灵活性。

3.行为模式

（1）tmplate method模式封装算法结构，支持算法步骤变化

（2）strategy注重疯赚算法，支持算法的变化

（3）state模式注重封装与状态相关的行为，支持状态的变化

（4）memento模式注重封装对象状态变化，支持状态的保存和恢复

（5）mediator注重封装对象间的交互，支持对象交互的变化

（6）chain of responsebility注重封装对象责任，支持责任的变化

（7）command将请求封装为对象，支持请求的变化

（8）iterator注重封装集合对象内部结构，支持集合的变化

（9）interpreter注重封装特定领域变化，支持领域问题的频繁变化

（10）Oberver模式注重封装对象通知，支持通信对象的变化

（11）Visitor模式注重封装对象操作变化，支持在运行时为类层次结构动态添加新的操作。

4.Mediator与facade的区别与联系

（1）都用于连接多个类，简化类之间的联系

（2）facade将大系统藏在后面，由自己作为一个通用的接口，使用者不用关心具体类，只要与facade接口交互

（3）mediator是将系统的不同模块连接起来，使用者是系统的各个模块，他的目的是降低系统各个模块之间的依赖关系

5.抽象工厂类与工厂方法类的区别与联系

（1）工厂方法类是抽象工厂类的极端情况，抽象工厂类是工厂方法的一般化情况

（2）工厂方法简历一个产品的等级结构，抽象工厂类建立多个产品的等级结构

（3）工厂方法通常只有一个方法，而抽象工厂类往往有很多个方法

（4）工厂方法只有一个抽象产品，而抽象工厂有多个抽象产品