【设计模式六】行为型模式（中介者/备忘录/解释器/状态）

最新推荐文章于 2024-09-03 17:22:28 发布

土味儿~

最新推荐文章于 2024-09-03 17:22:28 发布

阅读量355

点赞数 1

分类专栏：设计模式文章标签： python java 数据库大数据设计模式

本文链接：https://blog.csdn.net/tu_wer/article/details/120192795

版权

设计模式专栏收录该内容

12 篇文章 1 订阅

订阅专栏

6、中介者模式
7、备忘录模式
8、解释器模式
9、状态模式

6、中介者模式

Mediator Pattern

[ˈmiːdieɪtər]

1)基本介绍

中介者模式(Mediator Pattern)，用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显式地相互引用，从而使其解耦，而且可以独立地改变它们之间的交互
中介者模式属于行为型模式，使代码易于维护
MVC模式，C(Controller控制器)是 M(Model模型)和 V(View视图)的中介者，在前后端交互时起到了中间人的作用

2)原理类图

Mediator 就是抽象中介者，定义了同事对象到中介者对象的接口
Colleague是抽象同事类
ConcreteMediator具体的中介者对象，实现抽象方法，需要知道所有的具体的同事类，即以一个集合来管理 HashMap，并接受某个同事对象消息，完成相应的任务
ConcreteColleague 具体的同事类，会有很多，每个同事只知道自己的行为，而不了解其他同事类的行为(方法)，但是他们都依赖中介者对象；同事间实现解耦，提高了扩展性

3)案例分析

智能家庭项目

智能家庭包括各种设备，闹钟、咖啡机、电视机、窗帘等
主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流程为：
闹铃响起
咖啡机开始做咖啡
窗帘自动落下
电视机开始播放

同事之间(闹钟、咖啡机、电视、窗帘、电话)实现解耦，方便扩展

每个同事都与中介关联，图中只展示闹钟和中介的关联，其余省略

中介抽象类 Mediator

package mediator.mediator;

import mediator.colleague.Colleague;

/**
 * @author 土味儿
 * Date 2021/7/29
 * @version 1.0
 * 中介抽象类
 */
public abstract class Mediator {
    /**
     * 注册特定同事，放入集合中
     * @param colleagueName
     * @param colleague
     */
    public abstract void register(String colleagueName, Colleague colleague);

    /**
     * 获取特定同事发出的消息
     * @param stateChange
     * @param colleagueName
     */
    public abstract  void getMessage(int stateChange,String colleagueName);

    /**
     * 发送消息
     */
    public abstract void sendMessage();
}

具体中介实现者 ConcreteMediator

package mediator.mediator;

import mediator.colleague.*;

import java.util.HashMap;
import java.util.Map;

/**
 * @author 土味儿
 * Date 2021/7/29
 * @version 1.0
 * 具体中介实现者
 */
public class ConcreteMediator extends Mediator {
    // 集合，放入同事对象
    private Map<String,Colleague> colleagueMap;
    // 集合，存放同事名称
    private HashMap<String, String> interMap;

    /**
     * 构造器
     */
    public ConcreteMediator() {
        this.colleagueMap = new HashMap<String,Colleague>();
        this.interMap = new HashMap<String,String>();
    }

    /**
     * 注册同事对象
     * @param colleagueName
     * @param colleague
     */
    @Override
    public void register(String colleagueName, Colleague colleague) {
        colleagueMap.put(colleagueName,colleague);

        if (colleague instanceof AlarmColleague) {
            interMap.put("Alarm", colleagueName);
        } else if (colleague instanceof CoffeeMachineColleague) {
            interMap.put("CoffeeMachine", colleagueName);
        }

    }

    /**
     * 核心方法
     * 获取消息并处理
     * @param stateChange
     * @param colleagueName
     */
    @Override
    public void getMessage(int stateChange, String colleagueName) {
        // 闹钟
        if(colleagueMap.get(colleagueName) instanceof AlarmColleague){
            if(stateChange == 0 ){// 闹钟响起：开始
                // 开始制作咖啡
                ((CoffeeMachineColleague)(colleagueMap.get(interMap.get("CoffeeMachine")))).startCoffee();
                // 落下窗帘
                // 打开电视
            }else if(stateChange == 1){// 闹钟响起：结束
                // 关闭电视
                // 升级窗帘
            }
        }
    }

