@TOC

行为型模式

1.观察者模式

一句话：各大语言的监听模式算是观察者模式吧，注册监听事件属于“借钱要债的名单注册”，触发事件属于“还钱操作”。

public class ObserverPattern{
   public static  void main(String[] args){
      debit zhangSan = new ZhangSan();
      zhangSan.borrow(new Wangwu());
      zhangSan.borrow(new ZhaoSI);
     //张三判断自己状态改变，自己有钱了，
      zhangSan.notifyCredits();
   }
}
interface Debit{
  void borrow(Credit credit);
  void notifyCredits();
}
 
class ZhangSan implementd debit{
  private List<Credit>allCredits = new ArrayList<>();
  private Integer state = 0;//1表示有钱
  public void  borrow(Credit credit){
      allCredits.add(credit);
 }
 public void notifyCredits(){
   allCredits.forEach(credit -> credit.takeMoney());
 } 
}
 
}
interface Credit{
  void takMoney();
}
 
class Wangwuimplementd  Credit{
 void takMoney(){
      sout(还钱了)
  }
}
class ZhaoSi implementd  Credit{
 void takMoney(){
  sout(还钱了)
 }
}

Debit:主体对象，负责调用和通知
Credit：观察者

2.状态模式

/**
 * 抽象状态类
 * @author gh
 *
 */public abstract class State {
public abstract void Handle(Context context);
}
public class ConcreteStateA extends State{
    @Override
    public void Handle(Context context) {
        context.setState(new ConcreteStateB()); //设置A的下一个状态是B
    }
 }
class ConcreteStateB extends State{
    @Override
    public void Handle(Context context) {
        context.setState(new ConcreteStateA()); //设置B的下一个状态是A
    }
   }
/**
 * 定义当前的状态
 * @author gh
 *
 */public class Context {
    State state;
    public Context(State state) { //定义Context的初始状态
        super();
        this.state = state;
    }
    public State getState() {
        return state;
    }
    public void setState(State state) {
        this.state = state;
        System.out.println("当前状态为"+state);
    }
    public void request(){
        state.Handle(this); //对请求做处理并且指向下一个状态
    }}

3. 策略模式

类图和状态一样，但是不同的是：

状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。

public interface QuackBehavior {
    void quack();}
public class Quack implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("quack!");
    }}
public class Squeak implements QuackBehavior{
    @Override
    public void quack() {
        System.out.println("squeak!");
    }}
public class Duck {

    private QuackBehavior quackBehavior;

    public void performQuack() {
        if (quackBehavior != null) {
            quackBehavior.quack();
        }
    }

    public void setQuackBehavior(QuackBehavior quackBehavior) {
        this.quackBehavior = quackBehavior;
    }}
public class Client {

    public static void main(String[] args) {
        Duck duck = new Duck();
        duck.setQuackBehavior(new Squeak());
        duck.performQuack();
        duck.setQuackBehavior(new Quack());
        duck.performQuack();
    }}
squeak!
quack!

4. 责任链模式

5. 模板方法设计模式

6. 命令设计模式

　命令模式是对命令的封装。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。
每一个命令都是一个操作：请求的一方发出请求要求执行一个操作；接收的一方收到请求，并执行操作。命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否被执行、何时被执行，以及是怎么被执行的。MVC模式

1.接受者角色类
public class Receiver {
    /**
     * 真正执行命令相应的操作
     */
    public void action(){
        System.out.println("执行操作");
    }
}
2.	抽象命令角色类

public interface Command {
    /**
     * 执行方法
     */
    void execute();
}
3.	具体命令角色类
public class ConcreteCommand implements Command {
    //持有相应的接收者对象
    private Receiver receiver = null;
    /**
     * 构造方法
     */
    public ConcreteCommand(Receiver receiver){
        this.receiver = receiver;
    }
    @Override
    public void execute() {
        //通常会转调接收者对象的相应方法，让接收者来真正执行功能
        receiver.action();
    }

}
4.	请求者角色类

public class Invoker {
    /**
     * 持有命令对象
     */
    private Command command = null;
    /**
     * 构造方法
     */
    public Invoker(Command command){
        this.command = command;
    }
    /**
     * 行动方法
     */
    public void action(){
        
        command.execute();
    }
}
5.	客户端角色类
public class Client {

    public static void main(String[] args) {
        //创建接收者
        Receiver receiver = new Receiver();
        //创建命令对象，设定它的接收者
        Command command = new ConcreteCommand(receiver);
        //创建请求者，把命令对象设置进去
        Invoker invoker = new Invoker(command);
        //执行方法
        invoker.action();
    }

}

7.备忘录模式

8.迭代器模式

9.中介者模式

10.访问者模式

符合开闭原则.