《Head First 设计模式》笔记9

最新推荐文章于 2024-08-26 11:44:49 发布
最新推荐文章于 2024-08-26 11:44:49 发布
阅读量182 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zoctan/article/details/79899094
版权

状态模式（State）

允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。

栗子

现在有一台糖果机，它的状态（挺复杂的）：
- 没有 25 分钱 -> 投入 25 分钱 -> 有 25 分钱
- 有 25 分钱 -> 转动曲柄 -> 售出糖果（数量不为0） | 糖果售罄（数量为0）
- 有 25 分钱 -> 退钱按钮 -> 退出 25 分钱
- 售出糖果 -> 没有 25 分钱

从上面的状态实现代码的步骤：
1. 找出所有状态 -> 共四种：没有 25 分钱、有 25 分钱、售出糖果、糖果售罄。
2. 创建一个持有当前状态的实例变量 state。
3. 写出所有可能发生的动作判断。

class GumballMachine {
    private final static int SOLD_OUT = 0;
    private final static int NO_QUARTER = 1;
    private final static int HAS_QUARTER = 2;
    private final static int SOLD = 3;

    private int state = SOLD_OUT; // 当前状态
    private int count = 0; // 糖果数目

    public GumballMachine(int count) {
        this.count = count;
        // 初始糖果机的糖果数
        if (count > 0) {
            // 大于0表示等待别人投币
            state = NO_QUARTER;
        }
    }

    // 投进25分钱
    public void insertQuarter() {
        if (state == HAS_QUARTER) {
            System.out.println("你已经投过25分钱了，请不要重复投币");
        } else if (state == NO_QUARTER) {
            System.out.println("投进25分钱");
            state = HAS_QUARTER;
        } else if (state == SOLD_OUT) {
            System.out.println("没有糖果了，不要投币");
        } else if (state == SOLD) {
            System.out.println("请稍等，正在出糖果");
        }
    }

    // 客户尝试退钱
    public void ejectQuarter() {
        if (state == HAS_QUARTER) {
            System.out.println("已退还25分钱");
            state = NO_QUARTER;
        } else if (state == NO_QUARTER) {
            System.out.println("你还没投币呢");
        } else if (state == SOLD_OUT) {
            System.out.println("没有糖果时无法投币，不要骗钱");
        } else if (state == SOLD) {
            System.out.println("你已经转动曲柄了，无法退钱");
        }
    }

    // 客户转动曲柄
    public void turnCrank() {
        if (state == HAS_QUARTER) {
            System.out.println("你转动了曲柄");
            state = SOLD;
            dispense();
        } else if (state == NO_QUARTER) {
            System.out.println("你还没投币呢");
        } else if (state == SOLD_OUT) {
            System.out.println("已经没有糖果了");
        } else if (state == SOLD) {
            System.out.println("转几次都只能拿一次");
        }
    }

    // 糖果机发糖果
    public void dispense() {
        if (state == SOLD) {
            System.out.println("糖果已发出");
            count--;
            if (count == 0) {
                System.out.println("已经没有糖果喽");
                state = SOLD_OUT;
            } else {
                state = NO_QUARTER;
            }
        } else if (state == NO_QUARTER) {
            System.out.println("你还没投币呢");
        } else if (state == SOLD_OUT) {
            System.out.println("没有糖果发");
        } else if (state == SOLD) {
            System.out.println("没有糖果发");
        }
    }
}

多么缜密的判断，基本上没什么漏洞了。

新需求

现在产品经理提需求来了：当曲柄被转动时，有 10% 的几率掉出两个糖果。

看回上面缜密的代码，是不是有点无从入手？这个需求真是要了命了……如果需求再有变更，上面的代码基本上就得推倒重来了，因为代码逻辑判断太复杂。

满足需求

我们可以把这四个状态当作一个实体，比如糖果机当前处在没投币的状态，那么在该状态下，可以通过投币动作使糖果机转移到投了币状态，其他状态也是这样，基本上可以把 if else 这些判断语句分离出来。

定义状态接口：

interface State {
    void insertQuarter();

    void ejectQuarter();

    void turnCrank();

    void dispense();
}

然后每种状态都实现该接口（先看总体）：

class SoldState implements State

class SoldOutState implements State

class NoQuarterState implements State

class HasQuarterState implements State

// 新需求中的“中奖状态”
class WinnerState implements State

还有新的糖果机（还没添加中奖状态）：

class GumballMachine {
    private State soldState;
    private State soldOutState;
    private State noQuarterState;
    private State hasQuarterState;

    private State state = soldState;
    private int count = 0;

    public GumballMachine(int count) {
        soldState = new SoldState(this);
        soldOutState = new SoldOutState(this);
        noQuarterState = new NoQuarterState(this);
        hasQuarterState = new HasQuarterState(this);
        this.count = count;
        if (count > 0) {
            state = noQuarterState;
        }
    }