    @Override
    public void sendMessage() {

    }
}

抽象同事类 Colleague

package mediator.colleague;

import mediator.mediator.Mediator;

/**
 * @author 土味儿
 * Date 2021/7/29
 * @version 1.0
 * 抽象同事类
 */
public abstract class Colleague {
    // 中介者
    private Mediator mediator;
    // 同事名称
    private String name;

    /**
     * 构造器
     * @param mediator
     * @param name
     */
    public Colleague(Mediator mediator, String name) {
        this.mediator = mediator;
        this.name = name;
    }

    /**
     * 发送消息
     * @param stateChange
     */
    public abstract void sendMessage(int stateChange);

    public String getName() {
        return name;
    }

    public Mediator getMediator() {
        return mediator;
    }
}

具体同事实现类

package mediator.colleague;

import mediator.mediator.Mediator;

/**
 * @author 土味儿
 * Date 2021/7/29
 * @version 1.0
 * 闹钟
 */
public class AlarmColleague extends Colleague {
    /**
     * 构造器
     *
     * @param mediator
     * @param name
     */
    public AlarmColleague(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name,this);
    }

    /**
     * 闹钟发声
     * @param stateChange
     */
    public void sendAlarm(int stateChange){
        if(stateChange == 0 ){// 闹钟响起：开始
            System.out.println("闹钟响起开始");
        }else if(stateChange == 1){// 闹钟响起：结束
            System.out.println("闹钟响起结束");
        }
        sendMessage(stateChange);
    }

    /**
     * 发送消息
     * @param stateChange
     */
    @Override
    public void sendMessage(int stateChange) {
        this.getMediator().getMessage(stateChange,this.getName());
    }
}

package mediator.colleague;

import mediator.mediator.Mediator;

/**
 * @author 土味儿
 * Date 2021/7/29
 * @version 1.0
 * 咖啡机
 */
public class CoffeeMachineColleague extends Colleague{
    /**
     * 构造器
     *
     * @param mediator
     * @param name
     */
    public CoffeeMachineColleague(Mediator mediator, String name) {
        super(mediator, name);
        mediator.register(name,this);
    }

    @Override
    public void sendMessage(int stateChange) {
        this.getMediator().getMessage(stateChange,this.getName());
    }

    /**
     * 开始制作咖啡
     */
    public void startCoffee(){
        System.out.println("开始制作咖啡");
    }

    /**
     * 咖啡制作完成
     */
    public void finishCoffee(){
        System.out.println("咖啡制作完成");
    }
}

客户端

package mediator;

import mediator.colleague.*;
import mediator.mediator.*;

/**
 * @author 土味儿
 * Date 2021/7/29
 * @version 1.0
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        // 创建中介者对象
        Mediator mediator = new ConcreteMediator();
        // 创建闹钟
        AlarmColleague alarmColleague = new AlarmColleague(mediator, "闹钟");
        // 创建咖啡机
        CoffeeMachineColleague coffeeMachineColleague = new CoffeeMachineColleague(mediator, "咖啡机");

        alarmColleague.sendAlarm(0);
        alarmColleague.sendAlarm(1);
    }
}

运行结果

闹钟响起开始
开始制作咖啡
闹钟响起结束

7、备忘录模式

Memento Pattern

1)基本介绍

备忘录模式(Memento Pattern)在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态
可以这样理解备忘录模式：现实生活中的备忘录是用来记录某些要去做的事情，或者是记录已经达成的共同意见的事情，以防忘记了。而在软件层面，备忘录模式有着相同的含义，备忘录对象主要用来记录一个对象的某种状态，或者某些数据，当要做回退时，可以从备忘录对象里获取原来的数据进行恢复操作
备忘录模式属于行为型模式

2)原理类图

Originator ：对象(需要保存状态的对象)
Memento：备忘录对象，负责保存记录，即 Originator 内部状态
Caretaker：守护者对象，负责保存多个备忘录对象，使用集合管理，提高效率
如果希望保存多个 originator 对象的不同时间的状态，也可以，只需要 HashMap <String，集合>

3)案例分析

游戏角色有攻击力和防御力，在大战 Boss前保存自身的状态(攻击力和防御力)，当大战 Boss后攻击力和防御力下降，从备忘录对象恢复到大战前的状态

可以存储多个角色的状态，每个角色有多个状态

备忘录对象 Memento

package memento.originator.more;

/**
 * @author 土味儿
 * Date 2021/7/30
 * @version 1.0
 * 备忘录对象
 */
