行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。
行为型模式分为类行为模式和对象行为模式，前者采用继承机制来在类间分派行为，后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象行为模式比类行为模式具有更大的灵活性。

一.模板方法模式

定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
结构
模板方法（Template Method）模式包含以下主要角色：
抽象类（Abstract Class）：负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。
模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。
基本方法：是实现算法各个步骤的方法，是模板方法的组成部分。基本方法又可以分为三种：
抽象方法(Abstract Method) ：一个抽象方法由抽象类声明、由其具体子类实现。
具体方法(Concrete Method) ：一个具体方法由一个抽象类或具体类声明并实现，其子类可以进行覆盖也可以直接继承。
钩子方法(Hook Method) ：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。一般钩子方法是用于判断的逻辑方法，这类方法名一般为isXxx，返回值类型为boolean类型。
具体子类（Concrete Class）：实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的组成步骤。
image.png

  1. //模板类
  2. public abstract class AbsClass {
  4.     //定义模板方法
  6.     public final void cookProcess() {
  7.         //第一步：倒油
  8.         this.pourOil();
  9.         //第二步：热油
  10.         this.heatOil();
  11.         //第三步：倒蔬菜
  12.         this.pourVegetable();
  13.         //第四步：倒调味料
  14.         this.pourSauce();
  15.         //第五步：翻炒
  16.         this.fry();
  17.     }
  19.     public void pourOil() {
  20.         System.out.println("倒油");
  21.     }
  23.     //第二步：热油是一样的，
  24.     public void heatOil() {
  25.         System.out.println("热油");
  26.     }
  28.     //第三步：倒蔬菜是不一样的（一个下包菜，一个是下菜心）
  29.     public abstract void pourVegetable();
  31.     //第四步：倒调味料是不一样
  32.     public abstract void pourSauce();
  35.     //第五步：翻炒是一样的，
  36.     public void fry(){
  37.         System.out.println("炒啊炒啊炒到熟啊");
  38.     }
  40. }
  1. 具体实现类
  2. public class cookImpl extends AbsClass{
  3.     public void pourVegetable() {
  4.         System.out.println("放蔬菜");
  5.     }
  7.     public void pourSauce() {
  8.         System.out.println("放调料");
  10.     }
  11. }

二.策略模式

该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。
结构
策略模式的主要角色如下：

  • 抽象策略（Strategy）类：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
  • 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现或行为。
  • 环境（Context）类：持有一个策略类的引用，最终给客户端调用。

image.png

  1. //抽象的策略接口
  2. public interface strategy {
  4.     public void show();
  5. }
  2. //俩个具体的策略
  3. public class strategyA implements strategy{
  4.     public void show() {
  5.         System.out.println("买一送一");
  6.     }
  7. }
  11. public class strategyB implements strategy{
  12.     public void show() {
  13.         System.out.println("打八折");
  14.     }
  15. }
  1. //策略执行者
  3. public class SaleMan {
  4.     private strategy strategy;
  6.     public SaleMan(strategy strategy) {
  7.         this.strategy = strategy;
  8.     }
  10.     public void saleManShow(){
  11.         this.strategy.show();
  12.     }
  13. }

三.命令模式

