设计模式(八)

2024-02-17 18:14:58

解释器模式

四则运算问题

通过解释器模式来实现四则运算，如计算a+b-c的值，具体要求1.先输入表达式的形式，比如 a+b+c-d+e, 要求表达式的字母不能重复 2.在分别输入a ,b, c, d, e 的值 3) 最后求出结果：

传统方案解决四则运算问题分析

编写一个方法，接收表达式的形式，然后根据用户输入的数值进行解析，得到结果
问题分析：如果加入新的运算符，比如 * / ( 等等，不利于扩展，另外让一个方法来解析会造成程序结构混乱，不够清晰.
解决方案：可以考虑使用解释器模式，即：表达式 -> 解释器(可以有多种) -> 结果

解释器模式基本介绍

在编译原理中，一个算术表达式通过词法分析器形成词法单元，而后这些词法单元再通过语法分析器构建语法分析树，最终形成一颗抽象的语法分析树。这里的词法分析器和语法分析器都可以看做是解释器
解释器模式（Interpreter Pattern）：是指给定一个语言(表达式)，定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子(表达式)
应用场景
• 应用可以将一个需要解释执行的语言中的句子表示为一个抽象语法树
• 一些重复出现的问题可以用一种简单的语言来表达
• 一个简单语法需要解释的场景
这样的例子还有，比如编译器、运算表达式计算、正则表达式、机器人等

Context: 是环境角色,含有解释器之外的全局信息.
AbstractExpression: 抽象表达式，声明一个抽象的解释操作,这个方法为抽象语法树中所有的节点所共享
TerminalExpression: 为终结符表达式, 实现与文法中的终结符相关的解释操作
NonTermialExpression: 为非终结符表达式，为文法中的非终结符实现解释操作.
说明：输入Context 和 TerminalExpression信息通过Client输入即可

代码实现

//抽象表达式
public abstract class Expression {
    public abstract int interpreter(HashMap<String, Integer> var);
}
//变量表达式
public class VarExpression extends Expression {
    private String key;

    public VarExpression(String key) {
        this.key = key;
    }
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return var.get(this.key);
    }
}
public class SymbolExpression extends Expression {
    protected Expression left;
    protected Expression right;

    public SymbolExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpreter(HashMap<String, Integer> var) {
        // TODO Auto-generated method stub
        return 0;
    }
}
public class AddExpression extends SymbolExpression {

    public AddExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return super.left.interpreter(var) + super.right.interpreter(var);
    }
}
public class SubExpression extends SymbolExpression {
    public SubExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return super.left.interpreter(var) - super.right.interpreter(var);
    }
}
//计算器
public class Calculator {
    // 定义表达式
    private Expression expression;

    // 构造函数传参，并解析
    public Calculator(String expStr) {
        // 安排运算先后顺序
        Stack<Expression> stack = new Stack<>();
        char[] charArray = expStr.toCharArray();

        Expression left = null;
        Expression right = null;
        for (int i = 0; i < charArray.length; i++) {
            switch (charArray[i]) {
                case '+': //
                    left = stack.pop();//
                    right = new VarExpression(String.valueOf(charArray[++i]));//
                    stack.push(new AddExpression(left, right));//
                    break;
                case '-': //
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new SubExpression(left, right));
                    break;
                default:
                    stack.push(new VarExpression(String.valueOf(charArray[i])));
                    break;
            }
        }
        this.expression = stack.pop();
    }

    public int run(HashMap<String, Integer> var) {
        return this.expression.interpreter(var);
    }
}
//客户端
public class Client {
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        String expStr = getExpStr();
        HashMap<String, Integer> var = getValue(expStr);
        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;
    }
}

解释器模式的注意事项和细节

当有一个语言需要解释执行，可将该语言中的句子表示为一个抽象语法树，就可以考虑使用解释器模式，让程序具有良好的扩展性
应用场景：编译器、运算表达式计算、正则表达式、机器人等
使用解释器可能带来的问题：解释器模式会引起类膨胀、解释器模式采用递归调用方法，将会导致调试非常复杂、效率可能降低.

状态模式

APP抽奖活动问题

请编写程序完成APP抽奖活动具体要求如下:

假如每参加一次这个活动要扣除用户50积分，中奖概率是10%
奖品数量固定，抽完就不能抽奖
活动有四个状态: 可以抽奖、不能抽奖、发放奖品和奖品领完
活动的四个状态转换关系图