public class Memento {
    // 攻击力
    private int vit;
    // 防御力
    private int def;

    public Memento(int vit, int def) {
        this.vit = vit;
        this.def = def;
    }

    public int getVit() {
        return vit;
    }

    public int getDef() {
        return def;
    }
}

游戏角色 GameRole

GameRole1、GameRole2、GameRole3

package memento.originator.more.gamerole;

import memento.originator.more.Memento;

/**
 * @author 土味儿
 * Date 2021/7/30
 * @version 1.0
 * 游戏角色1
 */
public class GameRole1 {
    // 角色名称
    private String name;
    // 攻击力
    private int vit;
    // 防御力
    private int def;

    public GameRole1() {
        this.name = "角色1";
        this.vit = 100;
        this.def = 100;
    }

    /**
     * 创建当前状态的备忘录
     *
     * @return
     */
    public Memento createMemento() {
        return new Memento(vit, def);
    }

    /**
     * 从备忘录中恢复状态
     */
    public void recoverFromMemento(Memento memento) {
        this.vit = memento.getVit();
        this.def = memento.getDef();
    }

    /**
     * 显示
     */
    public void display() {
        System.out.println(name + " 攻击力：" + vit + " 防御力：" + def);
    }

    public String getName() {
        return name;
    }

    public void setVit(int vit) {
        this.vit = vit;
    }

    public void setDef(int def) {
        this.def = def;
    }
}

守护者对象 Caretaker

package memento.originator.more;

import java.util.*;

/**
 * @author 土味儿
 * Date 2021/7/30
 * @version 1.0
 * 守护者对象
 * 存储备忘录
 */
public class Caretaker {
    // 存储某个角色备忘录集合
    private List<Memento> mementoList;
    // 存储所有角色的备忘录集合
    private HashMap<String,List<Memento>> mementoMap;

    /**
     * 构造器
     */
    public Caretaker() {
        //this.mementoList = new ArrayList<>();
        this.mementoMap = new HashMap<>();
    }

    /**
     * 添加
     * @param gameRoleName
     * @param memento
     */
    public void add(String gameRoleName,Memento memento){
        // 检查Map中是否存当前角色
        Set<String> keySet = mementoMap.keySet();
        // Map中是否包含当前角色：默认不包含
        boolean include = false;
        for (String k : keySet) {
            if(k.equals(gameRoleName)){
                include = true;
                break;
            }
        }
        // 不存在：直接添加
        if(!include){
            mementoList = new ArrayList<>();
            mementoList.add(memento);
            // HashMap 如果添加相同的key，后面的会替换前面的key-value(key不会替换，value会替换)
            mementoMap.put(gameRoleName,mementoList);
            return;
        }
        // 存在：从Map中取出List，把状态加入List，再把List存入Map
        mementoList = mementoMap.get(gameRoleName);
        mementoList.add(memento);
        // HashMap 如果添加相同的key，后面的会替换前面的key-value(key不会替换，value会替换)
        mementoMap.put(gameRoleName,mementoList);
    }

    /**
     * 获取
     * @param gameRoleName
     * @param index
     * @return
     */
    public Memento get(String gameRoleName,int index){
        return mementoMap.get(gameRoleName).get(index);
    }

    /**
     * 删除
     * @param index
     */
    public void remove(String gameRoleName,int index){
        mementoMap.get(gameRoleName).remove(index);
    }
}

客户端 Client

package memento.originator.more;

import memento.originator.more.gamerole.GameRole1;
import memento.originator.more.gamerole.GameRole2;
import memento.originator.more.gamerole.GameRole3;