    public void insertQuarter() {
        state.insertQuarter();
    }

    public void ejectQuarter() {
        state.ejectQuarter();
    }

    // 转动曲柄后
    // 具体是否能发出糖果就需要当前状态是 hasQuarterState
    public void turnCrank() {
        state.turnCrank();
        state.dispense();
    }

    public void setState(State state) {
        this.state = state;
    }

    // 不再通过 dispense 发放糖果
    public void releaseBall() {
        System.out.println("糖果已发出");
        if (count != 0) {
            count--;
        }
    }

    // getter
    public State getState() {
        return state;
    }

    public int getCount() {
        return count;
    }

    public State getSoldState() {
        return soldState;
    }

    public State getSoldOutState() {
        return soldOutState;
    }

    public State getNoQuarterState() {
        return noQuarterState;
    }

    public State getHasQuarterState() {
        return hasQuarterState;
    }
}

分别实现的状态类

没投币的状态：

class NoQuarterState implements State {
    private GumballMachine gumballMachine;

    public NoQuarterState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    @Override
    public void insertQuarter() {
        System.out.println("投进25分钱");
        gumballMachine.setState(gumballMachine.getHasQuarterState());
    }

    @Override
    public void ejectQuarter() {
        System.out.println("你还没投币呢，怎么退钱");
    }

    @Override
    public void turnCrank() {
        System.out.println("你转动了曲柄，但你还没投币呢");
    }

    @Override
    public void dispense() {
        System.out.println("你要先投币");
    }
}

投了币的状态：

class HasQuarterState implements State {
    private GumballMachine gumballMachine;

    public HasQuarterState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    @Override
    public void insertQuarter() {
        System.out.println("你已经投过25分钱了，请不要重复投币");
    }

    @Override
    public void ejectQuarter() {
        System.out.println("已退还25分钱");
        gumballMachine.setState(gumballMachine.getNoQuarterState());
    }

    @Override
    public void turnCrank() {
        System.out.println("你转动了曲柄");
        gumballMachine.setState(gumballMachine.getSoldState());
    }

    @Override
    public void dispense() {
        System.out.println("没有糖果发");
    }
}

售出糖果的状态：

class SoldState implements State {
    private GumballMachine gumballMachine;

    public SoldState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    @Override
    public void insertQuarter() {
        System.out.println("请稍等，正在出糖果");
    }

    @Override
    public void ejectQuarter() {
        System.out.println("你已经转动曲柄了，无法退钱");
    }

    @Override
    public void turnCrank() {
        System.out.println("转几次都只能拿一次");
    }

    @Override
    public void dispense() {
        gumballMachine.releaseBall();
        if (gumballMachine.getCount() > 0) {
            gumballMachine.setState(gumballMachine.getNoQuarterState());
        } else {
            System.out.println("已经没有糖果喽");
            gumballMachine.setState(gumballMachine.getSoldOutState());
        }
    }
}

糖果售罄的状态：

class SoldOutState implements State {
    private GumballMachine gumballMachine;

    public SoldOutState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    @Override
    public void insertQuarter() {
        System.out.println("没有糖果了，不要投币");
    }

    @Override
    public void ejectQuarter() {
        System.out.println("没有糖果时无法投币，不要骗钱");
    }

    @Override
    public void turnCrank() {
        System.out.println("你转动了曲柄，但是已经没有糖果了");
    }

    @Override
    public void dispense() {
        System.out.println("没有糖果发");
    }
}

新需求中的中奖状态：

class WinnerState implements State {
    private GumballMachine gumballMachine;

    public WinnerState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    @Override
    public void insertQuarter() {
        System.out.println("请稍等，正在出糖果");
    }

    @Override
    public void ejectQuarter() {
        System.out.println("你已经转动曲柄了，无法退钱");
    }

    @Override
    public void turnCrank() {
        System.out.println("转几次都只能拿一次");
    }

    // 除了发糖外，其他信息和售出糖果的状态一样
    @Override
    public void dispense() {
        System.out.println("恭喜！你拿到了两颗糖");
        // 第一颗糖
        gumballMachine.releaseBall();
        if (gumballMachine.getCount() == 0) {
            gumballMachine.setState(gumballMachine.getSoldOutState());
        } else {
            // 第二颗糖
            gumballMachine.releaseBall();
            if (gumballMachine.getCount() > 0) {
                gumballMachine.setState(gumballMachine.getNoQuarterState());
            } else {
                System.out.println("已经没有糖果喽");
                gumballMachine.setState(gumballMachine.getSoldOutState());
            }
        }
    }
}

需求还没解决完

上面的代码只是解决了状态的问题，但还没有完全满足需求，10% 的随机中奖还没写。（其实也没什么难度了）

