java设计模式——状态模式

最新推荐文章于 2024-06-18 05:54:53 发布
最新推荐文章于 2024-06-18 05:54:53 发布
阅读量371 收藏 1
点赞数 1
分类专栏： java设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014627852/article/details/107146463
版权

APP抽奖活动问题

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

  1. 假如每参加一次这个活动要扣除用户 50积分，中奖概率是 10%。
  2. 奖品数量固定，抽完就不能抽奖。
  3. 活动有四个状态:可以抽奖、不能抽奖、发放奖品和奖品领完。
  4. 活动的四个状态转换关系图：
    在这里插入图片描述

状态模式基本介绍

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

状态模式的原理类图

在这里插入图片描述

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

状态模式解决 APP抽奖问

1)应用实例要求：完成 APP抽奖活动项目，使用状态模式。
2)思路分析和图解(类图)

  • 定义出一个接口叫状态接口，每个状态都实现它。
  • 接口有扣除积分方法、抽奖方法、发放奖品方法。
    在这里插入图片描述
  1. 代码实现
package com.jinxu.state;

import java.util.Random;

/**
 * 可以抽奖的状态
 * @author Administrator
 *
 */
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("没中奖，不能发放奖品");
    }
}


package com.jinxu.state;

/**
 * 奖品发放完毕状态
 * 说明，当我们activity 改变成 DispenseOutState， 抽奖活动结束
 * @author Administrator
 *
 */
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("奖品发送完了，请下次再参加");
    }
}


package com.jinxu.state;

/**
 * 发放奖品的状态
 * @author Administrator
 *
 */
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("很遗憾，奖品发送完了");
            // 改变状态为奖品发送完毕, 后面我们就不可以抽奖
            activity.setState(activity.getDispensOutState());
            //System.out.println("抽奖活动结束");
            //System.exit(0);
        }

    }
}


package com.jinxu.state;

/**
 * 不能抽奖状态
 * @author Administrator
 *
 */
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("不能发放奖品");
    }
}


package com.jinxu.state;

/**
 * 抽奖活动 //
 * 
 * @author Administrator
 *
 */
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();
        }

    }

    public State getState() {
        return state;
    }

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

    //这里请大家注意，每领取一次奖品，count--
    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;
    }
}


package com.jinxu.state;

/**
 * 状态抽象类
 * @author Administrator
 *
 */
public abstract class State {

	
	// 扣除积分 - 50
    public abstract void deductMoney();

    // 是否抽中奖品
    public abstract boolean raffle();

    // 发放奖品
    public abstract  void dispensePrize();

}


package com.jinxu.state;

/**
 * 状态模式测试类
 * @author Administrator
 *
 */
public class ClientTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 创建活动对象，奖品有1个奖品
        RaffleActivity activity = new RaffleActivity(1);

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

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

}

状态模式在实际项目-借贷平台

  1. 借贷平台的订单，有审核-发布-抢单等等步骤，随着操作的不同，会改变订单的状态,项目中的这个模块实现就会使用到状态模式。
  2. 通常通过 if/else判断订单的状态，从而实现不同的逻辑，伪代码如下：在这里插入图片描述
  1. 使用状态模式完成借贷平台项目的审核模块
package com.jinxu.state.money;

public abstract class AbstractState implements State {

	protected static final RuntimeException EXCEPTION = new RuntimeException("操作流程不允许");

	//抽象类，默认实现了 State 接口的所有方法
	//该类的所有方法，其子类(具体的状态类)，可以有选择的进行重写
	