/**
 * @author 土味儿
 * Date 2021/7/30
 * @version 1.0
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        // 创建守护者
        Caretaker caretaker = new Caretaker();

        // 创建游戏角色1
        GameRole1 gameRole1 = new GameRole1();
        // 设置状态
        gameRole1.setVit(80);
        gameRole1.setDef(70);
        caretaker.add(gameRole1.getName(),gameRole1.createMemento());

        // 设置状态
        gameRole1.setVit(60);
        gameRole1.setDef(50);
        caretaker.add(gameRole1.getName(),gameRole1.createMemento());

        // 设置状态
        gameRole1.setVit(50);
        gameRole1.setDef(40);
        caretaker.add(gameRole1.getName(),gameRole1.createMemento());

        gameRole1.display();

        gameRole1.recoverFromMemento(caretaker.get(gameRole1.getName(),1));

        gameRole1.display();

        // 创建游戏角色2
        GameRole2 gameRole2 = new GameRole2();
        // 设置状态
        gameRole2.setVit(82);
        gameRole2.setDef(72);
        caretaker.add(gameRole2.getName(),gameRole2.createMemento());

        // 创建游戏角色3
        GameRole3 gameRole3 = new GameRole3();
        // 设置状态
        gameRole3.setVit(83);
        gameRole3.setDef(73);
        caretaker.add(gameRole3.getName(),gameRole3.createMemento());

        // 设置状态
        gameRole2.setVit(62);
        gameRole2.setDef(52);
        caretaker.add(gameRole2.getName(),gameRole2.createMemento());
        gameRole2.display();

        gameRole2.recoverFromMemento(caretaker.get(gameRole2.getName(),0));
        gameRole2.display();
    }
}

运行结果

角色1 攻击力：50 防御力：40
角色1 攻击力：60 防御力：50
角色2 攻击力：62 防御力：52
角色2 攻击力：82 防御力：72

4)注意事项和细节

给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态
实现了信息的封装，使得用户不需要关心状态的保存细节
如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存，这个需要注意
适用的应用场景：
- 后悔药
- 打游戏时的存档
- Windows里的 ctri + z
- IE中的后退
- 数据库的事务管理
为了节约内存，备忘录模式可以和原型模式配合使用

8、解释器模式

Interpreter Pattern

1)基本介绍

在编译原理中，一个算术表达式通过词法分析器形成词法单元，而后这些词法单元再通过语法分析器构建语法分析树，最终形成一颗抽象的语法分析树。这里的词法分析器和语法分析器都可以看做是解释器
解释器模式(Interpreter Pattern)：是指给定一个语言(表达式)，定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子(表达式)
应用场景
- 编译器
- 运算表达式计算
- 正则表达式
- 机器人等

2)原理类图

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

3)案例分析

通过解释器模式来实现加减运算，如计算 a+b-c 的值

Expression 抽象表达式(a+b-c)
- VarExpression 变量表达式(a、b、c)
- SymbolExpression 运算符表达式(+、-)
  - AddExpression 加法表达式
  - SubExpression 减法表达式
Calculator 计算器

4)Spring中的应用

Spring框架中 SpelExpressionParser 就使用到解释器模式

5)注意事项和细节

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

9、状态模式

State Pattern

1)基本介绍

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

2)原理类图

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

3)抽奖案例

APP抽奖活动

具体要求如下:

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

抽奖状态接口 RaffleState

package state.raffle;

/**
 * @author 土味儿
 * Date 2021/7/30
 * @version 1.0
 * 抽奖状态接口
 */
public interface RaffleState {
    /**
     * 扣积分
     */
    void deductIntegral();

    /**
     * 抽奖
     */
    boolean raffle();

    /**
     * 发奖品
     */
    void dispensePrize();
}

具体状态实现类

package state.raffle.state;

import state.raffle.RaffleActivity;
import state.raffle.RaffleState;

/**
 * @author 土味儿
 * Date 2021/7/30
 * @version 1.0
 * 待抽奖状态
 */
public class WaitRaffleState implements RaffleState {
    // 抽奖活动
    private RaffleActivity raffleActivity;

    /**
     * 构造器
     * @param raffleActivity
     */
    public WaitRaffleState(RaffleActivity raffleActivity) {
        this.raffleActivity = raffleActivity;
    }

    /**
     * 扣积分
     * 只有 待抽奖状态 可以扣积分，扣除后将状态设置成 可抽奖状态
     */
    @Override
    public void deductIntegral() {
        System.out.println("扣除 50 积分成功！您可以抽奖了！");
        // 把状态设置为 可抽奖状态
        raffleActivity.setState(raffleActivity.getCanRaffleState());
    }

    /**
     * 抽奖
     * 待抽奖状态 不能抽奖
     * @return
     */
    @Override
    public boolean raffle() {
        System.out.println("扣除积分后才可以抽奖哟");
        return false;
    }