将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行存储、传递、调用、增加与管理。
结构
命令模式包含以下主要角色：
抽象命令类（Command）角色： 定义命令的接口，声明执行的方法。
具体命令（Concrete Command）角色：具体的命令，实现命令接口；通常会持有接收者，并调用接收者的功能来完成命令要执行的操作。
实现者/接收者（Receiver）角色： 接收者，真正执行命令的对象。任何类都可能成为一个接收者，只要它能够实现命令要求实现的相应功能。
调用者/请求者（Invoker）角色： 要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方，也就是说相当于使用命令对象的入口。
image.png

  1. public interface Command {
  2.     void execute();//只需要定义一个统一的执行方法
  3. }
  5. public class OrderCommand implements Command {
  7.     //持有接受者对象
  8.     private SeniorChef receiver;
  9.     private Order order;
  11.     public OrderCommand(SeniorChef receiver, Order order){
  12.         this.receiver = receiver;
  13.         this.order = order;
  14.     }
  16.     public void execute()  {
  17.         System.out.println(order.getDiningTable() + "桌的订单：");
  18.         Set<String> keys = order.getFoodDic().keySet();
  19.         for (String key : keys) {
  20.             receiver.makeFood(order.getFoodDic().get(key),key);
  21.         }
  23.         try {
  24.             Thread.sleep(100);//停顿一下 模拟做饭的过程
  25.         } catch (InterruptedException e) {
  26.             e.printStackTrace();
  27.         }
  30.         System.out.println(order.getDiningTable() + "桌的饭弄好了");
  31.     }
  32. }
  34. public class Order {
  35.     // 餐桌号码
  36.     private int diningTable;
  38.     // 用来存储餐名并记录份数
  39.     private Map<String, Integer> foodDic = new HashMap<String, Integer>();
  41.     public int getDiningTable() {
  42.         return diningTable;
  43.     }
  45.     public void setDiningTable(int diningTable) {
  46.         this.diningTable = diningTable;
  47.     }
  49.     public Map<String, Integer> getFoodDic() {
  50.         return foodDic;
  51.     }
  53.     public void setFoodDic(String name, int num) {
  54.         foodDic.put(name,num);
  55.     }
  56. }
  58. // 资深大厨类 是命令的Receiver
  59. public class SeniorChef {
  61.     public void makeFood(int num,String foodName) {
  62.         System.out.println(num + "份" + foodName);
  63.     }
  64. }
  66. public class Waitor {
  68.     private ArrayList<Command> commands;//可以持有很多的命令对象
  70.     public Waitor() {
  71.         commands = new ArrayList();
  72.     }
  74.     public void setCommand(Command cmd){
  75.         commands.add(cmd);
  76.     }
  78.     // 发出命令 喊 订单来了，厨师开始执行
  79.     public void orderUp() {
  80.         System.out.println("美女服务员：叮咚，大厨，新订单来了.......");
  81.         for (int i = 0; i < commands.size(); i++) {
  82.             Command cmd = commands.get(i);
  83.             if (cmd != null) {
  84.                 cmd.execute();
  85.             }
  86.         }
  87.     }
  88. }
  90. public class Client {
  91.     public static void main(String[] args) {
  92.         //创建2个order
  93.         Order order1 = new Order();
  94.         order1.setDiningTable(1);
  95.         order1.getFoodDic().put("西红柿鸡蛋面",1);
  96.         order1.getFoodDic().put("小杯可乐",2);
  98.         Order order2 = new Order();
  99.         order2.setDiningTable(3);
  100.         order2.getFoodDic().put("尖椒肉丝盖饭",1);
  101.         order2.getFoodDic().put("小杯雪碧",1);
  103.         //创建接收者
  104.         SeniorChef receiver=new SeniorChef();
  105.         //将订单和接收者封装成命令对象
  106.         OrderCommand cmd1 = new OrderCommand(receiver, order1);
  107.         OrderCommand cmd2 = new OrderCommand(receiver, order2);
  108.         //创建调用者 waitor
  109.         Waitor invoker = new Waitor();
  110.         invoker.setCommand(cmd1);
  111.         invoker.setCommand(cmd2);
  113.         //将订单带到柜台 并向厨师喊 订单来了
  114.         invoker.orderUp();
  115.     }
  116. }

四.责任链模式

又名职责链模式，为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。
结构
职责链模式主要包含以下角色:
抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。
image.png

  1. public class LeaveRequest {
  2.     private String name;
  3.     private Integer day;
  5.     public LeaveRequest(String name, Integer day) {
  6.         this.name = name;
  7.         this.day = day;
  8.     }
  11.     public String getName() {
  12.         return name;
  13.     }
  15.     public Integer getDay() {
  16.         return day;
  17.     }
  18. }
  1. //抽象处理者
  2. public abstract class Handler {
  4.     protected static final int NUM_ONE=1;
  5.     protected static final int NUM_THREE=3;
  6.     protected static final int NUM_SEVEN=7;
  8.     private int start;
  9.     private int end;
  11.     //声明后继者
  12.     Handler next;
  14.     public Handler(int start, int end) {
  15.         this.start = start;
  16.         this.end = end;
  17.     }
  19.     public void setNext(Handler next) {
  20.         this.next = next;
  21.     }
  23.     public abstract void handlerLeave(LeaveRequest leave);
  24.     public  final void submit(LeaveRequest leave){
  25.         this.handlerLeave(leave);
  26.         if(this.next !=null && leave.getDay()>this.end){
  27.             this.next.submit(leave);
  28.         }else {
  29.             System.out.println("流程完毕");
  30.         }
  31.     }
  32. }