状态模式基本介绍

状态模式（State Pattern）：它主要用来解决对象在多种状态转换时，需要对外输出不同的行为的问题。状态和行为是一一对应的，状态之间可以相互转换。当一个对象的内在状态改变时，允许改变其行为，这个对象看起来像是改变了其类。

Context类为环境角色, 用于维护State实例,这个实例定义当前状态
State 是抽象状态角色,定义一个接口封装与Context的一个特点接口相关行为
ConcreteState 具体的状态角色，每个子类实现一个与Context 的一个状态相关行为

代码实现

//状态抽象类
public abstract class State {
    //扣积分
    public abstract void deductMoney();
    //抽奖
    public abstract boolean raffle();
    //领奖品
    public abstract  void dispensePrize();
}
//具体状态类
//不能抽奖
public class NoRaffleState extends State {
    private RaffleActivity activity;

    public NoRaffleState(RaffleActivity activity) {
        this.activity = activity;
    }

    @Override
    public void deductMoney() {
        System.out.println("扣除50积分成功，您可以抽奖了");
        activity.setState(activity.getCanRaffleState());
    }
    //当前状态为不能抽奖
    @Override
    public boolean raffle() {
        System.out.println("扣了积分才能抽奖喔！");
        return false;
    }
    //当前状态为不能抽奖
    @Override
    public void dispensePrize() {
        System.out.println("不能发放奖品");
    }
}
//可以抽奖
public class CanRaffleState extends State{
    private RaffleActivity activity;

    public CanRaffleState(RaffleActivity activity) {
        this.activity = activity;
    }

    @Override
    public void deductMoney() {
        System.out.println("已经扣取过了积分");
    }

    @Override
    public boolean raffle() {
        System.out.println("正在抽奖，请稍等！");
        Random r = new Random();
        int num = r.nextInt(10);
        // 10%中奖机会
        if(num == 0){
            // 改变活动状态为发放奖品
            activity.setState(activity.getDispenseState());
            return true;
        }else{
            System.out.println("很遗憾没有抽中奖品！");
            // 改变状态为不能抽奖
            activity.setState(activity.getNoRafflleState());
            return false;
        }
    }

    @Override
    public void dispensePrize() {
        System.out.println("没中奖，不能发放奖品");
    }
}
//领奖品
public class DispenseState extends State {
    private RaffleActivity activity;

    public DispenseState(RaffleActivity activity) {
        this.activity = activity;
    }

    @Override
    public void deductMoney() {
        System.out.println("不能扣除积分");
    }

    @Override
    public boolean raffle() {
        System.out.println("不能抽奖");
        return false;
    }

    @Override
    public void dispensePrize() {
        if(activity.getCount() > 0){
            System.out.println("恭喜中奖了");
            // 改变状态为不能抽奖
            activity.setState(activity.getNoRafflleState());
        }else{
            System.out.println("很遗憾，奖品发送完了");
            // 改变状态为奖品发送完毕
            activity.setState(activity.getDispensOutState());
        }
    }
}
//不能领奖品
public class DispenseOutState extends State {
    private RaffleActivity activity;

    public DispenseOutState(RaffleActivity activity) {
        this.activity = activity;
    }

    @Override
    public void deductMoney() {
        System.out.println("奖品发送完了，请下次再参加");
    }

    @Override
    public boolean raffle() {
        System.out.println("奖品发送完了，请下次再参加");
        return false;
    }

    @Override
    public void dispensePrize() {
        System.out.println("奖品发送完了，请下次再参加");
    }
}
//活动类
public class RaffleActivity {
    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);

    public RaffleActivity( int count) {
        this.state = getNoRafflleState();
        this.count = count;
    }

    public 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;
    }

    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;
    }
}
//客户端
// 创建活动对象，奖品池有5个奖品
RaffleActivity activity = new RaffleActivity(1);

// 我们连续抽三次奖
for (int i = 0; i < 30; i++) {
    System.out.println("--------第" + (i + 1) + "次抽奖----------");
    // 参加抽奖，第一步点击扣除积分
    activity.debuctMoney();

    // 第二步抽奖
    activity.raffle();
}

注意实现

