设计模式: 自己手动写一个状态模式

状态模式: 允许对象在内部状态改变时改变它的行为,对象看起来好像修改了它的类。状态模式将状态封装成独立的类,并将动作委托到代表当前状态的对象。状态模式使用组合通过简单引用不同的状态对象来造成类改变的假象。

状态模式和策略模式有相同的类图,但它们的意图不同,策略模式会用行为和算法来配置Context类。状态模式允许Context随着状态的改变而改变其行为。

源代码:

</pre><pre name="code" class="java">package state;
/**
 * 状态接口
 * @author Arvon
 *
 */
public interface State {
	/**
	 * 放入25分钱
	 */
	public void insertQuarter();
	/**
	 * 取出25分钱
	 */
	public void ejectQuarter();
	/**
	 * 扭动曲轴
	 */
	public void turnCrank();
	/**
	 * 分配口香糖
	 */
	public void dispense();
	/**
	 * 重新初始化口香糖机
	 */
	public void refill();
}
package state;

import java.util.Random;

public class HasQuarterState implements State {
	Random randomWinner = new Random(System.currentTimeMillis());
	GumballMachine gumballMachine;
	public HasQuarterState(GumballMachine gumballMachine) {
		this.gumballMachine = gumballMachine;
	}

	@Override
	public void insertQuarter() {
		System.out.println("You can't insert another quarter");

	}

	@Override
	public void ejectQuarter() {
		System.out.println("Quarter returned");
		gumballMachine.setState(gumballMachine.getNoQuarterState());

	}

	@Override
	public void turnCrank() {
		System.out.println("You turned...");
		int winner = randomWinner.nextInt(10);
		boolean isWinner = (winner == 0) && (gumballMachine.getCount() > 1);
		gumballMachine.setState(isWinner?gumballMachine.getWinnerState():gumballMachine.getSoldState());
	}

	@Override
	public void dispense() {
		System.out.println("please turn the crank,or No gumball will be dispensed");
	}

	@Override
	public void refill() {

	}

}
package state;

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

	@Override
	public void insertQuarter() {
		System.out.println("You inserted a quarter");
		gumballMachine.setState(gumballMachine.getHasQuarterState());

	}

	@Override
	public void ejectQuarter() {
		System.out.println("You haven't inserted a quarter");
	}

	@Override
	public void turnCrank() {
		System.out.println("You turned, but there's no quarter");
	}

	@Override
	public void dispense() {
		System.out.println("You need to pay first");
	}

	@Override
	public void refill() {

	}

}
package state;
/**
 * 售罄状态
 * @author Administrator
 *
 */
public class SoldOutState implements State {
	GumballMachine mGumballMachine;

	public SoldOutState(GumballMachine mGumballMachine) {
		super();
		this.mGumballMachine = mGumballMachine;
	}

	@Override
	public void insertQuarter() {
		// TODO Auto-generated method stub
		System.out.println("You can't insert a quarter, the machine is sold out");

	}

	@Override
	public void ejectQuarter() {
		// TODO Auto-generated method stub
		System.out.println("You can't eject, you haven't inserted a quarter yet");
	}

	@Override
	public void turnCrank() {
		// TODO Auto-generated method stub
		System.out.println("You turned, but there are no gumballs");
	}

	@Override
	public void dispense() {
		// TODO Auto-generated method stub
		System.out.println("No gumball dispensed");

	}

	@Override
	public void refill() {
		mGumballMachine.setState(mGumballMachine.getNoQuarterState());
	}

}
package state;

public class SoldState implements State {

	private GumballMachine gumballMachine;

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

	@Override
	public void insertQuarter() {
		System.out.println("Please wait, we're already giving you a gumball");
	}

	@Override
	public void ejectQuarter() {
		System.out.println("Sorry, you already turned the crank");

	}

	@Override
	public void turnCrank() {
		System.out.println("Turning twice doesn't get you another gumball!");

	}

	@Override
	public void dispense() {
		gumballMachine.releaseBall();
		if (gumballMachine.getCount() > 0)
			gumballMachine.setState(gumballMachine.getNoQuarterState());
		else {
			System.out.println("Oops, out of gumballs!");
			gumballMachine.setState(gumballMachine.getSoldOutState());
		}
	}

	@Override
	public void refill() {
		// TODO Auto-generated method stub

	}

}
package state;

