十四、模版方法模式
1、介绍
1）模板方法模式(Template Method Pattern)，又叫模板模式(Template Patern)，在一个抽象类公开定义了执行它的方法的模板。它的子类可以按需重写方法实现，但调用将以抽象类中定义的方式进行。
2）简单说，模板方法模式 定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构，就可以重定义该算法的某些特定步骤，这种类型的设计模式属于行为型模式。
- AbstractClass 抽象类， 类中实现了模板方法(template)，定义了算法的骨架，具体子类需要去实现 其它的抽象方法 operationr2,3,4
- ConcreteClass 实现抽象方法 operationr2,3,4,以完成算法中特点子类的步骤
2、案例
编写制作豆浆的程序，说明如下:
1）制作豆浆的流程 选材—>添加配料—>浸泡—>放到豆浆机打碎
2）通过添加不同的配料，可以制作出不同口味的豆浆
3）选材、浸泡和放到豆浆机打碎这几个步骤对于制作每种口味的豆浆都是一样的
4）请使用 模板方法模式 完成（说明：因为模板方法模式比较简单，很容易就想到这个方案，因此就直接使用。不再使用传统的方案来引出模板方法模式）
1、模版抽象类
//抽象类，表示豆浆
public abstract class SoyaMilk {//模板方法, make , 模板方法可以做成final , 不让子类去覆盖.final void make() {select(); addCondiments();soak();beat();}//选材料void select() {System.out.println("第一步：选择好的新鲜黄豆 ");}//添加不同的配料， 抽象方法, 子类具体实现abstract void addCondiments();//浸泡void soak() {System.out.println("第三步， 黄豆和配料开始浸泡， 需要3小时 ");}void beat() {System.out.println("第四步：黄豆和配料放到豆浆机去打碎 ");}
}
2、花生豆浆
public class PeanutSoyaMilk extends SoyaMilk {@Overridevoid addCondiments() {System.out.println(" 加入上好的花生 ");}}
3、红豆豆浆
public class RedBeanSoyaMilk extends SoyaMilk {@Overridevoid addCondiments() {System.out.println(" 加入上好的红豆 ");}}
4、测试
public static void main(String[] args) {//制作红豆豆浆System.out.println("----制作红豆豆浆----");SoyaMilk redBeanSoyaMilk = new RedBeanSoyaMilk();redBeanSoyaMilk.make();System.out.println("----制作花生豆浆----");SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();peanutSoyaMilk.make();}
----制作红豆豆浆----
第一步：选择好的新鲜黄豆
加入上好的红豆
第三步， 黄豆和配料开始浸泡， 需要3小时
第四步：黄豆和配料放到豆浆机去打碎
----制作花生豆浆----
第一步：选择好的新鲜黄豆
加入上好的花生
第三步， 黄豆和配料开始浸泡， 需要3小时
第四步：黄豆和配料放到豆浆机去打碎
3、钩子方法
1）在模板方法模式的父类中，我们可以定义一个方法，它默认不做任何事，子类可以视情况要不要覆盖它，该方法称为“钩子”。
2）用上面做豆浆的例子来讲解，比如，我们还希望制作纯豆浆，不添加任何的配料，请使用钩子方法对前面的模板方法进行改造
1、模版抽象类
//抽象类，表示豆浆
public abstract class SoyaMilk {//模板方法, make , 模板方法可以做成final , 不让子类去覆盖.final void make() {select(); if(customerWantCondiments()) {addCondiments();}soak();beat();}//选材料void select() {System.out.println("第一步：选择好的新鲜黄豆 ");}//添加不同的配料， 抽象方法, 子类具体实现abstract void addCondiments();//浸泡void soak() {System.out.println("第三步， 黄豆和配料开始浸泡， 需要3小时 ");}void beat() {System.out.println("第四步：黄豆和配料放到豆浆机去打碎 ");}//钩子方法，决定是否需要添加配料boolean customerWantCondiments() {return true;}
}
2、纯豆浆类
public class PureSoyaMilk extends SoyaMilk{@Overridevoid addCondiments() {//空实现}@Overrideboolean customerWantCondiments() {return false;}}
3、红豆
public class RedBeanSoyaMilk extends SoyaMilk {@Overridevoid addCondiments() {System.out.println(" 加入上好的红豆 ");}}
4、花生类
public class PeanutSoyaMilk extends SoyaMilk {@Overridevoid addCondiments() {System.out.println(" 加入上好的花生 ");}}
5、测试
public static void main(String[] args) {System.out.println("----制作红豆豆浆----");SoyaMilk redBeanSoyaMilk = new RedBeanSoyaMilk();redBeanSoyaMilk.make();System.out.println("----制作花生豆浆----");SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();peanutSoyaMilk.make();System.out.println("----制作纯豆浆----");SoyaMilk pureSoyaMilk = new PureSoyaMilk();pureSoyaMilk.make();}
----制作红豆豆浆----
第一步：选择好的新鲜黄豆
加入上好的红豆
第三步， 黄豆和配料开始浸泡， 需要3小时
第四步：黄豆和配料放到豆浆机去打碎
----制作花生豆浆----
第一步：选择好的新鲜黄豆
加入上好的花生
第三步， 黄豆和配料开始浸泡， 需要3小时
第四步：黄豆和配料放到豆浆机去打碎
----制作纯豆浆----
第一步：选择好的新鲜黄豆
第三步， 黄豆和配料开始浸泡， 需要3小时
第四步：黄豆和配料放到豆浆机去打碎
4、总结
1）基本思想是：算法只存在于一个地方，也就是在父类中，容易修改。需要修改算法时，只要修改父类的模板方法或者已经实现的某些步骤，子类就会继承这些修改。
2）实现了最大化代码复用。父类的模板方法和已实现的某些步骤会被子类继承而直接使用。
3）既统一了算法，也提供了很大的灵活性。父类的模板方法确保了算法的结构保持不变，同时由子类提供部分步骤的实现。
4）该模式的不足之处：每一个不同的实现都需要一个子类实现，导致类的个数增加，使得系统更加庞大。
5）一般模板方法都加上 fnal 关键字，防止子类重写模板方法
6）模板方法模式使用场景：当要完成在某个过程，该过程要执行一系列步骤 ，这一系列的步骤基本相同，但其个别步骤在实现时 可能不同，通常考虑用模板方法模式来处理
十五、命令模式
1、介绍
1）命令模式(Command Pattem)：在软件设计中，我们经常需要向某些对象发送请求，但是并不知道请求的接收者是谁，也不知道被请求的操作是哪个，我们只需在程序运行时指定具体的请求接收者即可，此时，可以使用命令模式来进行设计
2）命名模式使得请求发送者与请求接收者消除彼此之间的耦合，让对象之间的调用关系更加灵活，实现解耦。
3）在命名模式中，会将一个请求封装为一个对象，以便使用不同参数来表示不同的请求(即命名)，同时命令模式
也支持可撤销的操作。
4）通俗易懂的理解：将军发布命令，士兵去执行。其中有几个角色：将军(命令发布者)、士兵(命令的具体执行者)、命令(连接将军和士兵)。
Invoker 是调用者(将军)，Receiver 是被调用者(士兵)，MyCommand是命令，实现了 Command 接口，持有接收对象
说明：
1）Invoker 是调用者角色
2）Command：是命令角色，需要执行的所有命令都在这里，可以是接口或抽象类
3）Receiver：接受者角色，知道如何实施和执行一个请求相关的操作
4）ConcreteCommand：将一个接受者对象与一个动作绑定，调用接受者相应的操作，实现 execute
2、案例
1）我们买了一套智能家电，有照明灯、风扇、冰箱、洗衣机，我们只要在手机上安装 app 就可以控制对这些家电工作。
2）这些智能家电来自不同的厂家，我们不想针对每一种家电都安装一个 App，分别控制，我们希望只要一个 app就可以控制全部智能家电。
3）要实现一个 app 控制所有智能家电的需要，则每个智能家电厂家都要提供一个统一的接口给 app 调用，这时 就可以考虑使用命令模式。
4）命令模式可将“动作的请求者”从“动作的执行者”对象中解耦出来。
5）在我们的例子中，动作的请求者是手机 app，动作的执行者是每个厂商的一个家电产品
1、接口
//创建命令接口
public interface Command {//执行动作(操作)public void execute();//撤销动作(操作)public void undo();
}
2、灯具控制类（命令的执行者）
public class LightReceiver {public void on() {System.out.println(" 电灯打开了.. ");}public void off() {System.out.println(" 电灯关闭了.. ");}
}
3、开灯
public class LightOnCommand implements Command {//聚合LightReceiverLightReceiver light;//构造器public LightOnCommand(LightReceiver light) {super();this.light = light;}@Overridepublic void execute() {//调用接收者的方法light.on();}@Overridepublic void undo() {//调用接收者的方法light.off();}}
4、关灯
public class LightOffCommand implements Command {// 聚合LightReceiverLightReceiver light;// 构造器public LightOffCommand(LightReceiver light) {super();this.light = light;}@Overridepublic void execute() {// 调用接收者的方法light.off();}@Overridepublic void undo() {// 调用接收者的方法light.on();}
}
5、电视控制类（命令的执行者）
public class TVReceiver {public void on() {System.out.println(" 电视机打开了.. ");}public void off() {System.out.println(" 电视机关闭了.. ");}
}
6、开电视
public class TVOnCommand implements Command {// 聚合TVReceiverTVReceiver tv;// 构造器public TVOnCommand(TVReceiver tv) {super();this.tv = tv;}@Overridepublic void execute() {// 调用接收者的方法tv.on();}@Overridepublic void undo() {// 调用接收者的方法tv.off();}
}
7、关电视
public class TVOffCommand implements Command {// 聚合TVReceiverTVReceiver tv;// 构造器public TVOffCommand(TVReceiver tv) {super();this.tv = tv;}@Overridepublic void execute() {// 调用接收者的方法tv.off();}@Overridepublic void undo() {// 调用接收者的方法tv.on();}
}
8、空执行
/*** 没有任何命令，即空执行: 用于初始化每个按钮, 当调用空命令时，对象什么都不做* 其实，这样是一种设计模式, 可以省掉对空判断* @author Administrator**/
public class NoCommand implements Command {@Overridepublic void execute() {}@Overridepublic void undo() {}}
9、下达命令
public class RemoteController {// 开 按钮的命令数组Command[] onCommands;Command[] offCommands;// 执行撤销的命令Command undoCommand;// 构造器，完成对按钮初始化public RemoteController() {onCommands = new Command[5];offCommands = new Command[5];for (int i = 0; i < 5; i++) {onCommands[i] = new NoCommand();offCommands[i] = new NoCommand();}}// 给我们的按钮设置你需要的命令public void setCommand(int no, Command onCommand, Command offCommand) {onCommands[no] = onCommand;offCommands[no] = offCommand;}// 按下开按钮public void onButtonWasPushed(int no) { // no 0// 找到你按下的开的按钮， 并调用对应方法onCommands[no].execute();// 记录这次的操作，用于撤销undoCommand = onCommands[no];}// 按下开按钮public void offButtonWasPushed(int no) { // no 0// 找到你按下的关的按钮， 并调用对应方法offCommands[no].execute();// 记录这次的操作，用于撤销undoCommand = offCommands[no];}// 按下撤销按钮public void undoButtonWasPushed() {undoCommand.undo();}}
10、测试
public static void main(String[] args) {//使用命令设计模式，完成通过遥控器，对电灯的操作//创建电灯的对象(接受者)LightReceiver lightReceiver = new LightReceiver();//创建电灯相关的开关命令LightOnCommand lightOnCommand = new LightOnCommand(lightReceiver);LightOffCommand lightOffCommand = new LightOffCommand(lightReceiver);//需要一个遥控器RemoteController remoteController = new RemoteController();//给我们的遥控器设置命令, 比如 no = 0 是电灯的开和关的操作remoteController.setCommand(0, lightOnCommand, lightOffCommand);System.out.println("--------按下灯的开按钮-----------");remoteController.onButtonWasPushed(0);System.out.println("--------按下灯的关按钮-----------");remoteController.offButtonWasPushed(0);System.out.println("--------按下撤销按钮-----------");remoteController.undoButtonWasPushed();System.out.println("=========使用遥控器操作电视机==========");TVReceiver tvReceiver = new TVReceiver();TVOffCommand tvOffCommand = new TVOffCommand(tvReceiver);TVOnCommand tvOnCommand = new TVOnCommand(tvReceiver);//给我们的遥控器设置命令, 比如 no = 1 是电视机的开和关的操作remoteController.setCommand(1, tvOnCommand, tvOffCommand);System.out.println("--------按下电视机的开按钮-----------");remoteController.onButtonWasPushed(1);System.out.println("--------按下电视机的关按钮-----------");remoteController.offButtonWasPushed(1);System.out.println("--------按下撤销按钮-----------");remoteController.undoButtonWasPushed();}
--------按下灯的开按钮-----------
电灯打开了…
--------按下灯的关按钮-----------
电灯关闭了…
--------按下撤销按钮-----------
电灯打开了…
=使用遥控器操作电视机==
--------按下电视机的开按钮-----------
电视机打开了…
--------按下电视机的关按钮-----------
电视机关闭了…
--------按下撤销按钮-----------
电视机打开了…
3、总结
1）将发起请求的对象与执行请求的对象解耦。发起请求的对象是调用者，调用者只要调用命令对象的 execute()方法就可以让接收者工作，而不必知道具体的接收者对象是谁、是如何实现的，命令对象会负责让接收者执行请求的动作，也就是说：请求发起者”和“请求执行者”之间的解耦是通过命令对象实现的，命令对象起到了纽带桥梁的作用。
2）容易设计一个命令队列。只要把命令对象放到列队，就可以多线程的执行命令
3）容易实现对请求的撤销和重做
4）命令模式不足：可能导致某些系统有过多的具体命令类，增加了系统的复杂度，这点在在使用的时候要注意
5）空命令也是一种设计模式，它为我们省去了判空的操作。在上面的实例中，如果没有用空命令，我们每按下一个按键都要判空，这给我们编码带来一定的麻烦。
十六、访问者模式
1、介绍
1）访问者模式(Visitor Pattern)，封装一些作用于某种数据结构的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。
2）主要将数据结构与数据操作分离，解决 数据结构和操作耦合性问题
3）访问者模式的基本工作原理是：在被访问的类里面加一个对外提供接待访问者的接口
4）访问者模式主要应用场景是：需要对一个对象结构中的对象进行很多不同操作(这些操作彼此没有关联)，同时需要避免让这些操作"污染"这些对象的类，可以选用访问者模式解决
说明：
1）Visitor 是抽象访问者，为该对象结构中的 ConcreteElement 的每一个类声明一个 visit 操作
2）ConcreteVisitor 是一个具体的访问者 实现每个有 Visitor 声明的操作，是每个操作实现的部分
3）ObjectStructure 能枚举它的元素, 可以提供一个高层的接口，用来允许访问者访问元素
4）Element 定义一个 accept 方法，接收一个访问者对象
5）ConcreteElement 为具体元素，实现了 accept 方法
2、案例
将人分为男人和女人，对歌手进行测评，当看完某个歌手表演后，得到他们对该歌手不同的评价(评价 有不同的种类，比如 成功、失败 等)，请使用访问者模式来说实现
1、评价
public abstract class Action {//得到男性 的测评public abstract void getManResult(Man man);//得到女的 测评public abstract void getWomanResult(Woman woman);
}
2、提供一个方法，让访问者可以访问
public abstract class Person {//提供一个方法，让访问者可以访问public abstract void accept(Action action);
}
3、男生
public class Man extends Person {@Overridepublic void accept(Action action) {action.getManResult(this);}}
4、女生
//说明
//1. 这里我们使用到了双分派, 即首先在客户端程序中，将具体状态作为参数传递Woman中(第一次分派)
//2. 然后Woman 类调用作为参数的 "具体方法" 中方法getWomanResult, 同时将自己(this)作为参数
// 传入，完成第二次的分派
public class Woman extends Person{@Overridepublic void accept(Action action) {action.getWomanResult(this);}}
5、待定评价
public class Wait extends Action {@Overridepublic void getManResult(Man man) {System.out.println(" 男人给的评价是该歌手待定 ..");}@Overridepublic void getWomanResult(Woman woman) {System.out.println(" 女人给的评价是该歌手待定 ..");}}
6、成功的评价
public class Success extends Action {@Overridepublic void getManResult(Man man) {System.out.println(" 男人给的评价该歌手很成功 !");}@Overridepublic void getWomanResult(Woman woman) {System.out.println(" 女人给的评价该歌手很成功 !");}}
7、失败的评价
public class Fail extends Action {@Overridepublic void getManResult(Man man) {System.out.println(" 男人给的评价该歌手失败 !");}@Overridepublic void getWomanResult(Woman woman) {System.out.println(" 女人给的评价该歌手失败 !");}}
8、核心管理类
//数据结构，管理很多人（Man , Woman）
public class ObjectStructure {//维护了一个集合private List<Person> persons = new LinkedList<Person>();//增加到listpublic void attach(Person p) {persons.add(p);}//移除public void detach(Person p) {persons.remove(p);}//显示测评情况public void display(Action action) {for(Person p: persons) {p.accept(action);}}
}
9、测试
public static void main(String[] args) {//创建ObjectStructureObjectStructure objectStructure = new ObjectStructure();objectStructure.attach(new Man());objectStructure.attach(new Woman());//成功Success success = new Success();objectStructure.display(success);System.out.println("===============");Fail fail = new Fail();objectStructure.display(fail);System.out.println("=======给的是待定的测评========");Wait wait = new Wait();objectStructure.display(wait);}
男人给的评价该歌手很成功 !
女人给的评价该歌手很成功 !
男人给的评价该歌手失败 !
女人给的评价该歌手失败 !
=给的是待定的测评==
男人给的评价是该歌手待定 …
女人给的评价是该歌手待定 …
3、双分派
所谓双分派是指不管类怎么变化，我们都能找到期望的方法运行。双分派意味着得到执行的操作取决于请求的种类和两个接收者的类型。
以上述实例为例，假设我们要添加一个 Wait 的状态类，考察 Man 类和 Woman 类的反应，由于使用了双分派，只需增加一个 Action 子类即可在客户端调用即可，不需要改动任何其他类的代码。
4、总结
优点：
访问者模式符合单一职责原则、让程序具有优秀的扩展性、灵活性非常高
访问者模式可以对功能进行统一，可以做报表、UI、拦截器与过滤器，适用于数据结构相对稳定的系统
缺点：
具体元素对访问者公布细节，也就是说访问者关注了其他类的内部细节，这是迪米特法则所不建议的，这样造成了具体元素变更比较困难
违背了依赖倒转原则。访问者依赖的是具体元素，而不是抽象元素
如果一个系统有比较稳定的数据结构，又有经常变化的功能需求，那么访问者模式就是比较合适的
十七、迭代器模式
1、介绍
1）迭代器模式(Iterator Pattern)是常用的设计模式，属于行为型模式
2）如果我们的集合元素是用不同的方式实现的，有数组，还有java 的集合类，或者还有其他方式，当客户端要遍历这些集合元素的时候就要使用多种遍历方式,而且还会暴露元素的内部结构,可以考虑使用迭代器模式解决。
3）迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示，即:不暴露其内部的结构。
说明：
1）Iterator : 迭代器接口，是系统提供，含义 hasNext,next,remove
2）Concretelterator：具体的迭代器类，管理迭代
3）Aggregate :一个统一的聚合接口，将客户端和具体聚合解耦
4）ConcreteAggreage：具体的聚合持有对象集合，并提供一个方法，返回一个迭代器，该迭代器可以正确遍历集合
5）Client :客户端，通过 Iterator 和Aggregate 依赖子类
2、案例
编写程序展示一个学校院系结构:需求是这样,要在一个页面中展示出学校的院系组成,一个学校有多个学院,一个学院有多个系。
1、部门
//ϵ
public class Department {private String name;private String desc;public Department(String name, String desc) {super();this.name = name;this.desc = desc;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getDesc() {return desc;}public void setDesc(String desc) {this.desc = desc;}}
2、大学接口
public interface College {public String getName();//增加系的方法public void addDepartment(String name, String desc);//返回一个迭代器,遍历public Iterator createIterator();
}
3、信息工程学院
public class InfoCollege implements College {List<Department> departmentList;public InfoCollege() {departmentList = new ArrayList<Department>();addDepartment("信息安全专业", " 信息安全专业 ");addDepartment("网络安全专业", " 网络安全专业 ");addDepartment("服务器安全专业", " 服务器安全专业 ");}@Overridepublic String getName() {return "信息工程学院";}@Overridepublic void addDepartment(String name, String desc) {Department department = new Department(name, desc);departmentList.add(department);}@Overridepublic Iterator createIterator() {return new InfoColleageIterator(departmentList);}}
4、计算机学院
public class ComputerCollege implements College {Department[] departments;int numOfDepartment = 0 ;// 保存当前数组的对象个数public ComputerCollege() {departments = new Department[5];addDepartment("Java专业", " Java专业 ");addDepartment("PHP专业", " PHP专业 ");addDepartment("大数据专业", " 大数据专业 ");}@Overridepublic String getName() {return "计算机学院";}@Overridepublic void addDepartment(String name, String desc) {Department department = new Department(name, desc);departments[numOfDepartment] = department;numOfDepartment += 1;}@Overridepublic Iterator createIterator() {return new ComputerCollegeIterator(departments);}}
5、信息工程学院迭代器
public class InfoColleageIterator implements Iterator {List<Department> departmentList; // 信息工程学院是以List方式存放系int index = -1;//索引public InfoColleageIterator(List<Department> departmentList) {this.departmentList = departmentList;}//判断list中还有没有下一个元素@Overridepublic boolean hasNext() {if(index >= departmentList.size() - 1) {return false;} else {index += 1;return true;}}@Overridepublic Object next() {return departmentList.get(index);}//空实现removepublic void remove() {}
}
6、计算机学院迭代器
public class ComputerCollegeIterator implements Iterator {//这里我们需要Department 是以怎样的方式存放=>数组Department[] departments;int position = 0; //遍历的位置public ComputerCollegeIterator(Department[] departments) {this.departments = departments;}//判断是否还有下一个元素@Overridepublic boolean hasNext() {if(position >= departments.length || departments[position] == null) {return false;}else {return true;}}@Overridepublic Object next() {Department department = departments[position];position += 1;return department;}//删除的方法，默认空实现public void remove() {}
}
7、输出
public class OutPutImpl {//学院集合List<College> collegeList;public OutPutImpl(List<College> collegeList) {this.collegeList = collegeList;}//遍历所有学院,然后调用printDepartment 输出各个学院的系public void printCollege() {//从collegeList 取出所有学院, Java 中的 List 已经实现IteratorIterator<College> iterator = collegeList.iterator();while(iterator.hasNext()) {//取出一个学院College college = iterator.next();System.out.println("=== "+college.getName() +"=====" );printDepartment(college.createIterator()); //得到对应迭代器}}//输出 学院输出 系public void printDepartment(Iterator iterator) {while(iterator.hasNext()) {Department d = (Department)iterator.next();System.out.println(d.getName());}}
}
8、测试
public static void main(String[] args) {//创建学院List<College> collegeList = new ArrayList<College>();ComputerCollege computerCollege = new ComputerCollege();InfoCollege infoCollege = new InfoCollege();collegeList.add(computerCollege);collegeList.add(infoCollege);OutPutImpl outPutImpl = new OutPutImpl(collegeList);outPutImpl.printCollege();}
=== 计算机学院=====
Java专业
PHP专业
大数据专业
=== 信息工程学院=====
信息安全专业
网络安全专业
服务器安全专业
3、总结
优点：
1）提供一个统一的方法遍历对象，客户不用再考虑聚合的类型，使用一种方法就可以遍历对象了。
2）隐藏了聚合的内部结构，客户端要遍历聚合的时候只能取到迭代器，而不会知道聚合的具体组成。
3）提供了一种设计思想，就是一个类应该只有一个引起变化的原因(叫做单一责任原则)。在聚合类中，我们把迭代器分开，就是要把管理对象集合和遍历对象集合的责任分开，这样一来集合改变的话，只影响到聚合对象。而如果遍历方式改变的话，只影响到了迭代器。
4）当要展示一组相似对象，或者遍历一组相同对象时使用，适合使用迭代器模式
缺点：
每个聚合对象都要一个迭代器，会生成多个迭代器不好管理类
十八、观察者模式
1、介绍
1）Subject：登记注册、移除和通知
registerObserver 注册
removeObserver 移除
notifyObservers0)通知所有的注册的用户，根据不同需求，可以是更新数据，让用户来取，也可能是实施 推送,看具体需求定
2）Observer：接收输入
3）观察者模式：对象之间多对一依赖的一种设计方案，被依赖的对象为Subiect，依赖的对象为Observer，Subiect通知 Observer 变化,比如这里的奶站是 Subiect，是1的一方。用户时 Observer，是多的一方。
2、案例
2）气象站可以将每天测量到的温度，湿度，气压等等以公告的形式发布出去(比如发布到自己的网站或第三方)。
2）需要设计开放型 API，便于其他第三方也能接入气象站获取数据。
3）提供温度、气压和湿度的接口
4）测量数据更新时，要能实时的通知给第三方
1、观察者接口
//观察者接口，由观察者来实现
public interface Observer {public void update(float temperature, float pressure, float humidity);
}
2、百度
public class BaiduSite implements Observer {// 温度，气压，湿度private float temperature;private float pressure;private float humidity;// 更新 天气情况，是由 WeatherData 来调用，我使用推送模式public void update(float temperature, float pressure, float humidity) {this.temperature = temperature;this.pressure = pressure;this.humidity = humidity;display();}// 显示public void display() {System.out.println("===百度网站====");System.out.println("***百度网站 气温 : " + temperature + "***");System.out.println("***百度网站 气压: " + pressure + "***");System.out.println("***百度网站 湿度: " + humidity + "***");}}
3、当前信息
public class CurrentConditions implements Observer {// 温度，气压，湿度private float temperature;private float pressure;private float humidity;// 更新 天气情况，是由 WeatherData 来调用，我使用推送模式public void update(float temperature, float pressure, float humidity) {this.temperature = temperature;this.pressure = pressure;this.humidity = humidity;display();}// 显示public void display() {System.out.println("***Today mTemperature: " + temperature + "***");System.out.println("***Today mPressure: " + pressure + "***");System.out.println("***Today mHumidity: " + humidity + "***");}
}
4、接口
//接口, 让WeatherData 来实现
public interface Subject {public void registerObserver(Observer o);public void removeObserver(Observer o);public void notifyObservers();
}
5、核心
/*** 类是核心* 1. 包含最新的天气情况信息 * 2. 含有 观察者集合，使用ArrayList管理* 3. 当数据有更新时，就主动的调用 ArrayList, 通知所有的（接入方）就看到最新的信息* @author Administrator**/
public class WeatherData implements Subject {private float temperatrue;private float pressure;private float humidity;//观察者集合private ArrayList<Observer> observers;//加入新的第三方public WeatherData() {observers = new ArrayList<Observer>();}public float getTemperature() {return temperatrue;}public float getPressure() {return pressure;}public float getHumidity() {return humidity;}public void dataChange() {//调用 接入方的 updatenotifyObservers();}//当数据有更新时，就调用 setDatapublic void setData(float temperature, float pressure, float humidity) {this.temperatrue = temperature;this.pressure = pressure;this.humidity = humidity;//调用dataChange， 将最新的信息 推送给 接入方 currentConditionsdataChange();}//注册一个观察者@Overridepublic void registerObserver(Observer o) {observers.add(o);}//移除一个观察者@Overridepublic void removeObserver(Observer o) {if(observers.contains(o)) {observers.remove(o);}}//遍历所有的观察者，并通知@Overridepublic void notifyObservers() {for(int i = 0; i < observers.size(); i++) {observers.get(i).update(this.temperatrue, this.pressure, this.humidity);}}
}
6、测试
public static void main(String[] args) {//创建一个WeatherDataWeatherData weatherData = new WeatherData();//创建观察者CurrentConditions currentConditions = new CurrentConditions();BaiduSite baiduSite = new BaiduSite();//注册到weatherDataweatherData.registerObserver(currentConditions);weatherData.registerObserver(baiduSite);//测试System.out.println("通知各个注册的观察者, 看看信息");weatherData.setData(10f, 100f, 30.3f);weatherData.removeObserver(currentConditions);//测试System.out.println();System.out.println("通知各个注册的观察者, 看看信息");weatherData.setData(10f, 100f, 30.3f);}
通知各个注册的观察者, 看看信息
Today mTemperature: 10.0
Today mPressure: 100.0
Today mHumidity: 30.3
=百度网站==
百度网站 气温 : 10.0
百度网站 气压: 100.0
百度网站 湿度: 30.3
通知各个注册的观察者, 看看信息
=百度网站==
百度网站 气温 : 10.0
百度网站 气压: 100.0
百度网站 湿度: 30.3
3、总结
观察者模式设计后，会以集合的方式来管理用户(Observer)，包括注册，移除和通知。这样，我们增加观察者(这里可以理解成一个新的公告板)，就不需要去修改核心类 WeatherData 不会修改代码，遵守了 ocp 原则。
十九、中介者模式
1、介绍
1）中介者模式(Mediator Patter)，用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互
2）中介者模式属于行为型模式，使代码易于维护
3）比如 MVC 模式，C(Controller 控制器)是M(Model 模型)和 V(View视图)的中介者，在前后端交互时起到了中间人的作用
说明：
1）Mediator 就是抽象中介者,定义了同事对象到中介者对象的接口
2）Colleague 是抽象同事类
3）ConcreteMediator 具体的中介者对象，实现抽象方法，他需要知道所有的具体的同事类，即以一个集合来管理HashMap，并接受某个同事对象消息，完成相应的任务
4）ConcreteColleague 具体的同事类,会有很多,每个同事只知道自己的行为，而不了解其他同事类的行为(方法)，但是他们都依赖中介者对象。
2、案例
智能家庭项目:
智能家庭包括各种设备，闹钟、咖啡机、电视机、窗帘 等；主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流程为:闹铃响起->咖啡机开始2)做咖啡->窗帘自动落下->电视机开始播放
1、同事抽象类
//同事抽象类
public abstract class Colleague {private Mediator mediator;public String name;public Colleague(Mediator mediator, String name) {this.mediator = mediator;this.name = name;}public Mediator GetMediator() {return this.mediator;}public abstract void SendMessage(int stateChange);
}
2、具体同事类（闹钟）
//具体的同事类
public class Alarm extends Colleague {//构造器public Alarm(Mediator mediator, String name) {super(mediator, name);//在创建Alarm 同事对象时，将自己放入到ConcreteMediator 对象中[集合]mediator.Register(name, this);}public void SendAlarm(int stateChange) {SendMessage(stateChange);}@Overridepublic void SendMessage(int stateChange) {//调用的中介者对象的getMessagethis.GetMediator().GetMessage(stateChange, this.name);}
}
3、具体同事类（coffee）
public class CoffeeMachine extends Colleague {public CoffeeMachine(Mediator mediator, String name) {super(mediator, name);mediator.Register(name, this);}@Overridepublic void SendMessage(int stateChange) {this.GetMediator().GetMessage(stateChange, this.name);}public void StartCoffee() {System.out.println("It's time to startcoffee!");}public void FinishCoffee() {System.out.println("After 5 minutes!");System.out.println("Coffee is ok!");SendMessage(0);}
}
4、具体同事类（窗帘）
public class Curtains extends Colleague {public Curtains(Mediator mediator, String name) {super(mediator, name);mediator.Register(name, this);}@Overridepublic void SendMessage(int stateChange) {this.GetMediator().GetMessage(stateChange, this.name);}public void UpCurtains() {System.out.println("I am holding Up Curtains!");}}
5、具体同事类（电视）
public class TV extends Colleague {public TV(Mediator mediator, String name) {super(mediator, name);mediator.Register(name, this);}@Overridepublic void SendMessage(int stateChange) {this.GetMediator().GetMessage(stateChange, this.name);}public void StartTv() {System.out.println("It's time to StartTv!");}public void StopTv() {System.out.println("StopTv!");}
}
6、中介者
public abstract class Mediator {//将给中介者对象，加入到集合中public abstract void Register(String colleagueName, Colleague colleague);//接收消息, 具体的同事对象发出public abstract void GetMessage(int stateChange, String colleagueName);public abstract void SendMessage();
}
7、具体中介类
//具体的中介者类
public class ConcreteMediator extends Mediator {//集合，放入所有的同事对象private HashMap<String, Colleague> colleagueMap;private HashMap<String, String> interMap;public ConcreteMediator() {colleagueMap = new HashMap<String, Colleague>();interMap = new HashMap<String, String>();}@Overridepublic void Register(String colleagueName, Colleague colleague) {colleagueMap.put(colleagueName, colleague);if (colleague instanceof Alarm) {interMap.put("Alarm", colleagueName);} else if (colleague instanceof CoffeeMachine) {interMap.put("CoffeeMachine", colleagueName);} else if (colleague instanceof TV) {interMap.put("TV", colleagueName);} else if (colleague instanceof Curtains) {interMap.put("Curtains", colleagueName);}}//具体中介者的核心方法//1. 根据得到消息，完成对应任务//2. 中介者在这个方法，协调各个具体的同事对象，完成任务@Overridepublic void GetMessage(int stateChange, String colleagueName) {//处理闹钟发出的消息if (colleagueMap.get(colleagueName) instanceof Alarm) {if (stateChange == 0) {((CoffeeMachine) (colleagueMap.get(interMap.get("CoffeeMachine")))).StartCoffee();((TV) (colleagueMap.get(interMap.get("TV")))).StartTv();} else if (stateChange == 1) {((TV) (colleagueMap.get(interMap.get("TV")))).StopTv();}} else if (colleagueMap.get(colleagueName) instanceof CoffeeMachine) {((Curtains) (colleagueMap.get(interMap.get("Curtains")))).UpCurtains();} else if (colleagueMap.get(colleagueName) instanceof TV) {//如果TV发现消息} else if (colleagueMap.get(colleagueName) instanceof Curtains) {//如果是以窗帘发出的消息，这里处理...}}@Overridepublic void SendMessage() {// TODO Auto-generated method stub}}
8、测试
public static void main(String[] args) {//创建一个中介者对象Mediator mediator = new ConcreteMediator();//创建Alarm 并且加入到 ConcreteMediator 对象的HashMapAlarm alarm = new Alarm(mediator, "alarm");//创建了CoffeeMachine 对象，并 且加入到 ConcreteMediator 对象的HashMapCoffeeMachine coffeeMachine = new CoffeeMachine(mediator,"coffeeMachine");//创建 Curtains , 并 且加入到 ConcreteMediator 对象的HashMapCurtains curtains = new Curtains(mediator, "curtains");TV tV = new TV(mediator, "TV");//让闹钟发出消息alarm.SendAlarm(0);coffeeMachine.FinishCoffee();alarm.SendAlarm(1);}
It’s time to startcoffee!
It’s time to StartTv!
After 5 minutes!
Coffee is ok!
I am holding Up Curtains!
StopTv!
3、总结
1）多个类相互耦合，会形成网状结构，使用中介者模式将网状结构分离为星型结构，进行解耦
2）减少类间依赖，降低了耦合，符合迪米特原则
3）中介者承担了较多的责任，一旦中介者出现了问题，整个系统就会受到影响
4）如果设计不当，中介者对象本身变得过于复杂，这点在实际使用时，要特别注意
二十、备忘录模式
1、介绍
1）备忘录模式(Memento Patern)在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态
2）可以这样理解备忘录模式：现实生活中的备忘录是用来记录某些要去做的事情，或者是记录已经达成的共同意见的事情，以防忘记了。而在软件层面，备忘录模式有着相同的含义，备忘录对象主要用来记录一个对象的某种状态，或者某些数据，当要做回退时，可以从备忘录对象里获取原来的数据进行恢复操作
3）备忘录模式属于行为型模式
说明：
1）originator：对象(需要保存状态的对象)
2）Memento : 备忘录对象,负责保存好记录，即 Originator 内部状态
3）Caretaker：守护者对象,负责保存多个备忘录对象,使用集合管理，提高效率
4）说明：如果希望保存多个 originator 对象的不同时间的状态，也可以，只需要 HashMap<String,集合>
1、备忘录对象
public class Memento {private String state;//构造器public Memento(String state) {super();this.state = state;}public String getState() {return state;}}
2、守护者对象
public class Caretaker {//在List 集合中会有很多的备忘录对象private List<Memento> mementoList = new ArrayList<Memento>();public void add(Memento memento) {mementoList.add(memento);}//获取到第index个Originator 的 备忘录对象(即保存状态)public Memento get(int index) {return mementoList.get(index);}
}
3、需要记录的对象
public class Originator {private String state;//状态信息public String getState() {return state;}public void setState(String state) {this.state = state;}//编写一个方法，可以保存一个状态对象 Memento//因此编写一个方法，返回 Mementopublic Memento saveStateMemento() {return new Memento(state);}//通过备忘录对象，恢复状态public void getStateFromMemento(Memento memento) {state = memento.getState();}
}
4、测试
public static void main(String[] args) {Originator originator = new Originator();Caretaker caretaker = new Caretaker();originator.setState(" 状态#1 攻击力 100 ");//保存了当前的状态caretaker.add(originator.saveStateMemento());originator.setState(" 状态#2 攻击力 80 ");caretaker.add(originator.saveStateMemento());originator.setState(" 状态#3 攻击力 50 ");caretaker.add(originator.saveStateMemento());System.out.println("当前的状态是 =" + originator.getState());//希望得到状态 1, 将 originator 恢复到状态1originator.getStateFromMemento(caretaker.get(0));System.out.println("恢复到状态1 , 当前的状态是");System.out.println("当前的状态是 =" + originator.getState());}
当前的状态是 = 状态#3 攻击力 50
恢复到状态1 , 当前的状态是
当前的状态是 = 状态#1 攻击力 100
2、案例
游戏角色有攻击力和防御力，在大战 Boss 前保存自身的状态(攻击力和防御力)，当大战 Boss后攻击力和防御力下降，从备忘录对象恢复到大战前的状态。
1、备忘录对象
public class Memento {//攻击力private int vit;//防御力private int def;public Memento(int vit, int def) {super();this.vit = vit;this.def = def;}public int getVit() {return vit;}public void setVit(int vit) {this.vit = vit;}public int getDef() {return def;}public void setDef(int def) {this.def = def;}
}
2、守护对象
//守护者对象, 保存游戏角色的状态
public class Caretaker {//如果只保存一次状态private Memento memento;//对GameRole 保存多次状态//private ArrayList<Memento> mementos;//对多个游戏角色保存多个状态//private HashMap<String, ArrayList<Memento>> rolesMementos;public Memento getMemento() {return memento;}public void setMemento(Memento memento) {this.memento = memento;}}
3、需要记录的对象
public class GameRole {private int vit;private int def;//创建Memento ,即根据当前的状态得到Mementopublic Memento createMemento() {return new Memento(vit, def);}//从备忘录对象，恢复GameRole的状态public void recoverGameRoleFromMemento(Memento memento) {this.vit = memento.getVit();this.def = memento.getDef();}//显示当前游戏角色的状态public void display() {System.out.println("游戏角色当前的攻击力：" + this.vit + " 防御力: " + this.def);}public int getVit() {return vit;}public void setVit(int vit) {this.vit = vit;}public int getDef() {return def;}public void setDef(int def) {this.def = def;}}
4、测试
public static void main(String[] args) {//创建游戏角色GameRole gameRole = new GameRole();gameRole.setVit(100);gameRole.setDef(100);System.out.println("和boss大战前的状态");gameRole.display();//把当前状态保存caretakerCaretaker caretaker = new Caretaker();caretaker.setMemento(gameRole.createMemento());System.out.println("和boss大战~~~");gameRole.setDef(30);gameRole.setVit(30);gameRole.display();System.out.println("大战后，使用备忘录对象恢复到站前");gameRole.recoverGameRoleFromMemento(caretaker.getMemento());System.out.println("恢复后的状态");gameRole.display();}
和boss大战前的状态
游戏角色当前的攻击力：100 防御力: 100
和boss大战~~~
游戏角色当前的攻击力：30 防御力: 30
大战后，使用备忘录对象恢复到站前
恢复后的状态
游戏角色当前的攻击力：100 防御力: 100
3、总结
1）给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态
2）实现了信息的封装，使得用户不需要关心状态的保存细节
3）如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存，这个需要注意
4）适用的应用场景:1、后悔药。 2、打游戏时的存档。 3、Windows 里的 ctri+z。 4、E 中的后退。 4、数据库的事务管理
5）为了节约内存，备忘录模式可以和原型模式配合使用
二十一、解析器模式
1、介绍
1）在编译原理中，一个算术表达式通过词法分析器形成词法单元，而后这些词法单元再通过语法分析器构建语法分析树，最终形成一颗抽象的语法分析树。这里的词法分析器和语法分析器都可以看做是解释器
2）解释器模式(Interpreter Patter)：是指给定一个语言(表达式)，定义它的语法的一种表示，并定义一个解释器使用该解释器来解释语言中的句子(表达式)
3）应用场景
应用可以将一个需要解释执行的语言中的句子表示为一个抽象语法树
一些重复出现的问题可以用一种简单的语言来表达
一个简单语法需要解释的场景
4）这样的例子还有，比如编译器、运算表达式计算、正则表达式、机器人等
说明：
1）Context：是环境角色,含有解释器之外的全局信息
2）AbstractExpression：抽象表达式， 声明一个抽象的解释操作,这个方法为抽象语法树中所有的节点所共享
3）TerminalExpression：为终结符表达式，实现与文法中的终结符相关的解释操作
4）NonTermialExpression：为非终结符表达式，为文法中的非终结符实现解释操作
5）说明: 输入 Context he TerminalExpression 信息通过 Client 输入即可
2、案例
通过解释器模式来实现四则运算，如计算 a+b-c 的值
1、抽象类表达式
/*** 抽象类表达式，通过HashMap 键值对, 可以获取到变量的值* @author Administrator*/
public abstract class Expression {// a + b - c// 解释公式和数值, key 就是公式(表达式) 参数[a,b,c], value就是就是具体值// HashMap {a=10, b=20}public abstract int interpreter(HashMap<String, Integer> var);
}
2、变量的解释器
/*** 变量的解释器* @author Administrator**/
public class VarExpression extends Expression {private String key; // key=a,key=b,key=cpublic VarExpression(String key) {this.key = key;}// var 就是{a=10, b=20}// interpreter 根据 变量名称，返回对应值@Overridepublic int interpreter(HashMap<String, Integer> var) {return var.get(this.key);}3、抽象运算符号解析器
/*** 抽象运算符号解析器 这里，每个运算符号，都只和自己左右两个数字有关系，* 但左右两个数字有可能也是一个解析的结果，无论何种类型，都是Expression类的实现类* @author Administrator**/
public class SymbolExpression extends Expression {protected Expression left;protected Expression right;public SymbolExpression(Expression left, Expression right) {this.left = left;this.right = right;}//因为 SymbolExpression 是让其子类来实现，因此 interpreter 是一个默认实现@Overridepublic int interpreter(HashMap<String, Integer> var) {return 0;}
}
4、减
public class SubExpression extends SymbolExpression {public SubExpression(Expression left, Expression right) {super(left, right);}//求出left 和 right 表达式相减后的结果public int interpreter(HashMap<String, Integer> var) {return super.left.interpreter(var) - super.right.interpreter(var);}
}
5、加
/*** 加法解释器* @author Administrator**/
public class AddExpression extends SymbolExpression {public AddExpression(Expression left, Expression right) {super(left, right);}//处理相加//var 仍然是 {a=10,b=20}..//一会我们debug 源码,就okpublic int interpreter(HashMap<String, Integer> var) {//super.left.interpreter(var) ： 返回 left 表达式对应的值 a = 10//super.right.interpreter(var): 返回right 表达式对应值 b = 20return super.left.interpreter(var) + super.right.interpreter(var);}
}
6、计算器类
public class Calculator {// 定义表达式private Expression expression;// 构造函数传参，并解析public Calculator(String expStr) { // expStr = a+b// 安排运算先后顺序Stack<Expression> stack = new Stack<>();// 表达式拆分成字符数组 char[] charArray = expStr.toCharArray();// [a, +, b]Expression left = null;Expression right = null;//遍历我们的字符数组， 即遍历 [a, +, b]//针对不同的情况，做处理for (int i = 0; i < charArray.length; i++) {switch (charArray[i]) {case '+': //left = stack.pop();// 从stack取出left => "a"right = new VarExpression(String.valueOf(charArray[++i]));// 取出右表达式 "b"stack.push(new AddExpression(left, right));// 然后根据得到left 和 right 构建 AddExpresson加入stackbreak;case '-': // left = stack.pop();right = new VarExpression(String.valueOf(charArray[++i]));stack.push(new SubExpression(left, right));break;default: //如果是一个 Var 就创建要给 VarExpression 对象，并push到 stackstack.push(new VarExpression(String.valueOf(charArray[i])));break;}}//当遍历完整个 charArray 数组后，stack 就得到最后Expressionthis.expression = stack.pop();}public int run(HashMap<String, Integer> var) {//最后将表达式a+b和 var = {a=10,b=20}//然后传递给expression的interpreter进行解释执行return this.expression.interpreter(var);}
}
7、测试
public class ClientTest {public static void main(String[] args) throws IOException {String expStr = getExpStr(); // a+bHashMap<String, Integer> var = getValue(expStr);// var {a=10, b=20}Calculator calculator = new Calculator(expStr);System.out.println("运算结果：" + expStr + "=" + calculator.run(var));}// 获得表达式public static String getExpStr() throws IOException {System.out.print("请输入表达式：");return (new BufferedReader(new InputStreamReader(System.in))).readLine();}// 获得值映射public static HashMap<String, Integer> getValue(String expStr) throws IOException {HashMap<String, Integer> map = new HashMap<>();for (char ch : expStr.toCharArray()) {if (ch != '+' && ch != '-') {if (!map.containsKey(String.valueOf(ch))) {System.out.print("请输入" + String.valueOf(ch) + "的值：");String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();map.put(String.valueOf(ch), Integer.valueOf(in));}}}return map;}
}
请输入表达式：qqq+bbbb
请输入q的值：1
请输入b的值：2
运算结果：qqq+bbbb=2
3、总结
1）当有一个语言需要解释执行，可将该语言中的句子表示为一个抽象语法树，就可以考虑使用解释器模式，让程1)序具有良好的扩展性
2）应用场景：编译器、运算表达式计算、正则表达式、机器人等
3）使用解释器可能带来的问题:解释器模式会引起类膨胀、解释器模式采用递归调用方法，将会导致调试非常复
杂、效率可能降低.
二十二、状态模式
1、介绍
1）状态模式(State Pattern)：它主要用来解决对象在多种状态转换时，需要对外输出不同的行为的问题。状态和行为是一一对应的，状态之间可以相互转换
2）当一个对象的内在状态改变时，允许改变其行为，这个对象看起来像是改变了其类
说明：
1）Context 类为环境角色，用于维护 State 实例,这个实例定义当前状态
2）State 是抽象状态角色，定义一个接口封装与 Context 的一个特点接口相关行为
3）ConcreteState 具体的状态角色，每个子类实现一个与 Context 的一个状态相关行为
2、案例1
1）假如每参加一次这个活动要扣除用户 50 积分，中奖概率是 10%
2）奖品数量固定，抽完就不能抽奖
3）活动有四个状态:可以抽奖、不能抽奖、发放奖品和奖品领完
4）
1、状态抽象类
/*** 状态抽象类* @author Administrator**/
public abstract class State {// 扣除积分 - 50public abstract void deductMoney();// 是否抽中奖品public abstract boolean raffle();// 发放奖品public abstract void dispensePrize();}
2、抽奖活动
/*** 抽奖活动 //* * @author Administrator**/
public class RaffleActivity {// state 表示活动当前的状态，是变化State state = null;// 奖品数量int count = 0;// 四个属性，表示四种状态State noRafflleState = new NoRaffleState(this);State canRaffleState = new CanRaffleState(this);State dispenseState = new DispenseState(this);State dispensOutState = new DispenseOutState(this);//构造器//1. 初始化当前的状态为 noRafflleState（即不能抽奖的状态）//2. 初始化奖品的数量 public RaffleActivity( int count) {this.state = getNoRafflleState();this.count = count;}//扣分, 调用当前状态的 deductMoneypublic void debuctMoney(){state.deductMoney();}//抽奖 public void raffle(){// 如果当前的状态是抽奖成功if(state.raffle()){//领取奖品state.dispensePrize();}}public State getState() {return state;}public void setState(State state) {this.state = state;}//这里请大家注意，每领取一次奖品，count--public int getCount() {int curCount = count; count--;return curCount;}public void setCount(int count) {this.count = count;}public State getNoRafflleState() {return noRafflleState;}public void setNoRafflleState(State noRafflleState) {this.noRafflleState = noRafflleState;}public State getCanRaffleState() {return canRaffleState;}public void setCanRaffleState(State canRaffleState) {this.canRaffleState = canRaffleState;}public State getDispenseState() {return dispenseState;}public void setDispenseState(State dispenseState) {this.dispenseState = dispenseState;}public State getDispensOutState() {return dispensOutState;}public void setDispensOutState(State dispensOutState) {this.dispensOutState = dispensOutState;}
}
3、不能抽奖状态
/*** 不能抽奖状态* @author Administrator**/
public class NoRaffleState extends State {// 初始化时传入活动引用，扣除积分后改变其状态RaffleActivity activity;public NoRaffleState(RaffleActivity activity) {this.activity = activity;}// 当前状态可以扣积分 , 扣除后，将状态设置成可以抽奖状态@Overridepublic void deductMoney() {System.out.println("扣除50积分成功，您可以抽奖了");activity.setState(activity.getCanRaffleState());}// 当前状态不能抽奖@Overridepublic boolean raffle() {System.out.println("扣了积分才能抽奖喔！");return false;}// 当前状态不能发奖品@Overridepublic void dispensePrize() {System.out.println("不能发放奖品");}
}
4、可以抽奖状态
/*** 可以抽奖的状态* @author Administrator**/
public class CanRaffleState extends State {RaffleActivity activity;public CanRaffleState(RaffleActivity activity) {this.activity = activity;}//已经扣除了积分，不能再扣@Overridepublic void deductMoney() {System.out.println("已经扣取过了积分");}//可以抽奖, 抽完奖后，根据实际情况，改成新的状态@Overridepublic boolean raffle() {System.out.println("正在抽奖，请稍等！");Random r = new Random();int num = r.nextInt(10);// 10%中奖机会if(num == 0){// 改变活动状态为发放奖品 contextactivity.setState(activity.getDispenseState());return true;}else{System.out.println("很遗憾没有抽中奖品！");// 改变状态为不能抽奖activity.setState(activity.getNoRafflleState());return false;}}// 不能发放奖品@Overridepublic void dispensePrize() {System.out.println("没中奖，不能发放奖品");}
}
5、发放奖品状态
/*** 发放奖品的状态* @author Administrator**/
public class DispenseState extends State {// 初始化时传入活动引用，发放奖品后改变其状态RaffleActivity activity;public DispenseState(RaffleActivity activity) {this.activity = activity;}@Overridepublic void deductMoney() {System.out.println("不能扣除积分");}@Overridepublic boolean raffle() {System.out.println("不能抽奖");return false;}//发放奖品@Overridepublic void dispensePrize() {if(activity.getCount() > 0){System.out.println("恭喜中奖了");// 改变状态为不能抽奖activity.setState(activity.getNoRafflleState());}else{System.out.println("很遗憾，奖品发送完了");// 改变状态为奖品发送完毕, 后面我们就不可以抽奖activity.setState(activity.getDispensOutState());//System.out.println("抽奖活动结束");//System.exit(0);}}
}
6、奖品发放完成状态
/*** 奖品发放完毕状态* 说明，当我们activity 改变成 DispenseOutState， 抽奖活动结束* @author Administrator**/
public class DispenseOutState extends State {// 初始化时传入活动引用RaffleActivity activity;public DispenseOutState(RaffleActivity activity) {this.activity = activity;}@Overridepublic void deductMoney() {System.out.println("奖品发送完了，请下次再参加");}@Overridepublic boolean raffle() {System.out.println("奖品发送完了，请下次再参加");return false;}@Overridepublic void dispensePrize() {System.out.println("奖品发送完了，请下次再参加");}
}
7、测试
public static void main(String[] args) {// 创建活动对象，奖品有1个奖品RaffleActivity activity = new RaffleActivity(1);// 我们连续抽300次奖for (int i = 0; i < 30; i++) {System.out.println("--------第" + (i + 1) + "次抽奖----------");// 参加抽奖，第一步点击扣除积分activity.debuctMoney();// 第二步抽奖activity.raffle();}}
--------第1次抽奖----------
扣除50积分成功，您可以抽奖了
正在抽奖，请稍等！
很遗憾没有抽中奖品！
--------第2次抽奖----------
扣除50积分成功，您可以抽奖了
正在抽奖，请稍等！
很遗憾没有抽中奖品！
--------第3次抽奖----------
扣除50积分成功，您可以抽奖了
正在抽奖，请稍等！
很遗憾没有抽中奖品！
--------第4次抽奖----------
扣除50积分成功，您可以抽奖了
正在抽奖，请稍等！
很遗憾没有抽中奖品！
--------第5次抽奖----------
扣除50积分成功，您可以抽奖了
正在抽奖，请稍等！
恭喜中奖了
…
3、案例2
借贷平台的订单，有审核-发布-抢单 等等 步骤，随着操作的不同，会改变订单的状态,项目中的这个模块实现就会使用到状态模式
1、状态接口
/*** 状态接口* @author Administrator**/
public interface State {/*** 电审*/void checkEvent(Context context);/*** 电审失败*/void checkFailEvent(Context context);/*** 定价发布*/void makePriceEvent(Context context);/*** 接单*/void acceptOrderEvent(Context context);/*** 无人接单失效*/void notPeopleAcceptEvent(Context context);/*** 付款*/void payOrderEvent(Context context);/*** 接单有人支付失效*/void orderFailureEvent(Context context);/*** 反馈*/void feedBackEvent(Context context);String getCurrentState();
}
2、默认实现
public abstract class AbstractState implements State {protected static final RuntimeException EXCEPTION = new RuntimeException("操作流程不允许");//抽象类，默认实现了 State 接口的所有方法//该类的所有方法，其子类(具体的状态类)，可以有选择的进行重写@Overridepublic void checkEvent(Context context) {throw EXCEPTION;}@Overridepublic void checkFailEvent(Context context) {throw EXCEPTION;}@Overridepublic void makePriceEvent(Context context) {throw EXCEPTION;}@Overridepublic void acceptOrderEvent(Context context) {throw EXCEPTION;}@Overridepublic void notPeopleAcceptEvent(Context context) {throw EXCEPTION;}@Overridepublic void payOrderEvent(Context context) {throw EXCEPTION;}@Overridepublic void orderFailureEvent(Context context) {throw EXCEPTION;}@Overridepublic void feedBackEvent(Context context) {throw EXCEPTION;}
}
3、环境上下文
//环境上下文
public class Context extends AbstractState{//当前的状态 state, 根据我们的业务流程处理，不停的变化private State state;@Overridepublic void checkEvent(Context context) {state.checkEvent(this);getCurrentState();}@Overridepublic void checkFailEvent(Context context) {state.checkFailEvent(this);getCurrentState();}@Overridepublic void makePriceEvent(Context context) {state.makePriceEvent(this);getCurrentState();}@Overridepublic void acceptOrderEvent(Context context) {state.acceptOrderEvent(this);getCurrentState();}@Overridepublic void notPeopleAcceptEvent(Context context) {state.notPeopleAcceptEvent(this);getCurrentState();}@Overridepublic void payOrderEvent(Context context) {state.payOrderEvent(this);getCurrentState();}@Overridepublic void orderFailureEvent(Context context) {state.orderFailureEvent(this);getCurrentState();}@Overridepublic void feedBackEvent(Context context) {state.feedBackEvent(this);getCurrentState();}public State getState() {return state;}public void setState(State state) {this.state = state;}@Overridepublic String getCurrentState() {System.out.println("当前状态 : " + state.getCurrentState());return state.getCurrentState();}
}
4、状态枚举类
/*** 状态枚举类* @author Administrator**/
public enum StateEnum {//订单生成GENERATE(1, "GENERATE"),//已审核REVIEWED(2, "REVIEWED"),//已发布PUBLISHED(3, "PUBLISHED"),//待付款NOT_PAY(4, "NOT_PAY"),//已付款PAID(5, "PAID"),//已完结FEED_BACKED(6, "FEED_BACKED");private int key;private String value;StateEnum(int key, String value) {this.key = key;this.value = value;}public int getKey() {return key;}public String getValue() {return value;}
}
5、各种具体状态类
//各种具体状态类
class FeedBackState extends AbstractState {@Overridepublic String getCurrentState() {return StateEnum.FEED_BACKED.getValue();}
}class GenerateState extends AbstractState {@Overridepublic void checkEvent(Context context) {context.setState(new ReviewState());}@Overridepublic void checkFailEvent(Context context) {context.setState(new FeedBackState());}@Overridepublic String getCurrentState() {return StateEnum.GENERATE.getValue();}
}class NotPayState extends AbstractState {@Overridepublic void payOrderEvent(Context context) {context.setState(new PaidState());}@Overridepublic void feedBackEvent(Context context) {context.setState(new FeedBackState());}@Overridepublic String getCurrentState() {return StateEnum.NOT_PAY.getValue();}
}class PaidState extends AbstractState {@Overridepublic void feedBackEvent(Context context) {context.setState(new FeedBackState());}@Overridepublic String getCurrentState() {return StateEnum.PAID.getValue();}
}class PublishState extends AbstractState {@Overridepublic void acceptOrderEvent(Context context) {//把当前状态设置为 NotPayState。。。//至于应该变成哪个状态，有流程图来决定context.setState(new NotPayState());}@Overridepublic void notPeopleAcceptEvent(Context context) {context.setState(new FeedBackState());}@Overridepublic String getCurrentState() {return StateEnum.PUBLISHED.getValue();}
}class ReviewState extends AbstractState {@Overridepublic void makePriceEvent(Context context) {context.setState(new PublishState());}@Overridepublic String getCurrentState() {return StateEnum.REVIEWED.getValue();}}
6、测试
public static void main(String[] args) {//创建context 对象Context context = new Context();//将当前状态设置为 PublishStatecontext.setState(new PublishState());System.out.println(context.getCurrentState());// //publish --> not paycontext.acceptOrderEvent(context);
// //not pay --> paidcontext.payOrderEvent(context);
// // 失败, 检测失败时，会抛出异常
// try {
// context.checkFailEvent(context);
// System.out.println("流程正常..");
// } catch (Exception e) {
// // TODO: handle exception
// System.out.println(e.getMessage());
// }}
当前状态 : PUBLISHED
PUBLISHED
当前状态 : NOT_PAY
当前状态 : PAID
4、总结
1）代码有很强的可读性。状态模式将每个状态的行为封装到对应的一个类中
2）方便维护。将容易产生问题的 if-else 语句删除了，如果把每个状态的行为都放到一个类中，每次调用方法时都要判断当前是什么状态，不但会产出很多if-else 语句，而且容易出错
3）符合“开闭原则”。容易增删状态
4）会产生很多类。每个状态都要一个对应的类，当状态过多时会产生很多类，加大维护难度
5）应用场景：当一个事件或者对象有很多种状态，状态之间会相互转换，对不同的状态要求有不同的行为的时候可以考虑使用状态模式
二十三、策略模式
1、介绍
1）策略模式(Strategy Pattern)中，定义算法族(策略组)，分别封装起来，让他们之间可以互相替换，此模式
让算法的变化独立于使用算法的客户
2）这算法体现了几个设计原则，第一、把变化的代码从不变的代码中分离出来;第二、针对接口编程而不是具体类(定义了策略接口)，第三、多用组合/聚合，少用继承(客户通过组合方式使用策略)。
2、案例
有各种鸭子(比如 野鸭、北京鸭、水鸭等，鸭子有各种行为，比如 叫、飞行等)，显示鸭子的信息。
1、飞的接口
public interface FlyBehavior {void fly(); // 子类具体实现
}
2、不会飞
public class NoFlyBehavior implements FlyBehavior{@Overridepublic void fly() {System.out.println(" 不会飞翔 ");}}
3、飞翔技术一般
public class BadFlyBehavior implements FlyBehavior {@Overridepublic void fly() {System.out.println(" 飞翔技术一般 ");}}
4、飞翔技术高超
public class GoodFlyBehavior implements FlyBehavior {@Overridepublic void fly() {System.out.println(" 飞翔技术高超 ~~~");}}
5、鸭子行为接口
public interface QuackBehavior {void quack();//子类实现
}
6、鸭子抽象类
public abstract class Duck {//属性, 策略接口FlyBehavior flyBehavior;//其它属性<->策略接口QuackBehavior quackBehavior;public Duck() {}public abstract void display();//显示鸭子信息public void quack() {System.out.println("鸭子嘎嘎叫~~");}public void swim() {System.out.println("鸭子会游泳~~");}public void fly() {//改进if(flyBehavior != null) {flyBehavior.fly();}}public void setFlyBehavior(FlyBehavior flyBehavior) {this.flyBehavior = flyBehavior;}public void setQuackBehavior(QuackBehavior quackBehavior) {this.quackBehavior = quackBehavior;}
}
7、北京鸭
public class PekingDuck extends Duck {//假如北京鸭可以飞翔，但是飞翔技术一般public PekingDuck() {flyBehavior = new BadFlyBehavior();}@Overridepublic void display() {System.out.println("~~北京鸭~~~");}
}
8、玩具鸭
public class ToyDuck extends Duck{public ToyDuck() {flyBehavior = new NoFlyBehavior();}@Overridepublic void display() {System.out.println("玩具鸭");}//需要重写父类的所有方法public void quack() {System.out.println("玩具鸭不能叫~~");}public void swim() {System.out.println("玩具鸭不会游泳~~");}
}
9、野鸭
public class WildDuck extends Duck {//构造器，传入FlyBehavor 的对象public WildDuck() {flyBehavior = new GoodFlyBehavior();}@Overridepublic void display() {System.out.println(" 这是野鸭 ");}}
10、测试
public static void main(String[] args) {WildDuck wildDuck = new WildDuck();wildDuck.fly();//ToyDuck toyDuck = new ToyDuck();toyDuck.fly();PekingDuck pekingDuck = new PekingDuck();pekingDuck.fly();//动态改变某个对象的行为, 北京鸭 不能飞pekingDuck.setFlyBehavior(new NoFlyBehavior());System.out.println("北京鸭的实际飞翔能力");pekingDuck.fly();}
飞翔技术高超 ~~~
不会飞翔
飞翔技术一般
北京鸭的实际飞翔能力
不会飞翔
3、总结
1）策略模式的关键是：分析项目中变化部分与不变部分
2）策略模式的核心思想是：多用组合/聚合 少用继承；用行为类组合，而不是行为的继承。更有弹性
3）体现了“对修改关闭，对扩展开放”原则，客户端增加行为不用修改原有代码，只要添加一种策略(或者行为)即可，避免了使用多重转移语句(if…else if…else)
4）提供了可以替换继承关系的办法: 策略模式将算法封装在独立的 Strategy 类中使得你可以独立于其 Context改变它，使它易于切换、易于理解、易于扩展
5）需要注意的是：每添加一个策略就要增加一个类，当策略过多是会导致类数目庞大。
二十四、职责链模式
1、介绍
1）职责链模式(Chain ofResponsibility Patter)，又叫 责任链模式，为请求创建了一个接收者对象的链(简单示意图)。这种模式对请求的发送者和接收者进行解耦。
2）职责链模式通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。
3）这种类型的设计模式属于行为型模式
说明：
1）Handler：抽象的处理者，定义了一个处理请求的接口，同时含有另外 Handler
2）ConcreteHandlerA,B 是具体的处理者，处理它自己负责的请求， 可以访问它的后继者(即下一个处理者)，如果可以处理当前请求，则处理，否则就将该请求交个后继者去处理，从而形成一个职责链
3）Request，含有很多属性，表示一个请求
2、案例
编写程序完成学校 OA 系统的采购审批项目:需求
采购员采购教学器材
如果金额 小于等于 5000，由教学主任审批
如果金额 小于等于 10000，由院长审批
如果金额 小于等于 30000,由副校长审批
如果金额 超过 30000 以上，有校长审批
1、请求类
//请求类
public class PurchaseRequest {private int type = 0; //请求类型private float price = 0.0f; //请求金额private int id = 0;//构造器public PurchaseRequest(int type, float price, int id) {this.type = type;this.price = price;this.id = id;}public int getType() {return type;}public float getPrice() {return price;}public int getId() {return id;}}
2、处理类
public abstract class Approver {Approver approver; //下一个处理者String name; // 名字public Approver(String name) {// TODO Auto-generated constructor stubthis.name = name;}//下一个处理者public void setApprover(Approver approver) {this.approver = approver;}//处理审批请求的方法，得到一个请求, 处理是子类完成，因此该方法做成抽象public abstract void processRequest(PurchaseRequest purchaseRequest);}
3、部门
public class DepartmentApprover extends Approver {public DepartmentApprover(String name) {super(name);}@Overridepublic void processRequest(PurchaseRequest purchaseRequest) {if(purchaseRequest.getPrice() <= 5000) {System.out.println(" 请求编号 id= " + purchaseRequest.getId() + " 被 " + this.name + " 处理");}else {approver.processRequest(purchaseRequest);}}}
4、学院
public class CollegeApprover extends Approver {public CollegeApprover(String name) {super(name);}@Overridepublic void processRequest(PurchaseRequest purchaseRequest) {if(purchaseRequest.getPrice() < 5000 && purchaseRequest.getPrice() <= 10000) {System.out.println(" 请求编号 id= " + purchaseRequest.getId() + " 被 " + this.name + " 处理");}else {approver.processRequest(purchaseRequest);}}
}
5、副校长
public class ViceSchoolMasterApprover extends Approver {public ViceSchoolMasterApprover(String name) {super(name);}@Overridepublic void processRequest(PurchaseRequest purchaseRequest) {if(purchaseRequest.getPrice() < 10000 && purchaseRequest.getPrice() <= 30000) {System.out.println(" 请求编号 id= " + purchaseRequest.getId() + " 被 " + this.name + " 处理");}else {approver.processRequest(purchaseRequest);}}
}
6、校长
public class SchoolMasterApprover extends Approver {public SchoolMasterApprover(String name) {super(name);}@Overridepublic void processRequest(PurchaseRequest purchaseRequest) {if(purchaseRequest.getPrice() > 30000) {System.out.println(" 请求编号 id= " + purchaseRequest.getId() + " 被 " + this.name + " 处理");}else {approver.processRequest(purchaseRequest);}}
}
7、测试
public static void main(String[] args) {//创建一个请求PurchaseRequest purchaseRequest = new PurchaseRequest(1, 31000, 1);//创建相关的审批人DepartmentApprover departmentApprover = new DepartmentApprover("张主任");CollegeApprover collegeApprover = new CollegeApprover("李院长");ViceSchoolMasterApprover viceSchoolMasterApprover = new ViceSchoolMasterApprover("王副校");SchoolMasterApprover schoolMasterApprover = new SchoolMasterApprover("佟校长");//需要将各个审批级别的下一个设置好 (处理人构成环形: )departmentApprover.setApprover(collegeApprover);collegeApprover.setApprover(viceSchoolMasterApprover);viceSchoolMasterApprover.setApprover(schoolMasterApprover);schoolMasterApprover.setApprover(departmentApprover);departmentApprover.processRequest(purchaseRequest);viceSchoolMasterApprover.processRequest(purchaseRequest);
}
请求编号 id= 1 被 佟校长 处理
请求编号 id= 1 被 佟校长 处理
3、总结
1）将请求和处理分开，实现解耦，提高系统的灵活性
2）简化了对象，使对象不需要知道链的结构
3）性能会受到影响，特别是在链比较长的时候，因此需控制链中最大节点数量，，一般通过在 Handler 中设置一个最大节点数量，在 seNext0方法中判断是否已经超过阀值，超过则不允许该链建立，避免出现超长链无意识地破坏系统性能
4）调试不方便。采用了类似递归的方式，调试时逻辑可能比较复杂
5）最佳应用场景：有多个对象可以处理同一个请求时,比如: 多级请求、请假/加薪等审批流程、Java Web 中 Tomcat对 Encoding 的处理、拦截器