代码有很强的可读性。状态模式将每个状态的行为封装到对应的一个类中
方便维护。将容易产生问题的if-else语句删除了，如果把每个状态的行为都放到一个类中，每次调用方法时都要判断当前是什么状态，不但会产出很多if-else语句，而且容易出错
符合“开闭原则”。容易增删状态
会产生很多类。每个状态都要一个对应的类，当状态过多时会产生很多类，加大维护难度
应用场景：当一个事件或者对象有很多种状态，状态之间会相互转换，对不同的状态要求有不同的行为的时候，可以考虑使用状态模式

策略模式

鸭子问题

编写鸭子项目，具体要求如下: 1.有各种鸭子(比如野鸭、北京鸭、水鸭等，鸭子有各种行为，比如叫、飞行等) 2.显示鸭子的信息

传统方案解决鸭子问题

其它鸭子，都继承了Duck类，所以fly让所有子类都会飞了，这是不正确的
上面说的1 的问题，其实是继承带来的问题：对类的局部改动，尤其超类的局部改动，会影响其他部分。会有溢出效应
为了改进1问题，我们可以通过覆盖fly 方法来解决 => 覆盖解决
问题又来了，如果我们有一个玩具鸭子ToyDuck, 这样就需要ToyDuck去覆盖Duck 的所有实现的方法 => 解决思路策略模式 (strategy pattern)

策略模式基本介绍

策略模式（Strategy Pattern）中，定义算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。这算法体现了几个设计原则，第一、把变化的代码从不变的代码中分离出来；第二、针对接口编程而不是具体类（定义了策略接口）；第三、多用组合/聚合，少用继承（客户通过组合方式使用策略）。

代码实现

//定义策略接口
public interface Fly {
    void fly();
}
//具体策略
public class GoodFly implements Fly {
    @Override
    public void fly() {
        System.out.println("高超的飞行技术");
    }
}
public class NoFly implements Fly {
    @Override
    public void fly() {
        System.out.println("不会飞行技术");
    }
}
public class BadFly implements Fly {
    @Override
    public void fly() {
        System.out.println("一般的飞行技术");
    }
}
//不变的部分
public abstract class Duck {
    private Fly fly;

    public Duck(Fly fly) {
        this.fly = fly;
    }


    public void setFly(Fly fly) {
        this.fly = fly;
    }

    public void fly(){
        fly.fly();
    }
}
public class WildDuck extends Duck {
    public WildDuck(Fly fly) {
        super(fly);
    }
}
public class PekingDuck extends Duck {
    public PekingDuck(Fly fly) {
        super(fly);
    }
}
//客户端
Duck wildDuck = new WildDuck(new GoodFly());
wildDuck.fly();
Duck pekingDuck = new PekingDuck(new BadFly());
pekingDuck.fly();

策略模式的注意事项和细节

策略模式的关键是：分析项目中变化部分与不变部分
策略模式的核心思想是：多用组合/聚合，少用继承；用行为类组合，而不是行为的继承。更有弹性
体现了“对修改关闭，对扩展开放”原则，客户端增加行为不用修改原有代码，只要添加一种策略（或者行为）即可，避免了使用多重转移语句（if..else if..else)
提供了可以替换继承关系的办法：策略模式将算法封装在独立的Strategy类中使得你可以独立于其Context改变它，使它易于切换、易于理解、易于扩展
需要注意的是：每添加一个策略就要增加一个类，当策略过多是会导致类数目庞大

责任链模式

OA系统采购审批需求

学校OA系统的采购审批项目：需求是