public class WinnerState implements State {

	private GumballMachine gumballMachine;

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

	@Override
	public void insertQuarter() {
		System.out.println("Please wait, we're already giving you a Gumball");
	}

	@Override
	public void ejectQuarter() {
		System.out.println("Please wait, we're already giving you a Gumball");
	}

	@Override
	public void turnCrank() {
		System.out.println("Turning again doesn't get you another gumball!");
	}

	@Override
	public void dispense() {
		gumballMachine.releaseBall();
		if (gumballMachine.getCount() == 0)
			gumballMachine.setState(gumballMachine.getSoldOutState());
		else {
			gumballMachine.releaseBall();
			System.out.println("YOU'RE A WINNER! You got two gumballs for your quarter");
			if (gumballMachine.getCount() > 0)
				gumballMachine.setState(gumballMachine.getNoQuarterState());
			else {
            	System.out.println("Oops, out of gumballs!");
				gumballMachine.setState(gumballMachine.getSoldOutState());
			}
		}
	}

	@Override
	public void refill() {
		// TODO Auto-generated method stub

	}

}
package state;
/**
 * GumballMachine has soldOutState...
 * @author Administrator
 *
 */
public class GumballMachine {
	State soldOutState;
	State noQuarterState;
	State hasQuarterState;
	State soldState;
	State winnerState;
	State state = soldOutState;
	int count = 0;
	public GumballMachine(int numberGumballs) {
		soldOutState = new SoldOutState(this);
		noQuarterState = new NoQuarterState(this);
		hasQuarterState = new HasQuarterState(this);
		soldState = new SoldState(this);
		winnerState = new WinnerState(this);

		this.count = numberGumballs;
 		if (numberGumballs > 0) {
			state = noQuarterState;
		}
	}

	public State getSoldOutState() {
		return soldOutState;
	}

	public State getSoldState() {
		return soldState;
	}

	public State getWinnerState() {
		return winnerState;
	}

	public State getNoQuarterState() {
		return noQuarterState;
	}
	public State getHasQuarterState() {
		return hasQuarterState;
	}

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

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

	public void turnCrank() {
		state.turnCrank();
		state.dispense();
	}
	public void releaseBall() {
		System.out.println("A gumball comes rolling out the slot...");
		if (count != 0)
			count = count - 1;
	}

	public int getCount() {
		return count;
	}

	public String toString() {
		StringBuffer result = new StringBuffer();
		result.append("\nMighty Gumball, Inc.");
		result.append("\nJava-enabled Standing Gumball Model #2004");
		result.append("\nInventory: " + count + " gumball");
		if (count != 1) {
			result.append("s");
		}
		result.append("\n");
		result.append("Machine is " + state + "\n");
		return result.toString();
	}

}
package state;

public class StateTest {

	public static void main(String[] args) {
		GumballMachine mGumballMachine = new GumballMachine(10);
		System.out.println(mGumballMachine);

		mGumballMachine.ejectQuarter();
		for(int i=0;i<6;i++){
			mGumballMachine.insertQuarter();
			mGumballMachine.turnCrank();
		}
		System.out.println(mGumballMachine);
	}

}

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-12-08 01:13:39

设计模式: 自己手动写一个状态模式的相关文章

设计模式: 自己手动写一个代理模式

代理模式:为另一个对象提供一个替身或占位符以访问这个对象.代理模式为另一个对象提供代表,以便控制客户对对象的访问,管理访问的方式有许多种. 远程代理管理客户和远程对象之间的交互. 虚拟代理控制访问实例化开销大的对象. 保护代理基于调用者控制对对象方法的访问. 代理模式有许多变体,例如:缓存代理.同步代理.防火墙代理.写入时复制代理. Java内置的代理支持,可以根据需要动态创建代理,并将所有调用分配到所选的调用处理器(InvocationHandler). 下面 的例子是一种保护代理 类图: 源

设计模式 ( 十八 ):State状态模式 -- 行为型

1.概述 在软件开发过程中,应用程序可能会根据不同的情况作出不同的处理.最直接的解决方案是将这些所有可能发生的情况全都考虑到.然后使用if... ellse语句来做状态判断来进行不同情况的处理.但是对复杂状态的判断就显得“力不从心了”.随着增加新的状态或者修改一个状体(if else(或switch case)语句的增多或者修改)可能会引起很大的修改,而程序的可读性,扩展性也会变得很弱.维护也会很麻烦.那么我就考虑只修改自身状态的模式. 例子1:按钮来控制一个电梯的状态,一个电梯开们,关门,停,