具体处理者继承抽象处理者并声明next

五.状态模式

对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。
结构
状态模式包含以下主要角色。
环境（Context）角色：也称为上下文，它定义了客户程序需要的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理。
抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为。
具体状态（Concrete State）角色：实现抽象状态所对应的行为。
image.png

  1. //抽象状态类
  2. public abstract class LiftState {
  3.     //定义一个环境角色，也就是封装状态的变化引起的功能变化
  4.     protected Context context;
  6.     public void setContext(Context context) {
  7.         this.context = context;
  8.     }
  10.     //电梯开门动作
  11.     public abstract void open();
  13.     //电梯关门动作
  14.     public abstract void close();
  16.     //电梯运行动作
  17.     public abstract void run();
  19.     //电梯停止动作
  20.     public abstract void stop();
  21. }
  23. //开启状态
  24. public class OpenningState extends LiftState {
  26.     //开启当然可以关闭了，我就想测试一下电梯门开关功能
  27.     @Override
  28.     public void open() {
  29.         System.out.println("电梯门开启...");
  30.     }
  32.     @Override
  33.     public void close() {
  34.         //状态修改
  35.         super.context.setLiftState(Context.closeingState);
  36.         //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
  37.         super.context.getLiftState().close();
  38.     }
  40.     //电梯门不能开着就跑，这里什么也不做
  41.     @Override
  42.     public void run() {
  43.         //do nothing
  44.     }
  46.     //开门状态已经是停止的了
  47.     @Override
  48.     public void stop() {
  49.         //do nothing
  50.     }
  51. }
  53. //运行状态
  54. public class RunningState extends LiftState {
  56.     //运行的时候开电梯门？你疯了！电梯不会给你开的
  57.     @Override
  58.     public void open() {
  59.         //do nothing
  60.     }
  62.     //电梯门关闭？这是肯定了
  63.     @Override
  64.     public void close() {//虽然可以关门，但这个动作不归我执行
  65.         //do nothing
  66.     }
  68.     //这是在运行状态下要实现的方法
  69.     @Override
  70.     public void run() {
  71.         System.out.println("电梯正在运行...");
  72.     }
  74.     //这个事绝对是合理的，光运行不停止还有谁敢做这个电梯？！估计只有上帝了
  75.     @Override
  76.     public void stop() {
  77.         super.context.setLiftState(Context.stoppingState);
  78.         super.context.stop();
  79.     }
  80. }
  82. //停止状态
  83. public class StoppingState extends LiftState {
  85.     //停止状态，开门，那是要的！
  86.     @Override
  87.     public void open() {
  88.         //状态修改
  89.         super.context.setLiftState(Context.openningState);
  90.         //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
  91.         super.context.getLiftState().open();
  92.     }
  94.     @Override
  95.     public void close() {//虽然可以关门，但这个动作不归我执行
  96.         //状态修改
  97.         super.context.setLiftState(Context.closeingState);
  98.         //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
  99.         super.context.getLiftState().close();
  100.     }
  102.     //停止状态再跑起来，正常的很
  103.     @Override
  104.     public void run() {
  105.         //状态修改
  106.         super.context.setLiftState(Context.runningState);
  107.         //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
  108.         super.context.getLiftState().run();
  109.     }
  111.     //停止状态是怎么发生的呢？当然是停止方法执行了
  112.     @Override
  113.     public void stop() {
  114.         System.out.println("电梯停止了...");
  115.     }
  116. }
  118. //关闭状态
  119. public class ClosingState extends LiftState {
  121.     @Override
  122.     //电梯门关闭，这是关闭状态要实现的动作
  123.     public void close() {
  124.         System.out.println("电梯门关闭...");
  125.     }
  127.     //电梯门关了再打开，逗你玩呢，那这个允许呀
  128.     @Override
  129.     public void open() {
  130.         super.context.setLiftState(Context.openningState);
  131.         super.context.open();
  132.     }
  135.     //电梯门关了就跑，这是再正常不过了
  136.     @Override
  137.     public void run() {
  138.         super.context.setLiftState(Context.runningState);
  139.         super.context.run();
  140.     }
  142.     //电梯门关着，我就不按楼层
  143.     @Override
  144.     public void stop() {
  145.         super.context.setLiftState(Context.stoppingState);
  146.         super.context.stop();
  147.     }
  148. }
  150. //环境角色
  151. public class Context {
  152.     //定义出所有的电梯状态
  153.     public final static OpenningState openningState = new OpenningState();//开门状态，这时候电梯只能关闭
  154.     public final static ClosingState closeingState = new ClosingState();//关闭状态，这时候电梯可以运行、停止和开门
  155.     public final static RunningState runningState = new RunningState();//运行状态，这时候电梯只能停止
  156.     public final static StoppingState stoppingState = new StoppingState();//停止状态，这时候电梯可以开门、运行
  159.     //定义一个当前电梯状态
  160.     private LiftState liftState;
  162.     public LiftState getLiftState() {
  163.         return this.liftState;
  164.     }
  166.     public void setLiftState(LiftState liftState) {
  167.         //当前环境改变
  168.         this.liftState = liftState;
  169.         //把当前的环境通知到各个实现类中
  170.         this.liftState.setContext(this);
  171.     }
  173.     public void open() {
  174.         this.liftState.open();
  175.     }
  177.     public void close() {
  178.         this.liftState.close();
  179.     }
  181.     public void run() {
  182.         this.liftState.run();
  183.     }
  185.     public void stop() {
  186.         this.liftState.stop();
  187.     }
  188. }
  190. //测试类
  191. public class Client {
  192.     public static void main(String[] args) {
  193.         Context context = new Context();
  194.         context.setLiftState(new ClosingState());
  196.         context.open();
  197.         context.close();
  198.         context.run();
  199.         context.stop();
  200.     }
  201. }