    @Override
    public void checkEvent(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void checkFailEvent(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void makePriceEvent(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void acceptOrderEvent(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void notPeopleAcceptEvent(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void payOrderEvent(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void orderFailureEvent(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void feedBackEvent(Context context) {
        throw EXCEPTION;
    }
}


package com.jinxu.state.money;

//各种具体状态类
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();
	}
}

class NotPayState extends AbstractState {

	@Override
	public void payOrderEvent(Context context) {
		context.setState(new PaidState());
	}

	@Override
	public void feedBackEvent(Context context) {
		context.setState(new FeedBackState());
	}

	@Override
	public String getCurrentState() {
		return StateEnum.NOT_PAY.getValue();
	}
}

class PaidState extends AbstractState {

	@Override
	public void feedBackEvent(Context context) {
		context.setState(new FeedBackState());
	}

	@Override
	public String getCurrentState() {
		return StateEnum.PAID.getValue();
	}
}

class PublishState extends AbstractState {

	@Override
	public void acceptOrderEvent(Context context) {
		//把当前状态设置为  NotPayState。。。
		//至于应该变成哪个状态，有流程图来决定
		context.setState(new NotPayState());
	}

	@Override
	public void notPeopleAcceptEvent(Context context) {
		context.setState(new FeedBackState());
	}

	@Override
	public String getCurrentState() {
		return StateEnum.PUBLISHED.getValue();
	}
}

class ReviewState extends AbstractState {

	@Override
	public void makePriceEvent(Context context) {
		context.setState(new PublishState());
	}

	@Override
	public String getCurrentState() {
		return StateEnum.REVIEWED.getValue();
	}

}

package com.jinxu.state.money;

//环境上下文
public class Context extends AbstractState{
	//当前的状态 state, 根据我们的业务流程处理，不停的变化
	private State state;

    @Override
    public void checkEvent(Context context) {
        state.checkEvent(this);
        getCurrentState();
    }

    @Override
    public void checkFailEvent(Context context) {
        state.checkFailEvent(this);
        getCurrentState();
    }

    @Override
    public void makePriceEvent(Context context) {
        state.makePriceEvent(this);
        getCurrentState();
    }

    @Override
    public void acceptOrderEvent(Context context) {
        state.acceptOrderEvent(this);
        getCurrentState();
    }

    @Override
    public void notPeopleAcceptEvent(Context context) {
        state.notPeopleAcceptEvent(this);
        getCurrentState();
    }

    @Override
    public void payOrderEvent(Context context) {
        state.payOrderEvent(this);
        getCurrentState();
    }

    @Override
    public void orderFailureEvent(Context context) {
        state.orderFailureEvent(this);
        getCurrentState();
    }

    @Override
    public void feedBackEvent(Context context) {
        state.feedBackEvent(this);
        getCurrentState();
    }

    public State getState() {
        return state;
    }

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

    @Override
    public String getCurrentState() {
        System.out.println("当前状态 : " + state.getCurrentState());
        return state.getCurrentState();
    }
}


package com.jinxu.state.money;

/**
 * 状态接口
 * @author Administrator
 *
 */
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();
}


package com.jinxu.state.money;

/**
 * 状态枚举类
 * @author Administrator
 *
 */
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) {
        this.key = key;
        this.value = value;
    }
    public int getKey() {return key;}
    public String getValue() {return value;}
}

状态模式的注意事项和细节

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

java设计模式往期回顾：

  1. java设计模式
  2. java设计模式原则——单一职责原则
  3. java设计模式原则——接口隔离原则
  4. java设计模式原则——依赖倒置原则
  5. java设计模式原则——里氏替换原则
  6. java设计模式原则——开闭原则
  7. java设计模式原则——迪米特法则
  8. java设计模式原则——合成复用原则
  9. java设计模式概述和分类
  10. java设计模式——单例模式
  11. java设计模式——工厂模式
  12. java设计模式——原型模式
  13. java设计模式——建造者模式
  14. java设计模式——适配器模式
  15. java设计模式——桥接模式
  16. java设计模式——装饰者模式
  17. java设计模式——组合模式
  18. java设计模式——外观模式
  19. java设计模式——享元模式
  20. java设计模式——代理模式
  21. java设计模式——模板方法模式
  22. java设计模式——命令模式
  23. java设计模式——访问者模式
  24. java设计模式——迭代器模式
  25. java设计模式——观察者模式
  26. java设计模式——中介者模式
  27. java设计模式——备忘录模式
  28. java设计模式——解释器模式
呆萌坦然
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java设计模式之——状态模式
AkaiC的博客
10-31 636
状态方法模式简单介绍状态模式中的行为是由状态来决定的，不同的状态下有不同的行为。状态模式和策略模式的结构几乎完全一样，但它们的目的、本质却完全不一样。状态模式的行为是平行的、不可替换的，策略模式的行为是彼此独立、可相互替换的。用一句话来表述，状态模式把对象的行为包装在不同的状态对象里，每一个状态对象都有一个共同的抽象状态基类。状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。状态模
Java 设计模式之状态模式
m0_45196258的博客
08-20 112
状态模式(State) 当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。 状态模式主要是解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况，把状态的判断逻辑转移到表示不同状态的一系列的类中，可以把复杂的逻辑简化。如果这个状态判断很简单，就没必要用状态模式了。 状态模式的好处是将与特定状态相关的行为局部化，并且将不同状态的行为分割开来。 将特定的状态相关的行为都放入一个对象中，由于所有与状态相关的代码都存在于某个ConcreteState中，所以通过定义新的子类可以很容易的增
java设计模式之状态模式
12-07
java设计模式之状态模式，通过实际生活中的例子说明状态模式的原理。
Java 状态模式
aotangai1607的博客
10-28 81
　　在阎宏博士的《JAVA与模式》一书中开头是这样描述状态（State）模式的：状态模式，又称状态对象模式（Pattern of Objects for States），状态模式是对象的行为模式。状态模式允许一个对象在其内部状态改变的时候改变其行为。这个对象看上去就像是改变了它的类一样。 　　状态模式的结构 　　状态模式把对象的行为包装在不同的状态对象里，每一个状态对象都属于一...
《设计模式就该这样学》之彻底搞懂Spring状态机原理，实现订单与物流解耦
最新发布
2401_85763569的博客
06-18 826
本文节选自《设计模式就该这样学》1　状态模式的UML类图状态模式的UML类图如下图所示。2　使用状态模式实现登录状态自由切换否则，跳转到登录界面，登录后再继续执行先前的动作。这里涉及的状态有两种：登录与未登录；下面使用状态模式来实现这个逻辑，代码如下。首先创建抽象状态角色UserState类。然后创建登录状态LogInState类。@Override创建未登录状态UnloginState类。
java状态模式
沈纵情
05-25 1086
参考：http://blog.csdn.net/shendl/archive/2006/09/22/1267142.aspx         http://zhidao.baidu.com/question/93967748.html状态模式：当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。使用前提：状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的判断逻辑简化。使用好处：将与特定状态相关的行为局部化
Java状态模式（State模式）
weixin_34088838的博客
09-16 154
from:http://www.weixueyuan.net/view/6170.htmlState的定义：不同的状态，不同的行为；或者说，每个状态有着相应的行为。何时使用状态模式State模式在实际使用中比较多，适合"状态的切换"。因为我们经常会使用If elseif else 进行状态切换， 如果针对状态的这样判断切换反复出现，我们就要联想到是否可以采取State模式了。...
JAVA 状态模式
✧V的博客
05-25 250
文章目录 介绍 状态模式 实现 介绍 描述 状态模式设计模式属于行为型模式，对于控制一个对象状态转换的条件表达式过于复杂时，将其特定的状态相关的行为都放入一个对象中，通过定义新的状态类去改变当前上下文状态从而改变它的相关行为。特点 优点：取代大量的if-else操作，多个环境对象共享一个状态对象，减少相互间的依赖。 缺点：增加系统类和对象的个数，导致系统维护难度增加。 实现原理 将同一个状态对象传入，在不同的状态中，改变实例变量的值。 Context（上下文类）：在环..
Java设计模式——备忘录模式
邻家小乌龟的博客
11-16 858
Java设计模式——备忘录模式课程学习笔记（自用）
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
本资料“《java设计模式》课后习题模拟试题解答——刘伟.zip”主要涵盖了Java设计模式的学习与应用，特别是针对刘伟教授的相关课程的课后习题及模拟试题的解答。 设计模式分为三大类：创建型、结构型和行为型模式。...
Java设计模式——中介者模式
邻家小乌龟的博客
11-16 332
Java设计模式——中介者模式学习笔记整理（自用）
Java设计模式——观察者模式
05-04
首先，我们来看"Java设计模式——观察者模式的两种情况"： 1. **主动通知**: 在这种情况下，被观察者对象在自身状态发生变化时，会主动调用`Observable`接口提供的`notifyObservers()`方法，将变化通知给所有注册的...
Java与模式——源码
01-15
《Java与模式——源码》这个主题涉及到的是Java编程语言中的设计模式应用，以及如何通过源代码来理解和学习这些模式。设计模式是软件工程中的一种最佳实践，它们是解决常见问题的经验总结，使得代码更易读、易维护、...
Java状态模式
光临天下
04-26 759
允许对象在内部状态改变时 , 改变它的行为。
java之状态模式
huzd博客
05-23 288
状态模式 定义 状态模式，又称状态对象模式（Pattern of Objects for States），状态模式是对象的行为模式。状态模式允许一个对象在其内部状态改变的时候改变其行为。这个对象看上去就像是改变了它的类一样。 角色 环境(Context)角色，也成上下文：定义客户端所感兴趣的接口，并且保留一个具体状态类的实例。这个具体状态类的实例给出此环境对象的现有状态。 抽象状态(State)...
《看小说学设计模式》——Java设计模式解析
"看小说学设计模式pdf版" 是一本以轻松的小故事方式解释Java设计模式的书籍，适合不同层次的开发者，从初级到高级，甚至系统分析师都能从中获益。书中涵盖了25种常见的设计模式，包括策略模式、代理模式、单例模式等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值