设计模式之第21章-状态模式(Java实现)

设计模式之第21章-状态模式(Java实现) “what are you 干啥了?怎么这么萎靡不振?”“昨晚又是补新番,又是补小笼包,睡得有点晚啊.话说杨过的那个雕兄真是太好了,每天给找蛇胆,又陪练武功的,想不无敌都难啊,还有那个blablabla”(作者已被拖走).咳咳,今天那个状态哥哥马不停蹄的赶过来,下面闪亮登场. 状态模式之自我介绍 今天不在状态,可能是由于宇宙差的原因,好了,先说下定义:Allow an object to alter its behavior when its int

原来热加载如此简单,手动写一个 Java 热加载吧

1. 什么是热加载 热加载是指可以在不重启服务的情况下让更改的代码生效,热加载可以显著的提升开发以及调试的效率,它是基于 Java 的类加载器实现的,但是由于热加载的不安全性,一般不会用于正式的生产环境. 2. 热加载与热部署的区别 首先,不管是热加载还是热部署,都可以在不重启服务的情况下编译/部署项目,都是基于 Java 的类加载器实现的. 那么两者到底有什么区别呢? 在部署方式上: 热部署是在服务器运行时重新部署项目. 热加载是在运行时重新加载 class. 在实现原理上: 热部署是直接重新

【设计模式学习笔记】 之 状态模式

简介: 每种事物都有不同的状态,不同的状态会有不同的表现,通过更改状态从而改变表现的设计模式称为状态模式(state pattern) 下边会通过多个例子进行讲述,会有一些代码重用的类,请注意包名! 举例1: 人有多种心情,不同的心情会有不同的表现,这里先使用分支判断写个小例子 创建一个Person类,它持有一个表示心情的字符串,通过设置这个字符串并对这个字符串进行判断来决定产生不同的行为 1 package com.mi.state.state1; 2 3 /** 4 * 人类,拥有一个状态属

设计模式(十五)状态模式

相关文章 设计模式系列 前言 建议在阅读本文前先阅读设计模式(十一)策略模式这篇文章,虽说状态模式和策略模式的结构几乎是相同的,但是它们所解决的问题是不同的,读完这两篇文章你就会有了答案. 1.状态模式定义 状态模式定义 定义:当一个对象的内在状态改变时允许改变其行为,这个对象看起来像是改变了其类. 状态模式UML图 在享元模式中有如下角色: Context:环境角色,定义客户端需要的接口,并且负责具体状态的切换. State:抽象状态角色,可以是抽象类或者接口,负责对象状态定义,并封装了环境角

设计模式之十二:状态模式(State)

状态模式: 当一个对象的内部状态发生变化时允许改变它的行为. Allow an object to alter its behavior when its internal state changes. The object will appear to change its class. 状态模式将依赖于状态的行为分离成了各种状态类,每一种特定的转态类只处理单一的行为,并且定义了各种状态之间的转移变迁关系. UML图: 主要包括: Context:定义了客户端需要的接口,操作了一个当前状态类的

设计模式(十九)状态模式(State)-行为型

状态模式(State)-行为型 在职责链模式中,将条件语句改成多个职责类进行处理,如果不是自己处理,则自动转到下一个职责类,如果在转给下一个职责类进行处理前,需要修改当前的状态,此时就需要用到状态模式. 引例:电梯的运行过程,各种状态切换. 实现原理图 状态模式实现原理图 状态模式就是根据对象的状态不同,作出不同的行为.状态模式使代码中复杂而庸常的逻辑判断语句问题得到了解决,而且具体状态角色将具体状态和他对应的行为封装了起来,这使得增加一种新的状态变得十分简单.状态模式主要由三部分组成,抽象状态

23种设计模式(16):状态模式

概述 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新. 类型:行为类模式. 类图: 适用性: 1.一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为. 2.一个操作中含有庞大的多分支的条件语句,且这些分支依赖于该对象的状态. 这个状态通常用一个或多个枚举常量表示. 通常,有多个操作包含这一相同的条件结构. State模式将每一个条件分支放入一个独立的类中. 这使得你可以根据对象自身的情况将对象的状态作为一个对象,这一对象