设计模式 Day08
文章总结自B站尚硅谷
1. 备忘录模式
在不破坏封装性的前提下，捕获一个对象的内部状态，并在改对象之外保存这个状态。这样以后就可以将该对象恢复到原先保存的状态。
案例：游戏角色，有战时状态和正常状态，在不打仗时为正常状态，打完之后恢复到正常状态。
保存的对象：
/**
* 原始对象
* @date 2020/8/31 8:22
*/
public class Originator {
private String state;
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
/**
* 保存状态对象
* @return
*/
public Memento saveState(){
return new Memento(state);
}
/**
* 得到状态
* @param memento
*/
public void getStateFormMemento(Memento memento){
state = memento.getState();
}
/**
* 显示状态
*/
public void display(){
System.out.println("****----------****");
System.out.println("当前状态"+this.state);
}
}
备忘录对象：
/**
* 备忘录对象
* @date 2020/8/31 8:23
*/
public class Memento {
private String state;
public Memento(String state) {
this.state = state;
}
public String getState() {
return state;
}
}
对象中心：
/**
* 对象管理中心-负责保存多个备忘录对象
* @date 2020/8/31 8:30
*/
public class Caretaker {
// 一个游戏角色
private Memento memento;
// 多次保存状态
private List<Memento> mementos = new ArrayList<>();
// 对多个游戏角色保存状态
private HashMap<String ,List<Memento>> roleMementos;
/**
* 添加memento对象
* @param memento
*/
public void addMemento(Memento memento){
this.memento = memento;
}
/**
* 多次保存状态
* @param memento
*/
public void addMementoList(Memento memento){
mementos.add(memento);
}
/**
* 获取指定index的memento对象即保存的状态
* @return memento
*/
public Memento getMemento(int index){
return mementos.get(index);
}
/**
* 单个对象单次保存
* @return
*/
public Memento getMemento(){
return memento;
}
}
客户端：
/**
* @date 2020/8/31 8:33
*/
public class Client {
public static void main(String[] args) {
// 原始对象
Originator originator = new Originator();
// 管理中心对象
Caretaker caretaker = new Caretaker();
// 设置原始状态
originator.setState(" 正常状态 ");
originator.display();
// 将当前状态保存到管理中心
caretaker.addMemento(originator.saveState());
caretaker.addMementoList(originator.saveState());
// 设置新的状态
originator.setState(" 战时状态 ");
originator.display();
originator.saveState();
// 恢复状态
originator.getStateFormMemento(caretaker.getMemento(0));
originator.display();
}
}
细节和注意事项：
- 实现了信息的封装，使得用户不需要关系状态的保存细节；
- 如果类的成员过多，会占有过多的资源；
- 适用于需要数据回退的场景；
- 可以和原型模式配合使用
2. 解释器模式
给定一个表达式，定义它的文法的一种表示，并给定一个解释器，用解释器来解释表达式。
案例：多数加减法运算。
在Spring框架的SpelExpressionParser中用到了解释器模式
注意事项和细节：
- 当有一个语言需要解释执行，可将改语言的句子表示为一个抽象语法树，就可以使用解释器模式，这样程序有更好的扩展性，一般用于编译器，运算表达式计算等。
- 会引起类膨胀，解释器模式采用递归调用方法，导致调试复杂，效率低下。
3. 状态模式
主要用来解决对象在多个状态转换时，需要对外输出不同的行文的问题。状态和行为是一一对应的，状态之间可以互相转换；当一个对象的内在状态改变时，允许改变其行为，这个对象看起来像是改变了其类。
案例：抽奖活动，用户没参加一次需要扣除50积分，中奖概率为10%；奖品数量固定，抽完就不能再抽；活动有四个状态：可以抽奖、不能抽奖、发放奖品和奖品领完。
注意事项和细节：
- 代码有很多的可读性，状态模式将每个状态的行为封装到一个类中；
- 方便维护，将容易出错的if-else语句删除了，如果把每个状态的行为都放到一个类中，没错调用方法时都需要判断当前是什么状态，不但会产生很多的if-else语句，而且容易出错；
- 符合开闭原则ocp。容易判断增删状态。
- 会产生很多的类，每个状态都要一个对应的类，当状态过多时会产生很多类，加大维护难度；
- 当要一个事件或者对象有很多状态，状态之间会相互切换，对不同的状态要求有所不同的行为的时候，适合使用该模式。
4. 策略模式
定义算法族，分别封装起来，让他们之间可以互相替换，此模式让算法独立于使用算法的用户。
体现的设计原则：把变化的代码从不变的代码中分离出来；针对接口编程；多用组合/聚合，少用继承。
案例：鸭子的问题。有各种鸭子，如：北京鸭子、野鸭等。也有很多的行为，如：飞行、吃、叫等。显示鸭子的信息。
鸭子行为类：
/**
* @date 2020/8/31 14:15
*/
public abstract class Duck {
// 策略属性接口
FlyBehavior flyBehavior;
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;
}
}
飞行行为接口：
/**
* 飞动作接口
* @date 2020/8/31 14:27
*/
public interface FlyBehavior {
void fly();
}
根据不同鸭子的不同飞行能力分为：飞的好、飞的不好、不会飞
/**
* 飞的好动作实现类
* @date 2020/8/31 14:27
*/
public class GoodFlyBehaviorImpl implements FlyBehavior {
@Override
public void fly() {
System.out.println(" 飞的好 ");
}
}
/**
* 飞的不好实现类
* @date 2020/8/31 14:29
*/
public class BadFlyBehaviorImpl implements FlyBehavior {
@Override
public void fly() {
System.out.println(" 分的不好 ");
}
}
/**
* 不会飞的实现类
* @date 2020/8/31 14:28
*/
public class NotFlyBehaviorImpl implements FlyBehavior {
@Override
public void fly() {
System.out.println(" 不会飞 ");
}
}
鸭子类：
北京鸭：
/**
* 北京鸭子
* @date 2020/8/31 14:17
*/
public class PekingDuck extends Duck{
public PekingDuck() {
flyBehavior = new BadFlyBehaviorImpl();
}
@Override
public void display() {
System.out.println(" 北京鸭子 ");
}
}
野鸭：
/**
* 野鸭
* @date 2020/8/31 14:17
*/
public class WildDuck extends Duck{
public WildDuck() {
flyBehavior = new GoodFlyBehaviorImpl();
}
@Override
public void display() {
System.out.println("野鸭");
}
}
客户端：
/**
* @date 2020/8/31 14:33
*/
public class Client {
public static void main(String[] args) {
WildDuck wildDuck = new WildDuck();
wildDuck.fly();
// 动态的改变鸭子的行为。
wildDuck.setFlyBehavior(new BadFlyBehaviorImpl());
wildDuck.fly();
}
}
改模式好就好在可以根据实际的不同行为去编写不同的实现类，接口编程。
策略模式在JDK的Arrays在进行排序时中有使用
注意事项和细节：
- 多用聚合/组合，少用继承，用行为类组合，而不是行为类继承。使得项目更加灵活多变。
- ocp的对修改关闭，对扩展开发原则进行符合，
- 提供了可以替换继承的方法，使它易于扩展切换和理解。
- 会导致类的数量过多。
5. 职责链模式
又叫责任链模式，为请求创建一个接收者对象的链。这种模式对请求的发送者和接收者进行解耦。这种模式通常每个接收者都包括对另一个接收者的引用，如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者。
案例：oa系统采购，金额小于等于5k，由教学主任批准、金额小于等于10k，由院长批准、金额小于等于30k，由副校长批准、金额大于30k，由校长批准。
请求类：
/**
* 请求
* @date 2020/8/31 15:06
*/
public class PurchaseRequest {
// 请求id
private int id = 0;
// 请求类型
private int type;
// 请求价格
private float price = 0.0f;
public PurchaseRequest(int id, int type, float price) {
this.id = id;
this.type = type;
this.price = price;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
}
处理中心：
/**
* @date 2020/8/31 15:10
*/
public abstract class Approver {
Approver approver;
String name;
public Approver(String name) {
this.name = name;
}
// 设置下一个处理者
public void setApprover(Approver approver) {
this.approver = approver;
}
// 处理审批请求的方法，得到一个请求。
public abstract void processRequest(PurchaseRequest purchaseRequest);
}
处理级别（主任、院长、副校长、校长）
/**
* 系
* @date 2020/8/31 15:16
*/
public class DepartmentApprover extends Approver {
public DepartmentApprover(String name) {
super(name);
}
@Override
public void processRequest(PurchaseRequest purchaseRequest) {
if (purchaseRequest.getPrice() <= 5000){
System.out.println(this.name+"审批了请求编号为"+purchaseRequest.getId()+"的申请");
}else {
approver.processRequest(purchaseRequest);
}
}
}
/**
* 学院
* @date 2020/8/31 15:19
*/
public class CollegeApprover extends Approver {
public CollegeApprover(String name) {
super(name);
}
@Override
public void processRequest(PurchaseRequest purchaseRequest) {
if (purchaseRequest.getPrice() >= 5000 && purchaseRequest.getPrice() <= 10000){
System.out.println(this.name+"审批了请求编号为"+purchaseRequest.getId()+"的申请");
}else {
approver.processRequest(purchaseRequest);
}
}
}
/**
* 副校长
* @date 2020/8/31 15:21
*/
public class ViceSchoolApprover extends Approver {
public ViceSchoolApprover(String name) {
super(name);
}
@Override
public void processRequest(PurchaseRequest purchaseRequest) {
if (purchaseRequest.getPrice() >= 10000 && purchaseRequest.getPrice() <= 30000){
System.out.println(this.name+"审批了请求编号为"+purchaseRequest.getId()+"的申请");
}else {
approver.processRequest(purchaseRequest);
}
}
}
/**
* 校长
* @date 2020/8/31 15:21
*/
public class SchoolApprover extends Approver{
public SchoolApprover(String name) {
super(name);
}
@Override
public void processRequest(PurchaseRequest purchaseRequest) {
if ( purchaseRequest.getPrice() >= 30000){
System.out.println(this.name+"审批了请求编号为"+purchaseRequest.getId()+"的申请");
}else {
approver.processRequest(purchaseRequest);
}
}
}
客户端：
/**
* @date 2020/8/31 15:22
*/
public class Client {
public static void main(String[] args) {
PurchaseRequest purchaseRequest = new PurchaseRequest(1, 3, 40000);
DepartmentApprover departmentApprover = new DepartmentApprover("张主任");
CollegeApprover collegeApprover = new CollegeApprover("李院长");
ViceSchoolApprover viceSchoolApprover = new ViceSchoolApprover("周副校长");
SchoolApprover schoolApprover = new SchoolApprover("王校长");
// 设置好审批下一个级别，形成环形
departmentApprover.setApprover(collegeApprover);
collegeApprover.setApprover(viceSchoolApprover);
viceSchoolApprover.setApprover(schoolApprover);
schoolApprover.setApprover(departmentApprover);
departmentApprover.processRequest(purchaseRequest);
}
}
在SpringMVC的HandlerExecutionChina中用到了
注意事项和细节
- 将请求和解耦分开，实现解耦，提高系统的灵活性。
- 简化了对象，使对象不需要知道链的结构。
- 性能会受到影响。
- 调试不方便。
- 一般用于多级请求、请假/加薪等审批流程。
扫一扫
1955
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