给糖果机加上中奖状态：

class GumballMachine {
    // ...
    private State winnerState;

    public GumballMachine(String location, int count) {
        winnerState = new WinnerState(this);
        // ...
    }

    public State getWinnerState() {
        return winnerState;
    }

    // ...
}

因为只有在投了币的情况下才能转动曲柄 -> 发糖 | 中奖，所以要在投了币的状态加入这 10% 随机：

class HasQuarterState implements State {
    // ...

    @Override
    public void turnCrank() {
        System.out.println("你转动了曲柄");
        Random randomWinner = new Random(System.currentTimeMillis());
        // 中奖
        // 10次里面有一次是0，即 1/10
        int winner = randomWinner.nextInt(10);
        if (winner == 0 && gumballMachine.getCount() > 1) {
            gumballMachine.setState(gumballMachine.getWinnerState());
        } else {
            gumballMachine.setState(gumballMachine.getSoldState());
        }
    }

    // ...
Zoctan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
笔记_HeadFirst设计模式.pdf
06-16
笔记_HeadFirst设计模式
HeadFirst设计模式学习笔记
08-18
《HeadFirst设计模式学习笔记》是一份详尽的资料，旨在帮助读者深入理解并掌握设计模式这一编程领域的核心概念。设计模式是软件工程中的一种最佳实践，它在解决常见问题时提供了一种标准的解决方案，使得代码更易于...
《Head First设计模式》读书笔记
weixin_52847003的博客
01-27 681
目录 一、设计模式入门与策略模式 二、观察者模式 三、装饰者模式 四、工厂模式 五、单件模式 六、命令模式 七、适配器与外观模式 八、模板方法模式 九、迭代器与组合模式 十、状态模式 十一、代理模式 十二、复合模式 十三、与设计模式相处 十四、其他模式 一、设计模式入门与策略模式 1.使用模式最好的方式是：“把模式装进脑子里，然后在你的设计和已有的应用中，寻找何处可以使用它们。” 2.软件开发的一个不变真理：改变 3.第一个设计原则：分离需要变化的代码和不需要变化的代
简单理解-Head First 设计模式
走一段令人留恋的路，做一个不负自己的人
12-10 3477
我们知道四人组的《设计模式》共介绍了23种，并且将其分成3类，分别是：创建型、结构型、行为型，如下所示： - **创建型**：**5个**。工厂方法模式、抽象工厂模式、Builder模式（Retrofit）、单例模式（类初始化）、原型模式 - **结构型**：**7个**。适配器模式、装饰模式（File操作）、代理模式（静态代理——代理对象内部操作委托对象、动态代理——代理对象里面不指定特定的委托对象，更加灵活）、组合模式、桥接模式、外观模式、享元模式 - **行为型**：**11个**。观察者模式
Head First设计模式学习笔记
微赚淘客系统开发者博客
06-29 555
本文介绍了《Head First设计模式》中的部分设计模式，包括工厂方法模式、适配器模式和观察者模式，并提供了相应的Java代码示例。设计模式是软件开发中非常重要的一部分，它们帮助我们解决常见问题，并促进代码的重用和维护。是在软件设计中反复出现的问题的解决方案，它们被广泛应用于提高代码的重用性、灵活性和可维护性。观察者模式定义了对象之间的一对多依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都将得到通知并自动更新。关注对象之间的通信，帮助我们更好地分配职责和定义对象之间的交互模式。
《Head First 设计模式》笔记
一只挣扎的小白的博客
05-05 310
《Head First 设计模式》笔记 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录《Head First 设计模式》笔记前言一、策略模式二、使用步骤1.引入库2.读入数据总结 前言 大三党修炼（自动狗头）花点时间了解JAVA中的一些设计模式，写博客是为了帮自己理清思路，希望也能帮到大家了解设计模式， 书中设计模式第一种我也没接触过框架，我希望后
headfirst设计模式笔记（11章节）--代理模式
stupid的博客
03-20 249
目录 1：PDF上传链接 2：控制对象访问 2.1：目标 3：Java RMI概观 4：定义代理模式 5：设计箱的工具 6：本章去看详细的PDF吧（裂开） 1：PDF上传链接 【免费】headfirst-设计模式：PDF用于引用资源-CSDN文库 2：控制对象访问 玩过扮白脸、扮黑脸的游戏？你是一个白脸，提供很好且友善的服务，但是你不希望每个人都叫你做事，所有找了黑脸控制对你的访问。这就是代理要做的：控制和管理访问。就像你将看到的，代理的方式有很多种。代理通过I
Head First设计模式读书笔记
Zouch
03-18 224
1、策略模式 三个原则： 找出应用中可能变化的代码，把他们独立出来不要和那些不需要变化的代码混在一起; 针对接口编程，而不是正对实现编程。 多用组合，少用继承。 书中举出的例子，父类中使用接口定义了行为，和调用行为的方法。 接口则定义了具体行为。 通过继承也就是多态，和接口组合，实现了策略模式。 换句话说，通过给子类赋予不同的接口实例，来实现不同的行为。共同行为封装在父类中，由子类实现。 2、观察者模式 明天继续 ...
《Head First设计模式》中文版 读书笔记
山河已无恙
05-09 2085
I 'm just afraid that if I died today , that my life would’ve amounted to nothing. 我只是怕某天死了，我的生命却一无所有。----《奇幻之旅》
headfirst设计模式笔记（12章节）--模式中的模式（复合模式）
stupid的博客
04-07 168
使用模式最棒的方式，就是把它们从家里找出来跟其他模式展开交互，你越多的使用模式就越容易发现他们一同现身在你的设计中。对于这些在设计中携手合作征服许多问题的模式，我们给它一个特备的名字：复合模式（compound Pattern）；模式通常被一起使用，并被组合在同一个设计解决方案中。复合模式在一个解决方案中结合两个或者多个模式，以解决一般或重复发生的问题。本章节还是以鸭子模拟器进行举例，详情参考PDF；
HeadFirst 设计模式 笔记
打渔还是晒网 —— stone
09-10 859
设计原则 1. 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。 2. 针对接口编程，而不是针对实现编程。        针对接口编程，实质上是指针对超类型(supertype)编程。        变量的声明类型应该是超类型，通常指一个抽象类或一个接口；多态 3. 多用组合，少用继承。        has a 可能比 is a 更好
Head First 设计模式笔记 4.单例模式
zhazha_hui的博客
01-02 1023
单例模式比较简单，用于创建全局唯一的一个对象。这里简介一下如何实现单例模式并且保证其线程安全
HeadFirst设计模式笔记
04-14
《HeadFirst设计模式笔记》是深入理解软件设计思想的一份宝贵资料，主要涵盖了设计模式的基础理论和实际应用。设计模式是软件开发中的经验总结，它为解决常见的编程问题提供了标准的解决方案，使得代码更具可读性、...
Head First设计模式读书笔记-DesignPatterns.zip
01-29
《Head First设计模式》是一本深受开发者喜爱的设计模式学习书籍，它以易懂且生动的方式介绍了23种经典设计模式。这些模式是软件工程中经过实践验证的最佳实践，旨在提高代码的可重用性、可读性和可维护性。下面，...
设计模式2个黄鹂鸣翠柳-《分析模式》漫谈23
最新发布
rolt的专栏
08-26 596
翻译这样有原文白纸黑字可以对照的东西，其中还掺杂这么多“技巧”和“变化”
设计模式 5 原型模式
小小程序猿
08-23 643
原型模式允许一个对象通过复制自身来创建新的对象。这种模式提供了一种创建对象的快捷方式，尤其适用于创建代价较高的对象。
设计模式 4 建造者模式
小小程序猿
08-22 1083
建造者模式将一个复杂对象的构造过程分离出来，使得相同的构造过程可以创建不同的表示。它使用多个简单的对象一步一步构建复杂对象，通过不同的建造者实现不同的构建方式。
设计模式反模式：UML图示常见误用案例分析
hai40587的博客
08-26 469
UML图示是软件开发过程中重要的沟通工具，但如果不当使用，可能会导致设计模式反模式的出现。通过避免类关系混淆、过度复杂的继承关系、接口与实现关系模糊、滥用枚举类型以及错误的组件划分等常见误用，可以确保UML图示的准确性和有效性，从而提升软件系统的质量和可维护性。在实际应用中，开发人员应深入理解UML和设计模式的相关知识，并结合具体项目的需求来合理使用它们。
设计模式（三）
dingyahui的博客
08-24 1080
Circle 是具体的实现类，它实现了抽象类的方法，并使用实现类接口来完成绘制工作，测试函数中创建了两个具体的实现类对象和两个使用这些实现类的圆形对象，并调用它们的绘制方法。优点：使用代理模式创建代表对象，让代表对象来控制某对象的访问，被代理的对象可以是远程的对象，创建开销大的对象或需要安全控制的对象。：真实的角色实现实际的业务逻辑，不用关心其它非本职的事务，通过后期的代理完成附加的事务，附带的结果就是编程简洁清晰。：享元模式的优点在于大幅减少内存中对象的数量，降低程序内存的占用，提高性能。
Head First 设计模式学习笔记概览
"这是一份关于Head First 设计模式的学习笔记，涵盖了多种常见的设计模式，包括但不限于观察者模式、装饰者模式、工厂模式、单件模式、命令模式、适配器与外观模式、模板方法模式、迭代器与组合模式、状态模式、代理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值