状态模式
1. 题目
- 不能抽奖
- 扣除50积分，可以抽奖
- 未中奖，变为 不能抽奖
- 10% 会中奖 发放奖品
- 奖品 >0 变为不能抽奖
- 奖品==0 奖品领完
- 扣除50积分，可以抽奖
请编写程序完成APP抽奖活动 具
体要求如下:
- 假如每参加一次这个活动要
扣除用户50积分，中奖概率
是10% - 奖品数量固定，抽完就不能
抽奖 - 活动有四个状态: 可以抽奖、
不能抽奖、发放奖品和奖品
领完 - 活动的四个状态转换关系图
2. 基本介绍
- 状态模式（State Pattern）：它主要用来解决对象在多种状态转换时，需要对外
输出不同的行为的问题。状态和行为是一一对应的，状态之间可以相互转换 - 当一个对象的内在状态改变时，允许改变其行为，这个对象看起来像是改变了
其类
3. 角色职责
- Context 类为环境角色, 用于维护State实例,这个实例定义当前状态
- State 是抽象状态角色,定义一个接口封装与Context 的一个特点接口相关行为
- ConcreteState 具体的状态角色，每个子类实现一个与Context 的一个状态相关行为
- Context
- State 状态 和 获取
- State
- operation1
- operation2
- ConcreteStateA
- ConcreteStateB
Raffle
英
/ˈræfl/
美
/ˈræfl/
全球发音
简明 牛津 新牛津 韦氏 柯林斯 例句 百科
n.
废物；抽彩售货
vt.
抽彩售货
vi.
抽彩
dispense
英
/dɪˈspens/
美
/dɪˈspens/
全球发音
简明 牛津 新牛津 韦氏 柯林斯 例句 百科
v.
发放，分配；提供，施予；配（药），发（药）
-
State
- deduceMoney()
- raffle 返回布尔
- dispensePrize
-
状态的子类
- NoRaffle State 不能抽奖
- CanRaffle State 可以抽奖
- Dispense State 发放奖品
- Dispense Out State 奖品发完
-
Activity 类关联，这些 子类
-
Client 调用 Activity，依赖 State
4. 状态模式
状态接口
public abstract class State {
// 扣除积分 - 50
public abstract void deductMoney();
// 是否抽中奖品
public abstract boolean raffle();
// 发放奖品
public abstract void dispensePrize();
}
不能抽奖的状态
public class NoRaffleState extends State {
// 初始化时传入活动引用，扣除积分后改变其状态
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 {
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){
// 改变活动状态为发放奖品 context
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 {
// 初始化时传入活动引用，发放奖品后改变其状态
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("很遗憾，奖品发送完了");
// 改变状态为奖品发送完毕, 后面我们就不可以抽奖
//即：再次调用抽奖，会是 DispensOutState 的抽奖方法。
activity.setState(activity.getDispensOutState());
//System.out.println("抽奖活动结束");
//System.exit(0);
}
}
}
奖品发完
/**
* 奖品发放完毕状态
* 说明，当我们activity 改变成 DispenseOutState， 抽奖活动结束
*/
public class DispenseOutState extends State {
// 初始化时传入活动引用
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 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);
//构造器
//1. 初始化当前的状态为 noRafflleState（即不能抽奖的状态）
//2. 初始化奖品的数量
public RaffleActivity( int count) {
this.state = getNoRafflleState();
this.count = count;
}
//扣分, 调用当前状态的 deductMoney
public void debuctMoney(){
state.deductMoney();
}
//抽奖
public void raffle(){
// 如果当前的状态是抽奖成功
if(state.raffle()){
//领取奖品
state.dispensePrize();
}
}
//这里请大家注意，每领取一次奖品，count--
public int getCount() {
int curCount = count;
count--;
return curCount;
}
public void setCount(int count) {
this.count = count;
}
//get set
//state noRafflleState canRaffleState dispenseState dispensOutState
}
测试类
// 创建活动对象，奖品有1个奖品
RaffleActivity activity = new RaffleActivity(1);
// 我们连续抽300次奖
for (int i = 0; i < 30; i++) {
System.out.println("--------第" + (i + 1) + "次抽奖----------");
// 参加抽奖，第一步点击扣除积分
activity.debuctMoney();
// 第二步抽奖
activity.raffle();
}
发奖接口完善
public void dispensePrize() {
int count = activity.getCount();
if (count > 0) {
System.out.println("恭喜中奖了，还剩：" + (count - 1) + "个奖品");
// 改变状态为不能抽奖
activity.setState(activity.getNoRafflleState());
if (count == 1) {
System.out.println("抽奖活动结束=======奖品发放完毕");
System.exit(0);
}
} else {
System.out.println("很遗憾，奖品发送完了");
System.out.println("抽奖活动结束");
System.exit(0);
}
}
5. 状态模式 贷款
状态接口
public interface State {
/**
* 电审
*/
void checkEvent(Context context);
/**
* 电审失败
*/
void checkFailEvent(Context context);
/**
* 定价发布
*/
void makePriceEvent(Context context);
/**
* 接单
*/
void acceptOrderEvent(Context context);
/**
* 无人接单失效
*/
void notPeopleAcceptEvent(Context context);
/**
* 付款
*/
void payOrderEvent(Context context);
/**
* 接单有人支付失效
*/
void orderFailureEvent(Context context);
/**
* 反馈
*/
void feedBackEvent(Context context);
String getCurrentState();
}
抽象类 默认实现
public abstract class AbstractState implements State {
protected static final RuntimeException EXCEPTION = new RuntimeException("操作流程不允许");
//抽象类，默认实现了 State 接口的所有方法
//该类的所有方法，其子类(具体的状态类)，可以有选择的进行重写
@Override
public void checkEvent(Context context) {
throw EXCEPTION;
}
}
各种具体的类
//各种具体状态类
class FeedBackState extends AbstractState {
@Override
public String getCurrentState() {
return StateEnum.FEED_BACKED.getValue();
}
}
class GenerateState extends AbstractState {
@Override
public void checkEvent(Context context) {
context.setState(new ReviewState());
}
@Override
public void checkFailEvent(Context context) {
context.setState(new FeedBackState());
}
@Override
public String getCurrentState() {
return StateEnum.GENERATE.getValue();
}
}
//NotPayState
//PaidState
//ReviewState
class PublishState extends AbstractState {
@Override
public void acceptOrderEvent(Context context) {
//把当前状态设置为 NotPayState。。。
//至于应该变成哪个状态，有流程图来决定
context.setState(new NotPayState());
}
}
枚举状态
/**
* 状态枚举类
*/
public enum StateEnum {
//订单生成
GENERATE(1, "GENERATE"),
//已审核
REVIEWED(2, "REVIEWED"),
//已发布
PUBLISHED(3, "PUBLISHED"),
//待付款
NOT_PAY(4, "NOT_PAY"),
//已付款
PAID(5, "PAID"),
//已完结
FEED_BACKED(6, "FEED_BACKED");
private int key;
private String value;
//StateEnum(int key, String value)
//getKey
//getValue
}
流程类
//环境上下文
public class Context extends AbstractState{
//当前的状态 state, 根据我们的业务流程处理，不停的变化
private State state;
@Override
public void checkEvent(Context context) {
state.checkEvent(this);
getCurrentState();
}
//getState
//setState
@Override
public String getCurrentState() {
System.out.println("当前状态 : " + state.getCurrentState());
return state.getCurrentState();
}
}
进行测试
//创建context 对象
Context context = new Context();
//将当前状态设置为 PublishState
context.setState(new PublishState());
System.out.println(context.getCurrentState());
// //publish --> not pay
context.acceptOrderEvent(context);
// //not pay --> paid
context.payOrderEvent(context);
// // 失败, 检测失败时，会抛出异常
// try {
// context.checkFailEvent(context);
// System.out.println("流程正常..");
// } catch (Exception e) {
// System.out.println(e.getMessage());
// }
当前状态 : PUBLISHED
PUBLISHED //返回值打印的
当前状态 : NOT_PAY
当前状态 : PAID
6. 传统if问题 和 注意
这类代码难以应对变化，在添加一种状态时，我们需要手动
添加if/else，在添加一种功能时，要对所有的状态进行判断。
因此代码会变得越来越臃肿，并且一旦没有处理某个状态，
便会发生极其严重的BUG，难以维护
状态模式的注意事项和细节
- 代码有很强的可读性。状态模式将每个状态的行为封装到对应的一个类中
- 方便维护。将容易产生问题的if-else语句删除了，如果把每个状态的行为都放到一
个类中，每次调用方法时都要判断当前是什么状态，不但会产出很多if-else语句，
而且容易出错 - 符合“开闭原则”。容易增删状态
- 会产生很多类。每个状态都要一个对应的类，当状态过多时会产生很多类，加大维
护难度 - 应用场景：当一个事件或者对象有很多种状态，状态之间会相互转换，对不同的状
态要求有不同的行为的时候，可以考虑使用状态模式
策略模式
有各种鸭子(比如 野鸭、北京鸭、水鸭等， 鸭子有各种行为，比如 叫、飞行等)
非模式
顶层抽象类
public abstract class Duck {
public Duck() {
}
public abstract void display();//显示鸭子信息
public void quack() {
System.out.println("鸭子嘎嘎叫~~");
}
public void swim() {
System.out.println("鸭子会游泳~~");
}
}
实现类
public class ToyDuck extends Duck{
@Override
public void display() {
// TODO Auto-generated method stub
System.out.println("玩具鸭");
}
//需要重写父类的所有方法
public void quack() {
System.out.println("玩具鸭不能叫~~");
}
public void swim() {
System.out.println("玩具鸭不会游泳~~");
}
}
非模式的问题
-
其它鸭子，都继承了Duck类，所以fly让所有子类都会飞了，这是不正确的
-
上面说的1 的问题，其实是继承带来的问题： 对类的局部改动，尤其超类的局部改
动，会影响其他部分。会有溢出效应 -
为了改进1问题，我们可以通过覆盖fly 方法来解决 => 覆盖解决
-
问题又来了，如果我们有一个玩具鸭子ToyDuck, 这样就需要ToyDuck去覆盖Duck
的所有实现的方法 => 解决思路 策略模式 (strategy pattern)
基本简介
基本介绍
- 策略模式（Strategy Pattern）中，定义算法族，分别封装起来，让他们之间可以
互相替换，此模式让算法的变化独立于使用算法的客户 - 这算法体现了几个设计原则，
- 第一、把变化的代码从不变的代码中分离出来；
- 第二、针对接口编程而不是具体类（定义了策略接口）；
- 第三、多用组合/聚合，
少用继承（客户通过组合方式使用策略）。
角色划分
context 有成员变量strategy 或者 其他的策略接口,
-
至于需要使用到哪个策略，我们可以在构造器中指定.
-
Context
-
Strategy 聚合此接口，可能有多个这样接口
-
operation1 和 operation2
-
Concrete StrategyA
-
Concrete StrategyB
-
-
-
Duck 聚合：FlyBehavior
-
PekingDuck
-
Toy
-
Wild
-
-
FlyBehavior
- No FlyBehavior
- Bad
- Good
-
Quack Behavior
- No Quack
- GeGe
- GaGa
wild
英
/waɪld/
美
/waɪld/
全球发音
简明 牛津 新牛津 韦氏 柯林斯 例句 百科
adj.
（动植物）自然生长的，野生的；（土地）无人烟的，未开垦的；（人）未开化的，野蛮的；不受控制的，放荡的；暴风雨的，狂暴的；（做事或说话）轻率的，缺乏根据的；激动人心的；满腔热情的
adv.
自然地，不受控制地
n.
偏远地区，人烟稀少的地区；自然环境，野生状态
behavior
英
/bɪˈheɪvjə(r)/
美
/bɪˈheɪvjər/
全球发音
简明 韦氏 柯林斯 例句 百科
n.
行为，举止；态度；反应
quack
英
/kwæk/
美
/kwæk/
全球发音
简明 牛津 新牛津 韦氏 柯林斯 例句 百科
n.
（鸭子的）呱呱声，嘎嘎声；庸医，江湖郎中；<非正式>医生
v.
（鸭子）呱呱叫，嘎嘎叫；<非正式>大声说蠢话，咭咭呱呱
adj.
江湖医生的
使用模式
行为的接口 和 实现
public interface FlyBehavior {
void fly(); // 子类具体实现
}
public class GoodFlyBehavior implements FlyBehavior {
@Override
public void fly() {
System.out.println(" 飞翔技术高超 ~~~");
}
}
public class NoFlyBehavior implements FlyBehavior{
@Override
public void fly() {
System.out.println(" 不会飞翔 ");
}
}
鸭子的父抽象类
public abstract class Duck {
//属性, 策略接口
FlyBehavior flyBehavior;
//其它属性<->策略接口
//QuackBehavior quackBehavior;
public Duck() {
}
public abstract void display();//显示鸭子信息
public void fly() {
//改进
if(flyBehavior != null) {
flyBehavior.fly();
}
}
//set: flyBehavior 和 quackBehavior
}
野鸭和玩具鸭实现
public class WildDuck extends Duck {
//构造器，传入FlyBehavor 的对象
public WildDuck() {
flyBehavior = new GoodFlyBehavior();
}
@Override
public void display() {
System.out.println(" 这是野鸭 ");
}
}
public class ToyDuck extends Duck{
public ToyDuck() {
flyBehavior = new NoFlyBehavior();
}
@Override
public void display() {
System.out.println("玩具鸭");
}
}
测试
WildDuck w = new WildDuck();
w.fly();
//动态改变某个对象的行为, 北京鸭 不能飞
w.setFlyBehavior(new NoFlyBehavior());
System.out.println("野鸭的实际飞翔能力");
w.fly();
飞翔技术高超 ~~~
野鸭的实际飞翔能力
不会飞翔
核心：有原来的 继承，转换为 聚合 或 组合。
Arrays
案例
//数组
Integer[] data = { 9, 1, 2, 8, 4, 3 };
// 实现降序排序，返回-1放左边，1放右边，0保持不变
// 说明
// 1. 实现了 Comparator 接口（策略接口） , 匿名类 对象 new Comparator<Integer>(){..}
// 2. 对象 new Comparator<Integer>(){..} 就是实现了 策略接口 的对象
// 3. public int compare(Integer o1, Integer o2){} 指定具体的处理方式
Comparator<Integer> comparator = new Comparator<Integer>() {
public int compare(Integer o1, Integer o2) {
if (o1 > o2) {
//如果返回1 是升序，这里是 降序
return -1;
} else {
return 1;
}
};
};
//方式1
Arrays.sort(data, comparator);
System.out.println(Arrays.toString(data)); // 降序排序
//方式2- 同时lambda 表达式实现 策略模式
Integer[] data2 = { 19, 11, 12, 18, 14, 13 };
Arrays.sort(data2, (var1, var2) -> {
if(var1.compareTo(var2) > 0) {
return -1;
} else {
return 1;
}
});
System.out.println("data2=" + Arrays.toString(data2));
sort方法
// 说明
* public static <T> void sort(T[] a, Comparator<? super T> c) {
if (c == null) {
sort(a); //默认方法
} else {
if (LegacyMergeSort.userRequested)
legacyMergeSort(a, c); //使用策略对象c
else
// 使用策略对象c
TimSort.sort(a, 0, a.length, c, null, 0, 0);
}
}
策略接口
@FunctionalInterface
public interface Comparator<T> {
}
注意点
- 策略模式的关键是： 分析项目中变化部分与不变部分
- 策略模式的核心思想是：多用组合/聚合 少用继承；用行为类组合，而不是行为的
继承。更有弹性 - 体现了“对修改关闭，对扩展开放”原则，客户端增加行为不用修改原有代码，只
要添加一种策略（或者行为）即可， 避免了使用多重转移语句（if…else if…else） - 提供了可以替换继承关系的办法： 策略模式将算法封装在独立的Strategy类中使得
你可以独立于其Context改变它，使它易于切换、易于理解、易于扩展 - 需要注意的是：每添加一个策略就要增加一个类，当策略过多是会导致类数目庞大
132
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