    /**
     * 发奖品
     */
    @Override
    public void dispensePrize() {
        System.out.println("待抽奖状态不能发放奖品哟");
    }
}

package state.raffle.state;

import state.raffle.RaffleActivity;
import state.raffle.RaffleState;

import java.util.Random;

/**
 * @author 土味儿
 * Date 2021/7/30
 * @version 1.0
 * 可抽奖状态
 */
public class CanRaffleState implements RaffleState {
    // 抽奖活动
    private RaffleActivity raffleActivity;

    /**
     * 构造器
     *
     * @param raffleActivity
     */
    public CanRaffleState(RaffleActivity raffleActivity) {
        this.raffleActivity = raffleActivity;
    }

    /**
     * 扣积分
     */
    @Override
    public void deductIntegral() {
        System.out.println("已经扣过积分了，请抽奖！");
    }

    /**
     * 抽奖
     *
     * @return
     */
    @Override
    public boolean raffle() {
        System.out.println("正在抽奖，请稍候...");
        // 随机抽奖：中奖概率30%
        int i = new Random().nextInt(100);
        // 中奖了
        if (i < 30) {
            System.out.println("㳟喜您！中奖了...");
            // 把状态设置为 发放奖品状态
            raffleActivity.setState(raffleActivity.getDispensePrizeState());
            return true;
        }
        System.out.println("很遗憾没有中奖！");
        // 把状态设置为 待抽奖状态
        raffleActivity.setState(raffleActivity.getWaitRaffleState());
        return false;
    }

    /**
     * 发放奖品
     */
    @Override
    public void dispensePrize() {
        System.out.println("中奖后才可以发放奖品！");
    }
}

package state.raffle.state;

import state.raffle.RaffleActivity;
import state.raffle.RaffleState;

/**
 * @author 土味儿
 * Date 2021/7/30
 * @version 1.0
 * 发放奖品状态
 */
public class DispensePrizeState implements RaffleState {
    // 抽奖活动
    private RaffleActivity raffleActivity;

    /**
     * 构造器
     * @param raffleActivity
     */
    public DispensePrizeState(RaffleActivity raffleActivity) {
        this.raffleActivity = raffleActivity;
    }

    /**
     * 扣积分
     */
    @Override
    public void deductIntegral() {
        System.out.println("发放奖品状态不扣积分！");
    }

    /**
     * 抽奖
     * @return
     */
    @Override
    public boolean raffle() {
        System.out.println("发放奖品状态不能抽奖");
        return false;
    }

    /**
     * 发放奖品
     * 根据奖品数量，判断状态
     */
    @Override
    public void dispensePrize() {
        if(raffleActivity.getCount() > 0){
            System.out.println("请领奖....");
            // 奖品数量减1
            raffleActivity.setCount(raffleActivity.getCount()-1);
            // 判断最新奖品数量，然后设置状态
            if(raffleActivity.getCount() > 0){
                // 把状态设置为 待抽奖状态
                raffleActivity.setState(raffleActivity.getWaitRaffleState());
                return;
            }
            // 把状态设置为 奖品发完状态
            raffleActivity.setState(raffleActivity.getPrizeOverState());
            return;
        }
        System.out.println("没有奖品了...");
        // 把状态设置为 奖品发完状态
        raffleActivity.setState(raffleActivity.getPrizeOverState());
    }
}

package state.raffle.state;

import state.raffle.RaffleActivity;
import state.raffle.RaffleState;

/**
 * @author 土味儿
 * Date 2021/7/30
 * @version 1.0
 * 奖品发完状态
 */
public class PrizeOverState implements RaffleState {
    // 抽奖活动
    private RaffleActivity raffleActivity;

    /**
     * 构造器
     * @param raffleActivity
     */
    public PrizeOverState(RaffleActivity raffleActivity) {
        this.raffleActivity = raffleActivity;
    }
    @Override
    public void deductIntegral() {
        System.out.println("奖品发完了！不扣积分");
    }

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

    @Override
    public void dispensePrize() {
        System.out.println("奖品发完了！");
    }
}

抽奖活动类 RaffleActivity

package state.raffle;