采购员采购教学器材
如果金额小于等于5000, 由教学主任审批（0<=x<=5000）
如果金额小于等于10000, 由院长审批 (5000）
如果金额小于等于30000, 由副校长审批 (10000）
如果金额超过30000以上，有校长审批 ( 30000）

传统方案解决OA系统审批

传统方式是：接收到一个采购请求后，根据采购金额来调用对应的Approver (审批人)完成审批。
传统方式的问题分析 : 客户端这里会使用到分支判断(比如 switch) 来对不同的采购请求处理，这样就存在如下问题 (1) 如果各个级别的人员审批金额发生变化，在客户端的也需要变化 (2) 客户端必须明确的知道有多少个审批级别和访问
这样对一个采购请求进行处理和 Approver (审批人) 就存在强耦合关系，不利于代码的扩展和维护
解决方案 =》职责链模式

职责链模式基本介绍

职责链模式（Chain of Responsibility Pattern）, 又叫责任链模式，为请求创建了一个接收者对象的链(简单示意图)。这种模式对请求的发送者和接收者进行解耦。职责链模式通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。这种类型的设计模式属于行为型模式。

职责链模式（Chain Of Responsibility），使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止.

Handler : 抽象的处理者, 定义了一个处理请求的接口, 同时含义另外Handler
ConcreteHandlerA , B 是具体的处理者, 处理它自己负责的请求，可以访问它的后继者(即下一个处理者), 如果可以处理当前请求，则处理，否则就将该请求交个后继者去处理，从而形成一个职责链
Request ，含义很多属性，表示一个请求

代码实现

//抽象处理者
public abstract class Approver {
    private Approver approver;//下一个处理请求者
    private String name;

    public Approver(String name) {
        this.name = name;
    }

    public void setApprover(Approver approver) {
        this.approver = approver;
    }

    public Approver getApprover() {
        return approver;
    }

    public String getName() {
        return name;
    }

    public abstract void processRequest(PurchaseRequest request);
}
//具体处理中
public class DepartmentApprover extends Approver {
    public DepartmentApprover(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if(request.getPrice() <= 5000){
            System.out.println("请求id: " + request.getId() + "被" + this.getName() + "处理，金额为" + request.getPrice());
        }else{
            this.getApprover().processRequest(request);
        }
    }
}
public class CollegeApprover extends Approver {
    public CollegeApprover(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if(request.getPrice() <= 10000 && request.getPrice() > 5000){
            System.out.println("请求id: " + request.getId() + "被" + this.getName() + "处理，金额为" + request.getPrice());
        }else{
            this.getApprover().processRequest(request);
        }
    }
}
public class ViceSchoolMasterApprover extends Approver {
    public ViceSchoolMasterApprover(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if(request.getPrice() <= 30000 && request.getPrice() > 10000){
            System.out.println("请求id: " + request.getId() + "被" + this.getName() + "处理，金额为" + request.getPrice());
        }else{
            this.getApprover().processRequest(request);
        }
    }
}
public class SchoolMasterApprover extends Approver {
    public SchoolMasterApprover(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if(request.getPrice() > 30000){
            System.out.println("请求id: " + request.getId() + "被" + this.getName() + "处理，金额为" + request.getPrice());
        }else{
            this.getApprover().processRequest(request);
        }
    }
}
//请求
public class PurchaseRequest {
    private int type;
    private float price;
    private int id;

    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;
    }
}
//客户端
PurchaseRequest request = new PurchaseRequest(1, 6000f, 1);
DepartmentApprover department = new DepartmentApprover("张主任");
CollegeApprover college = new CollegeApprover("吴院长");
ViceSchoolMasterApprover viceSchool = new ViceSchoolMasterApprover("张副校长");
SchoolMasterApprover school = new SchoolMasterApprover("王校长");
department.setApprover(college);
college.setApprover(viceSchool);
viceSchool.setApprover(school);
school.setApprover(department);

school.processRequest(request);

职责链模式的注意事项和细节

将请求和处理分开，实现解耦，提高系统的灵活性
简化了对象，使对象不需要知道链的结构
性能会受到影响，特别是在链比较长的时候，因此需控制链中最大节点数量，一般通过在Handler中设置一个最大节点数量，在setNext()方法中判断是否已经超过阀值，超过则不允许该链建立，避免出现超长链无意识地破坏系统性能
调试不方便。采用了类似递归的方式，调试时逻辑可能比较复杂
最佳应用场景：有多个对象可以处理同一个请求时，比如：多级请求、请假/加薪等审批流程、Java Web中Tomcat对Encoding的处理、拦截器

码农公寓

解释器模式

四则运算问题

传统方案解决四则运算问题分析

解释器模式基本介绍

代码实现

解释器模式的注意事项和细节

状态模式

APP抽奖活动问题

状态模式基本介绍

代码实现

注意实现

策略模式

鸭子问题

传统方案解决鸭子问题

策略模式基本介绍

代码实现

策略模式的注意事项和细节

责任链模式

OA系统采购审批需求

传统方案解决OA系统审批

职责链模式基本介绍

代码实现

职责链模式的注意事项和细节

相关文章