设计模式之行为型模式

1. 责任链模式【本身处理不了的往下传递处理】

1. 为请求创建一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。在这种模式中，每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。【本身处理不了的往下传递处理】

2. 责任链模式的实现流程

//1. 创建抽象的记录器类
public abstract class AbstractLogger{
	//定义级别
	protected int level;
	//责任链的下一个元素
	protected AvstractLogger nextLogger;
}

//2. 创建扩展了该记录器类的实体类
public class ConsoleLogger extends AbstractLogger {}
public class ErrorLogger extends AbstractLogger {}
public class FileLogger extends AbstractLogger {}

//3. 创建不同类型的记录器。赋予它们不同的错误级别，并在每个记录器中设置下一个记录器。每个记录器中的下一个记录器代表的是链的一部分。

2. 命令模式【打包模式】

1. 请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。【打包模式】

2. 命令模式实现流程

//1. 创建一个命令接口
public interface Order{
	void executer();
}

//2. 创建一个请求类
public class Stock{}

//3. 创建实现了Order接口的实体类
public class BuyStock implements Order{}
public class SellStock implements Order{}

//4. 创建命令调用类
public class Broker{
	private List<Order> orderList = new ArrayList<Order>(); 
}

//5. 使用Broker类来接受并执行命令。

3. 解释器模式【依据规则解析】

1. 提供了评估语言的语法或表达式的方式。【依据规则解析】

2. 解释器模式的实现流程

//1. 创建一个表达式接口
public interface Expression{}

//2. 创建接口的实现类
public class TerminalExpression implements Expression{}

public class OrEcpression implements Expression{}
public class AndExpression implements Expression{}

//3. 使用Expression类来创建规则，并解析它们

4. 迭代器模式【java中的迭代器原理】

1. 用于顺序访问集合对象的元素，不需要指导集合对象的底层表示【java中的迭代器原理】

2. 迭代器模式的实现流程

//1. 创建接口
public interface Iterator {
   public boolean hasNext();
   public Object next();
}
public interface Container {
   public Iterator getIterator();
}

//2. 创建了实现了Container接口的实体类。该类有实现了Iterator接口的内部类NameIterator
public class NameRepository implements Container {
   public String[] names = {"Robert" , "John" ,"Julie" , "Lora"};
 
   @Override
   public Iterator getIterator() {
      return new NameIterator();
   }
 
   private class NameIterator implements Iterator {
 
      int index;
 
      @Override
      public boolean hasNext() {
         if(index < names.length){
            return true;
         }
         return false;
      }
 
      @Override
      public Object next() {
         if(this.hasNext()){
            return names[index++];
         }
         return null;
      }     
   }
}

//3. 使用NameRepository来获取迭代器，并打印名字
public class IteratorPatternDemo {
   public static void main(String[] args) {
      NameRepository namesRepository = new NameRepository();
      for(Iterator iter = namesRepository.getIterator(); iter.hasNext();){
         String name = (String)iter.next();
         System.out.println("Name : " + name);
      }  
   }
}

5. 中介者模式【通信交流】

1. 用来降低多个对象和类之间的通信复杂性。【通信交流】

2. 中介者模式的实现流程

//1. 创建中介类
public static void class ChatRoom{}

//2. 创建user类
public class User{
	public void sendMessage(String message){
		ChatRoom.showMessage(this, message);
	}
}

//3. 通过User对象来显示他们之间的通信

6.备忘录模式【保存模式】

1. 保存一个对象的某个状态，以便在适当的时候恢复对象。【保存模式】

2. 备忘录模式的实现流程

//1. 创建Memento类
public class Memento{}

//2. 创建Originator类
public class Originator{}

//3. 创建CareTaker类
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);
    }
}

//4. 使用CareTaker和Originator对象

7. 观察者模式【一对多】

1. 当对象间存在一对多关系时，则使用观察者模式。【一对多】

2. 观察者模式的实现流程

//1. 创建Subject类
public class Subject{
	private List<Observer> observers = new ArrayList<Observer>();
}

//2. 创建Observer类
public abstract class Observer{
	protected Subject subject;
	public abstract void update();
}

//3. 创建实体观察者类
public class BinaryObserver extends Observer{}
public class OctalObserver extends Observer{}
public class HexaObserver extends Observer{}

//4. 使用Subject和实体观察者对象
Subject subject = new Subject();
new HexaObserver(subject);//【都放到了subject的集合中了】
new OctalObserver(subject);
new BinaryObserver(subject);
subject.setState(15);
subject.setState(10);

8. 状态模式【A变B跟着变】

1. 类的行为是基于它的状态改变的。【A变B跟着变】

2. 状态模式的实现流程

// 1. 创建接口
public interface State {
   public void doAction(Context context);
}

//2. 创建实现接口的实体类
public class StartState implements State{
	public void doAction(Context context){
		context.setState(this);
	}
}
public class StopState implements State {
   public void doAction(Context context) {
      context.setState(this); 
   }
}

//3. 创建Context类
public class Context{
   private State state;
 
   public Context(){
      state = null;
   }
 
   public void setState(State state){
      this.state = state;     
   }
 
   public State getState(){
      return state;
   }
}

9. 空对象模式

1. 一个空对象取代NULL对象实例的检查。Null对象不是检查空值，而是反应一个不做任何动作的关系。【没看懂它想干啥】

2. 空对象模式

//1. 创建一个抽象类
public abstract class AbstractCustomer{
	public abstract boolean isNil();
}

//2. 创建抽象类的扩展类
public class RealCustomer extends AbstractCustomer{}
public class NullCustomer extends AbstractCustomer{}

//3. 创建CustomerFactory类
public class CustomerFactory{}

//4. 使用CustomerFactory,基于客户传递的名字，来获取RealCustomer或NullCustomer对象

10. 策略模式【将操作封装起来】

1. 一个类的行为或其算法可以在运行时更改。【将操作封装起来】

2. 策略模式的实现流程

//1. 创建接口
public interface Strategy{}

//2. 创建接口的实体类
public class OperationAdd implements Strategy{
	//加法操作
}
public class OperationSubtract implements Strategy{
	//减法操作
}

//3. 创建context类
public class Context{
	//利用不同的策略调用不同的方法
}

//4. 使用Context来查看当它改变策略Strategy时的行为变化

11. 模板模式【模板】

1. 一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。【模板】

2. 模板模式的实现流程

//1. 创建一个抽象类，它的模板方法被设置为final
public abstract class Game {
   abstract void initialize();
   abstract void startPlay();
   abstract void endPlay();
 
   //模板
   public final void play(){
      //初始化游戏
      initialize();
      //开始游戏
      startPlay();
      //结束游戏
      endPlay();
   }
}

//2. 创建扩展了Game类的实体类
public class Circket extends Game{}
public class Football extends Game{}

//3. 使用Game的模板方法play()来掩饰游戏的定义方式

12. 访问者模式【对象不变，算法变】

1. 改变元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变【对象不变，算法变】

2. 访问者模式的实现流程

//1. 定义接口
public interface ComputerPart{}

//2. 创建接口的实体类
public class Keyboard implements ComputerPart{}
public class Monitor implements ComputerPart{}
public class Mouse implements ComputerPart{}

//3. 定义访问者接口
public interface ComputerPartVisitor{
	public void visit(Computer computer);
	public void visit(Mouse mouse);
	public void visit(Keyboard keyboard);
    public void visit(Monitor monitor);
}

//4. 定义访问者接口的实现类
public class ComputerPartDisplayVisitor implements ComputerPartVisitor{}

//5. 使用ComputerPartDisplayVisitor来显示Computer的组成部分