六.观察者模式

又被称为发布-订阅（Publish/Subscribe）模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己
结构
在观察者模式中有如下角色：
Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
Observer：抽象观察者，是观察者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
ConcrereObserver：具体观察者，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态
image.png

  1. //观察者接口
  2. public interface Observer {
  4.     //要更新的内容
  5.     public void update(String str);
  6. }
  1. public interface Subject {
  2.     //声明  添加观察者
  3.     public void attach(Observer obs);
  5.     //删除观察者
  6.     public void detach(Observer obs);
  8.     //发布消息
  9.     public void notify(String str);
  10. }
  1. public class SubscriptionSubject implements Subject{
  2.     //集合存放观察者对象
  3.     ArrayList<Observer> list =new ArrayList<Observer>();
  4.     public void attach(Observer obs) {
  5.         list.add(obs);
  6.     }
  8.     public void detach(Observer obs) {
  9.         list.remove(obs);
  10.     }
  12.     public void notify(String str) {
  13.         //遍历list  更新消息
  14.         for (Observer observer : list) {
  15.             observer.update(str);
  16.         }
  18.     }
  19. }

七.中介者模式

又叫调停模式，定义一个中介角色来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。
image.png
结构
中介者模式包含以下主要角色：
抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
具体中介者（ConcreteMediator）角色：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。
抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。
image.png

  1. //抽象中介者
  2. public abstract class Mediator {
  3.     //申明一个联络方法
  4.     public abstract void constact(String message,Person person);
  5. }
  7. //抽象同事类
  8. public abstract class Person {
  9.     protected String name;
  10.     protected Mediator mediator;
  12.     public Person(String name,Mediator mediator){
  13.         this.name = name;
  14.         this.mediator = mediator;
  15.     }
  16. }
  18. //具体同事类 房屋拥有者
  19. public class HouseOwner extends Person {
  21.     public HouseOwner(String name, Mediator mediator) {
  22.         super(name, mediator);
  23.     }
  25.     //与中介者联系
  26.     public void constact(String message){
  27.         mediator.constact(message, this);
  28.     }
  30.     //获取信息
  31.     public void getMessage(String message){
  32.         System.out.println("房主" + name +"获取到的信息：" + message);
  33.     }
  34. }
  36. //具体同事类 承租人
  37. public class Tenant extends Person {
  38.     public Tenant(String name, Mediator mediator) {
  39.         super(name, mediator);
  40.     }
  42.     //与中介者联系
  43.     public void constact(String message){
  44.         mediator.constact(message, this);
  45.     }
  47.     //获取信息
  48.     public void getMessage(String message){
  49.         System.out.println("租房者" + name +"获取到的信息：" + message);
  50.     }
  51. }
  53. //中介机构
  54. public class MediatorStructure extends Mediator {
  55.     //首先中介结构必须知道所有房主和租房者的信息
  56.     private HouseOwner houseOwner;
  57.     private Tenant tenant;
  59.     public HouseOwner getHouseOwner() {
  60.         return houseOwner;
  61.     }
  63.     public void setHouseOwner(HouseOwner houseOwner) {
  64.         this.houseOwner = houseOwner;
  65.     }
  67.     public Tenant getTenant() {
  68.         return tenant;
  69.     }
  71.     public void setTenant(Tenant tenant) {
  72.         this.tenant = tenant;
  73.     }
  75.     public void constact(String message, Person person) {
  76.         if (person == houseOwner) {          //如果是房主，则租房者获得信息
  77.             tenant.getMessage(message);
  78.         } else {       //反正则是房主获得信息
  79.             houseOwner.getMessage(message);
  80.         }
  81.     }
  82. }
  84. //测试类
  85. public class Client {
  86.     public static void main(String[] args) {
  87.         //一个房主、一个租房者、一个中介机构
  88.         MediatorStructure mediator = new MediatorStructure();
  90.         //房主和租房者只需要知道中介机构即可
  91.         HouseOwner houseOwner = new HouseOwner("张三", mediator);
  92.         Tenant tenant = new Tenant("李四", mediator);
  94.         //中介结构要知道房主和租房者
  95.         mediator.setHouseOwner(houseOwner);
  96.         mediator.setTenant(tenant);
  98.         tenant.constact("需要租三室的房子");
  99.         houseOwner.constact("我这有三室的房子，你需要租吗？");
  100.     }
  101. }

