行为型模式用于描述程序在运行时复杂的流程控制，简单来说，行为型模式就是用于描述多个类或对象之间如何相互协作来共同完成单个对象都无法完成的任务，它涉及算法和对象间的职责分配问题。
分类：（11种，除了标注的模式外，其余都为对象行为模式）
1模板方法模式
1.1定义
定义一个操作中的算法骨架，而将算法中的一些步骤延迟到子类中，使得子类可以在不改变算法结构的前提下，重新定义该算法的某些特定步骤。
1.2结构
抽象类：负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。
*模板方法：定义了算法的骨架，一般用final修饰，按某种顺序调用其包含的基本方法。
*基本方法：是实现算法中各个步骤的方法，是模板方法的组成部分。基本方法又分为三种：
1.3优缺点
优点：
*提高代码复用
将相同的代码放入抽象的父类中，而将不同的代码放入子类中。
*实现了反向控制
通过一个父类调用子类的操作，通过对子类的具体实现进行扩展，实现了“反向控制”，并符合“开闭原则”。
缺点：
*对每个不同的实现都需要定义一个子类，会导致类的数量增加，系统更加庞大，设计也更加抽象。
*父类中的抽象方法由子类实现，子类的执行结果会影响父类的执行结果，这导致一种反向的控制结构，增加了阅读代码的难度。
1.4适用场景
*算法的整体步骤相对稳定，但其中的个别部分容易发生改变时，可以使用模板方法模式，将容易改变的部分抽象出来，让子类实现。
*需要子类来决定父类中的某个步骤是否执行，实现子类对父类的反向控制。
1.5JDK源码解析
例如：InputStream类就使用了模板方法模式，定义了多个read()方法（重载）。
1.6【案例实现】炒菜
炒菜的步骤是固定的，一般分为5步：倒油，热油，倒蔬菜，倒调料，翻炒。将通过模板方法模式来实现。类图如下：
Dishes类：
1packagemy_test;2/**3*抽象类炒菜4*@authorAsus5*包含一个模板方法（算法）和一些基本方法6*/7publicabstractclassDishes{8//模板方法（炒菜的顺序)9publicfinalvoidcook(){10dao();11hot();12put();13spice();14fry();1516}1718//具体方法：倒油19publicvoiddao(){20System.out.println("开始往锅里倒油啦...");21}22//具体方法：热油23publicvoidhot(){24System.out.println("锅里的油热啦...");25}26//抽象方法：倒菜27abstractvoidput();28//抽象方法：倒调料29abstractvoidspice();30//具体方法：翻炒31publicvoidfry(){32System.out.println("炒呀炒炒呀炒...");33}34}Mapo_tofu类：
1packagemy_test;2/**3*炒菜的实现子类菜品一麻婆豆腐4*@authorAsus5*6*/7publicclassMapo_tofuextendsDishes{8//倒菜9@Override10voidput(){11System.out.println("开始往锅里放豆腐、牛肉末啦...");12}13//放调料14@Override15voidspice(){16System.out.println("放点调料酱油、盐、豆瓣酱会更美味哦...");17}1819}Sweet_and_sour_fish类：
1packagemy_test;2/**3*炒菜的实现子类菜品一糖醋鱼4*@authorAsus5*6*/7publicclassSweet_and_sour_fishextendsDishes{8//倒菜9@Override10voidput(){11System.out.println("开始往锅里放鱼、葱花啦...");12}13//放调料14@Override15voidspice(){16System.out.println("放点调料番茄酱、醋会更美味哦...");17}18}测试类：Test_Dishes
1packagemy_test;2/**3*炒菜的测试类4*@authorAsus5*6*/7publicclassTest_Dishes{89publicstaticvoidmain(String[]args){10//炒麻婆豆腐11System.out.println("-----*炒麻婆豆腐*-----------");12Mapo_tofumt=newMapo_tofu();13mt.cook();14System.out.println();1516//炒糖醋鱼17System.out.println("------*炒糖醋鱼*----------");18Sweet_and_sour_fishsf=newSweet_and_sour_fish();19sf.cook();2021}2223}运行结果：
2策略模式
2.1定义
该模式定义了一系列算法，并把每个算法封装起来，这些算法可以相互替换，且算法的改变不会影响到使用算法的客户。
策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和实现向隔离，并委派给不同的对象对这些算法进行管理。
2.2结构
2.3优缺点：
*优点：
*缺点：
2.4使用场景
2.5JDK源码解析
Comparator中的策略模式。在Arrays（环境类）类中有一个sort()方法。
2.6【案例实现】促销活动
一家百货公司在年度的促销活动。针对不同的节日（春节、中秋节、圣诞节）推出不同的促销活动，由促销员将促销活动展示给客户，类图如下：
Startegy类：
1packagemy_test2;2/**3*抽象类活动4*@authorAsus5*6*/7publicabstractclassStartegy{8//活动内容9abstractvoidshow();10}StartegyA类：
1packagemy_test2;2/**3*抽象类的实现一买一送一活动4*@authorAsus5*6*/7publicclassStartegyAextendsStartegy{8//买一送一活动9@Override10voidshow(){11System.out.println("买一送一活动");1213}1415}StartegyB类：
1packagemy_test2;2/**3*抽象类的实现二满120元送25元活动4*@authorAsus5*6*/7publicclassStartegyBextendsStartegy{89@Override10voidshow(){11System.out.println("满120元送25元活动");12}1314}StartegyC类：
1packagemy_test2;2/**3*抽象类的实现三打八五折活动4*@authorAsus5*6*/7publicclassStartegyCextendsStartegy{89@Override10voidshow(){11System.out.println("打八五折活动");1213}1415}SalesMan类：
1packagemy_test2;2/**3*环境类促销员4*@authorAsus5*6*/7publicclassSalesMan{8publicStartegystartegy;//活动类实例9//构造方法10publicSalesMan(Startegystartegy){11this.startegy=startegy;12}13//显示促销活动14publicvoidsalesManShow(){15startegy.show();16}1718publicvoidsetStartegy(Startegystartegy){19this.startegy=startegy;20}2122}测试类：TestSales
1packagemy_test2;23publicclassTestSales{45publicstaticvoidmain(String[]args){6//节日：春节运行结果活动：买一送一7SalesMansm=newSalesMan(newStartegyA());8sm.salesManShow();910System.out.println("现将活动调整为：");11//节日：春节活动：打八五折12sm.setStartegy(newStartegyC());13sm.salesManShow();14}1516}运行结果：
3命令模式
3.1定义
将一个请求封装为一个对象，使发出的请求和执行请求分隔开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行存储、传递、调用、增加与管理。
3.2结构
3.3优缺点：
*优点
*缺点
3.4使用场景
3.5JDK源码解析
Runnable是一个典型的命令模式，Runnable担当命令角色，Thread充当的是调用者，start方法就是执行方法。
3.6【案例实现】点餐
顾客吧订单交给服务员，服务员拿着订单放在订单柜台，然后喊了一声“订单来啦！”，厨师根据订单准备餐点。
服务员：调用者角色，由服务员来发起命令。
厨师：接受者角色，真正执行命令的对象。
订单：命令中包含订单。
类图如下：
Waiter类：
1packagemy_test3;23importjava.util.ArrayList;4importjava.util.List;56/**7*请求者角色（服务员）8*@authorAsus9*10*/11publicclassWaiter{12//持有多个命令对象13privateList
1packagemy_test3;2/**3*厨师类4*@authorAsus5*6*/7publicclassSeniorChef{8publicvoidmakefood(Stringname,intnum){9System.out.println(name+"->"+num+"份");10}11}OrderCommand类：
1packagemy_test3;23importjava.util.Map;4importjava.util.Set;56/**7*具体命令8*@authorAsus9*10*/11publicclassOrderCommandimplementsCommand{12//持有接收者对象13privateSeniorChefreceiver;14privateOrderorder;1516publicOrderCommand(SeniorChefreceiver,Orderorder){17this.receiver=receiver;18this.order=order;19}2021@Override22publicvoidexecute(){23System.out.println("-------*"+order.getTableNum()+"桌的订单*-----------");24Map
1packagemy_test3;23importjava.util.HashMap;4importjava.util.Map;56/**7*订单类8*@authorAsus9*10*/11publicclassOrder{12//餐桌号码13privateinttableNum;14//所点的餐品及份数15privateMap
1packagemy_test3;2/**3*抽象命令类4*@authorAsus5*6*/7publicinterfaceCommand{8//执行命令9voidexecute();1011}Client类：
1packagemy_test3;2/**3*测试类订餐4*@authorAsus5*6*/7publicclassClient{8publicstaticvoidmain(String[]args){9System.out.println("---------*欢迎光临姝鲤鳅饭店*-------------");10//创建第一个订单11Orderod1=newOrder();12od1.setTableNum(1);13od1.setFood("土豆粉",1);14od1.setFood("可乐",2);1516//创建第二个订单17Orderod2=newOrder();18od2.setTableNum(3);19od2.setFood("糖醋排骨",1);20od2.setFood("橙汁",1);2122//创建厨师对象23SeniorChefsf=newSeniorChef();24//创建命令对象25OrderCommandcmd1=newOrderCommand(sf,od1);26OrderCommandcmd2=newOrderCommand(sf,od2);2728//创建调用者（服务员）29Waiterwaiter=newWaiter();30waiter.setCommand(cmd1);31waiter.setCommand(cmd2);3233//让服务员发起命令34waiter.orderUp();35}3637}运行结果：
4责任链模式
4.1定义
责任链模式又名职责链模式，为了避免请求发送者和多个请求处理这耦合在一起，将所有请求的处理者通过前一个对象记住下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。
在日常生活中，常常会出现这样的情况：一个请求可以被多个对象处理，但每个对象的处理条件或权限不同。比如：一个员工要请假，应直接把请假单交给小组长审批，小组长能处理就审批，不能处理就将请假单转交给上一级进行审批，以此类推，直到有对象能够处理它。
4.2结构
4.3优缺点
4.4使用场景
4.5【案例实现】请假
请假一天以下的假只需要小组长统一即可；请假1天到3天的假还需要部门经理同意；请假3天到7天还需要总经理同意才行。
Handler类：
1packagemy_test4;2/**3*具体处理类（部门经理）4*@authorAsus5*6*/7publicclassManagerextendsHandler{89publicManager(){10super(Handler.NUM_ONE,Handler.NUM_THREE);11}1213@Override14protectedvoidhandleLeave(LeaveRequestleave){15System.out.println(leave.getName()+"请假"+leave.getNum()+"天,"+leave.getContent()+"。");16System.out.println("部门经理审批：同意");17}1819}GroupLeader类：
1packagemy_test4;2/**3*具体处理者小组长类4*@authorAsus5*6*/7publicclassGroupLeaderextendsHandler{89publicGroupLeader(){10super(0,Handler.NUM_ONE);1112}1314@Override15protectedvoidhandleLeave(LeaveRequestleave){16System.out.println(leave.getName()+"请假"+leave.getNum()+"天,"+leave.getContent()+"。");17System.out.println("小组长审批：同意");1819}2021}GeneralManager类：
1packagemy_test4;2/**3*具体处理者(总经理)4*@authorAsus5*6*/7publicclassGeneralManagerextendsHandler{89publicGeneralManager(){10super(Handler.NUM_THREE,Handler.NUM_SEVEN);11}1213@Override14protectedvoidhandleLeave(LeaveRequestleave){15System.out.println(leave.getName()+"请假"+leave.getNum()+"天,"+leave.getContent()+"。");16System.out.println("总经理审批：同意");17}1819}LeaveRequest类：
1packagemy_test4;2/**3*请假条4*@authorAsus5*6*/7publicclassLeaveRequest{8//姓名9privateStringname;10//请假天数11privateintnum;12//请假内容13privateStringcontent;14publicLeaveRequest(Stringname,intnum,Stringcontent){15super();16this.name=name;17this.num=num;18this.content=content;19}20publicStringgetName(){21returnname;22}2324publicintgetNum(){25returnnum;26}2728publicStringgetContent(){29returncontent;30}31323334}Client类：
1packagemy_test4;2/**3*客户端角色4*@authorAsus5*6*/7publicclassClient{8publicstaticvoidmain(String[]args){9//创建一个请假条对象10LeaveRequestleave=newLeaveRequest("路轻尘",1,"身体不适");1112//创建各级领导对象13GroupLeadergroupLeader=newGroupLeader();14Managermanager=newManager();15GeneralManagergeneralManager=newGeneralManager();1617//设置处理者链18groupLeader.setNextHandler(manager);19manager.setNextHandler(generalManager);2021//路轻尘提交请假申请22groupLeader.submit(leave);23}2425}运行结果：
5状态模式
5.1定义
对有状态的对象，把复杂的“逻辑判断”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。
5.2结构
5.3优缺点
优点
缺点
5.4使用场景
5.5【案例实现】电梯
通过按钮来控制一个电梯的状态，电梯状态有开门状态、关门状态、停止状态和停止状态。每一种状态改变，都有可能要根据其他状态来更新处理。例如：处于运行状态时不能开门；处于停止状态才可以开门。
StoppingState类：
1packagemy_test5;2/**3*具体状态类（停止电梯）4*@authorAsus5*6*/7publicclassStoppingStateextendsLiftState{89@Override10publicvoidopen(){11super.context.setLiftState(Context.opening);12super.context.open();13}1415@Override16publicvoidclose(){17super.context.setLiftState(Context.closing);18super.context.close();19}2021@Override22publicvoidrun(){23super.context.setLiftState(Context.running);24super.context.run();2526}27//这是当前状态要执行的方法28@Override29publicvoidstop(){30System.out.println("电梯停止了...");3132}3334}RunningState：
1packagemy_test5;2/**3*具体状态类（运行电梯）4*@authorAsus5*6*/7publicclassRunningStateextendsLiftState{89@Override10publicvoidopen(){11//donothing1213}1415@Override16publicvoidclose(){17//donothing1819}20//这是在运行状态下要实现的方法21@Override22publicvoidrun(){23System.out.println("电梯正在运行...");2425}26//停止运行电梯27@Override28publicvoidstop(){29super.context.setLiftState(Context.stoping);30super.context.stop();31}3233}OpeningState：
1packagemy_test5;2/**3*具体状态类打开电梯4*@authorAsus5*6*/7publicclassOpeningStateextendsLiftState{8//当前状态要执行的方法9@Override10publicvoidopen(){11System.out.println("电梯开启.....");1213}1415@Override16publicvoidclose(){17//修改状态18super.context.setLiftState(Context.closing);19//调用当前状态中的context中的close方法20super.context.close();2122}2324@Override25publicvoidrun(){26//donothing2728}2930@Override31publicvoidstop(){32//donothing3334}3536}LiftState：
1packagemy_test5;2/**3*环境角色4*@authorAsus5*6*/7publicclassContext{8//定义对应状态的常量9publicfinalstaticOpeningStateopening=newOpeningState();10publicfinalstaticClosingStateclosing=newClosingState();11publicfinalstaticRunningStaterunning=newRunningState();12publicfinalstaticStoppingStatestoping=newStoppingState();13//定义一个当前电梯状态变量14privateLiftStateliftState;15publicLiftStategetLiftState(){16returnliftState;17}18//设置当前状态对象19publicvoidsetLiftState(LiftStateliftState){20this.liftState=liftState;21//设置当前状态对象中的Context对象22this.liftState.setContext(this);23}24publicvoidopen(){25this.liftState.open();26}27publicvoidclose(){28this.liftState.close();29}30publicvoidrun(){31this.liftState.run();32}33publicvoidstop(){34this.liftState.stop();35}3637}ClosingState：
1packagemy_test5;2/**3*具体实现类（关闭电梯）4*@authorAsus5*6*/7publicclassClosingStateextendsLiftState{89@Override10publicvoidopen(){11super.context.setLiftState(Context.opening);12super.context.open();1314}1516@Override17publicvoidclose(){18System.out.println("电梯门关闭...");1920}2122@Override23publicvoidrun(){24super.context.setLiftState(Context.running);25super.context.run();2627}2829@Override30publicvoidstop(){31super.context.setLiftState(Context.stoping);32super.context.stop();3334}3536}Client：
1packagemy_test5;23publicclassClient{45publicstaticvoidmain(String[]args){6//创建环境角色对象7Contextcontext=newContext();8//设置当前电梯状态9context.setLiftState(newStoppingState());1011context.open();12context.close();13context.run();14context.stop();15}1617}运行结果：
6观察者模式
6.1定义
又被称为发布-订阅模式，定义了一种一对多的依赖关系，让多个观察者对象同时监听一个主题对象，当这个主题对象发生变化时，会通知所有的观察者对象，使它们能够自动地更新自己。
6.2结构
6.3优缺点
6.4使用场景
6.5JDK源码实现
在Java中，通过java.util.Observable类和java.util.Observer接口定义了观察者模式，朱旭实现它们的子类就可以编写观察者模式实例。
Observable类是抽象目标类（被观察者），有一个Vector集合成员变量，用于保存所有要通知的观察者对象。
Observer接口使抽象观察者，监听目标对象的变化，当目标对象发生变化时，观察者得到通知，并调用update方法，进行相应的工作。
7中介者模式
7.1定义
又叫调停模式，定义一个中介角色来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。
7.2结构
7.3优缺点
7.4使用场景
7.5【案例实现】租房
现在租房都是通过房产中介，房主将房屋托管给房屋中介，而租房者从房屋中介获取房屋信息，房屋中介充当租房者与房主的中介者。
8迭代器模式
8.1定义
提供一个对象来顺序访问聚合对象中的一系列数据，而不是暴露聚合对象的内部显示。
8.2结构
8.3优缺点
8.4使用场景
8.5【案例实现】学生管理系统
定义一个可以存储学生对象的容器对象，将遍历该容器的功能交给迭代器实现。
9访问者模式
9.1定义
封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下，定义作用于这些元素的新的操作。
9.2结构
9.3优缺点
9.4使用场景
9.5【案例实现】给宠物喂食
现在养宠物的人特别多，宠物分为猫，狗等，要给宠物喂食的话，主人可以喂，其他人也可以喂食。
访问者角色：给宠物喂食的人
具体访问者角色：主人、其他人
抽象元素角色：动物抽象类
具体元素角色：宠物狗、宠物猫
结构对象角色：主人家
10备忘录模式
10.1定义
又叫快照模式，在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要时，能将该对象恢复到原先保存的状态。
10.2结构
备忘录有两个接口：窄接口、宽接口。
10.3优缺点
10.4使用场景
11解释器模式
11.1定义
定义语言的文法，并且建立一个解释器来解释该语言中的句子，这里的“语言”意思是使用规定格式和语法的代码，它是一种类行为型模式。