设计模式之状态&责任链&观察者&策略

最新推荐文章于 2023-11-25 19:15:50 发布

Dilraba辣

最新推荐文章于 2023-11-25 19:15:50 发布

阅读量215

点赞数

文章标签： java

本文链接：https://blog.csdn.net/CLa11111111/article/details/124366366

版权

本文详细介绍了Java设计模式中的四种重要模式：状态模式用于处理对象的不同状态及其行为；责任链模式通过处理者链来分发请求；观察者模式实现了一对多的依赖关系，当对象状态改变时，所有依赖者都会得到通知；策略模式允许在运行时选择不同的算法或策略。这些模式提高了代码的可读性和可维护性，同时也揭示了面向对象设计的灵活性。

摘要由CSDN通过智能技术生成

1、状态模式（State）

2、责任链模式(Chain of Responsibility)

3、观察者模式（Observer）

4、策略模式（Strategy）

角色

Context：环境角色：用于维护 State 实例,这个实例定义当前状态
State：抽象状态角色：聚合到Context环境角色中
ConcreteState ：具体的状态角色 ConcreteStateA ConcreteStateB ConcreteStateC

在这里插入图片描述
案例：抽奖活动项目设计

在这里插入图片描述

public class State {
    //    当前的状态
    private int state;
    //    供抽奖的积分
    private int score;
    //    奖品的数量
    private int count;
 
    public State(int score, int count) {
        this.score = score;
        this.count = count;
    }
 
    public int getCount() {
        return count;
    }
 
    public int getState() {
        return state;
    }
 
    public void setState(int state) {
        this.state = state;
    }
 
    public int getScore() {
        return score;
    }
 
    public void setScore(int score) {
        this.score = score;
    }
 
    //    扣除积分
    public void minus() {
//        只有一阶段可以扣积分
        this.state = 1;
        if (this.state == 1) {
            if (this.score >= 50) {
                if (this.count == 0) {
                    System.out.println("奖品领完....");
                    return;
                }
                this.score = this.score - 50;
                System.out.println("========扣除50积分，当前积分还剩" + this.score + "========");
                this.state = 2;
                if (luckHit()) {
                    this.state = 3;
                    getPrize();
                }
            } else {
                System.out.println("========积分不够，当前积分为" + this.score + "========");
            }
        }
 
    }
 
    //    十分之一抽中奖品的概率
    public boolean luckHit() {
//        只有二阶段可以抽奖
        return this.state == 2 ? (new Random().nextInt(10) == 6) : false;
    }
 
    public void getPrize() {
        if (this.state == 3) {
            if (this.count > 0) {
                System.out.println("领取奖品....");
                this.count = this.count - 1;
            } else {
                System.out.println("奖品领完....");
            }
        }
    }
 
}

public class Client {
    public static void main(String[] args) {
        State state = new State(500,1);
//        state.minus();
        for (int i = 0; i < 300; i++) {
            state.minus();
        }
    }
}

从上面的编码中，我们可以看出，完成该需求有很多的条件判断，非常不利于后续的维护；上面状态只有4个，代码已经比较复杂了；状态越多，代码嵌套就越复杂，维护成本就越高；

public abstract class State {
 
//    扣积分
    abstract void minus();
//    抽奖
    abstract boolean luckHit();
//    获取奖品
    abstract void getPrize();
 
}
 
class ConcreteStateA extends State{
    Context context;
 
    public ConcreteStateA(Context context) {
        this.context = context;
    }
 
    @Override
    void minus() {
        if(context.getScore()>=50){
            context.setScore(context.getScore()-50);
            System.out.println("========扣除50积分，当前积分还剩"+context.getScore()+"========");
            context.setState(context.getStateB());
        }else{
            System.out.println("========积分不够，当前积分为"+context.getScore()+"========");
        }
    }
 
    @Override
    boolean luckHit() {
        System.out.println("还在扣费环节，不能抽奖...");
        return false;
    }
 
    @Override
    void getPrize() {
        System.out.println("还在扣费环节，不能领取奖品...");