import state.raffle.state.CanRaffleState;
import state.raffle.state.DispensePrizeState;
import state.raffle.state.PrizeOverState;
import state.raffle.state.WaitRaffleState;

/**
 * @author 土味儿
 * Date 2021/7/30
 * @version 1.0
 * 抽奖活动
 */
public class RaffleActivity {
    // 当前状态
    private RaffleState state = null;
    // 四种状态
    private WaitRaffleState waitRaffleState;
    private CanRaffleState canRaffleState;
    private DispensePrizeState dispensePrizeState;
    private PrizeOverState prizeOverState;
    // 奖品数量
    private int count = 0;

    /**
     * 构造器
     *
     * @param count
     */
    public RaffleActivity(int count) {
        this.waitRaffleState = new WaitRaffleState(this);
        this.canRaffleState = new CanRaffleState(this);
        this.dispensePrizeState = new DispensePrizeState(this);
        this.prizeOverState = new PrizeOverState(this);

        this.state = waitRaffleState;
        this.count = count;
    }

    /**
     * 扣积分
     */
    public void deductIntegral() {
        state.deductIntegral();
    }

    /**
     * 抽奖
     */
    public void raffle() {
        if (state.raffle()) {
            // 抽奖成功，发放奖品
            //setCount(getCount()-1);
            state.dispensePrize();
        }
    }

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

    public WaitRaffleState getWaitRaffleState() {
        return waitRaffleState;
    }

    public CanRaffleState getCanRaffleState() {
        return canRaffleState;
    }

    public DispensePrizeState getDispensePrizeState() {
        return dispensePrizeState;
    }

    public PrizeOverState getPrizeOverState() {
        return prizeOverState;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}

调用客户端 Client

package state.raffle;

/**
 * @author 土味儿
 * Date 2021/7/30
 * @version 1.0
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        // 创建抽奖活动：奖品数 2
        RaffleActivity raffleActivity = new RaffleActivity(2);

        // 循环抽奖，如果没有奖品就退出
        int i = 0;
        while(raffleActivity.getCount() > 0){
            System.out.println("\n===== 第" + ++i + "次抽奖 (剩余奖品数：" + raffleActivity.getCount() + ") =====");
            // 扣积分
            raffleActivity.deductIntegral();
            // 抽奖
            raffleActivity.raffle();
        }

/*        // 循环抽奖30次，即使没有奖品了，仍然抽奖
        for (int i = 1; i < 31; i++) {
           System.out.println("\n===== 第" + i + "次抽奖 (剩余奖品数：" + raffleActivity.getCount() + ") =====");
            // 扣积分
            raffleActivity.deductIntegral();
            // 抽奖
            raffleActivity.raffle();
        }*/

    }
}

运行结果

===== 第1次抽奖 (剩余奖品数：2) =====
扣除 50 积分成功！您可以抽奖了！
正在抽奖，请稍候...
很遗憾没有中奖！

===== 第2次抽奖 (剩余奖品数：2) =====
扣除 50 积分成功！您可以抽奖了！
正在抽奖，请稍候...
㳟喜您！中奖了...
请领奖....

===== 第3次抽奖 (剩余奖品数：1) =====
扣除 50 积分成功！您可以抽奖了！
正在抽奖，请稍候...
很遗憾没有中奖！

===== 第4次抽奖 (剩余奖品数：1) =====
扣除 50 积分成功！您可以抽奖了！
正在抽奖，请稍候...
㳟喜您！中奖了...
请领奖....

4)借贷平台案例

借贷平台的订单，有审核-发布-完结等等步骤，随着操作的不同，会改变订单的状态，项目中的这个模块实现就会使用到状态模式
通常通过 if/else 判断订单的状态，从而实现不同的逻辑，伪代码如下

5)注意事项和细节

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

土味儿~

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
【设计模式六】行为型模式（中介者/备忘录/解释器/状态）

目录6、中介者模式1)基本介绍2)原理类图3)案例分析7、备忘录模式1)基本介绍2)原理类图3)案例分析4)注意事项和细节8、解释器模式1)基本介绍2)原理类图3)案例分析4)Spring中的应用5)注意事项和细节9、状态模式1)基本介绍2)原理类图3)抽奖案例4)借贷平台案例5)注意事项和细节6、中介者模式Mediator Pattern[ˈmiːdieɪtər]1)基本介绍中...
复制链接

扫一扫