八.迭代器模式

提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示
结构
迭代器模式主要包含以下角色：
抽象聚合（Aggregate）角色：定义存储、添加、删除聚合元素以及创建迭代器对象的接口。
具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、next() 等方法。
具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

定义迭代器接口，声明hasNext、next方法

  1. public interface StudentIterator {
  2.     boolean hasNext();
  3.     Student next();
  4. }
  1. 定义具体的迭代器类，重写所有的抽象方法
public class StudentIteratorImpl implements StudentIterator {
    private List<Student> list;
    private int position = 0;

    public StudentIteratorImpl(List<Student> list) {
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        return position < list.size();
    }

    @Override
    public Student next() {
        Student currentStudent = list.get(position);
        position ++;
        return currentStudent;
    }
}

定义抽象容器类，包含添加元素，删除元素，获取迭代器对象的方法

public interface StudentAggregate {
    void addStudent(Student student);

    void removeStudent(Student student);

    StudentIterator getStudentIterator();
}

定义具体的容器类，重写所有的方法

public class StudentAggregateImpl implements StudentAggregate {

    private List<Student> list = new ArrayList<Student>();  // 学生列表

    @Override
    public void addStudent(Student student) {
        this.list.add(student);
    }

    @Override
    public void removeStudent(Student student) {
        this.list.remove(student);
    }

    @Override
    public StudentIterator getStudentIterator() {
        return new StudentIteratorImpl(list);
    }
}

九.访问者模式

封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下定义作用于这些元素的新的操作。