设计模式(Java)----状态模式State

人、事物在不同状态下会有不同表现，而一个状态又会在不同的表现下转移到下一个不同的状态。
例题：
工作状态的变化
上午状态好，中午想睡觉，下午渐恢复，加班苦煎熬。

class Work{
	private int hour;
	private Boolean finish=false;
	public int getHour() {
		return hour;
	}
	public void setHour(int hour) {
		this.hour = hour;
	}
	public Boolean getFinish() {
		return finish;
	}
	public void setFinish(Boolean finish) {
		this.finish = finish;
	}
	public void WriteProgram() {
		if(hour<12) {
			System.out.println("当前时间："+hour+"点上午工作，精神百倍");
		}else if(hour<13) {
			System.out.println("当前时间："+hour+"点饿了，午饭；犯困，午休");
		}else if(hour<17) {
			System.out.println("当前时间："+hour+"点下午状态还不错，继续努力");
		}else {
			if(finish) {
				System.out.println("当前时间："+hour+"点 下班回家了");
			}else {
				if(hour<21) {
					System.out.println("当前时间："+hour+"点 加班哦，疲惫至极");
				}else {
					System.out.println("当前时间："+hour+"点 不行了，睡着了。");
				}
			}
		}
	}
}
public  class Main{
	public static void main(String[] args){
		Work emergencyProjects=new Work();
		emergencyProjects.setHour(9);
		emergencyProjects.WriteProgram();
		emergencyProjects.setHour(10);
		emergencyProjects.WriteProgram();
		emergencyProjects.setHour(12);
		emergencyProjects.WriteProgram();
		emergencyProjects.setHour(14);
		emergencyProjects.WriteProgram();
		emergencyProjects.setHour(17);
		emergencyProjects.WriteProgram();
		emergencyProjects.setFinish(false);
		emergencyProjects.WriteProgram();
		emergencyProjects.setHour(19);
		emergencyProjects.WriteProgram();
		emergencyProjects.setHour(22);
		emergencyProjects.WriteProgram();
	}
}

问题：

1、方法很长，而且有很多个判断分支，意味着它的责任过大，面向对象设计其实就是希望做到代码的责任分解。——违背了 "单一职责原则”

2、writeProgram的方法里有很多判断，使得任何需求的改动或增加都需要去更改这个方法，但目前的代码却是对整个方法做改动的，维护出错的风险很大。——违背了“开放-封闭原则”

工作状态用状态模式实现

abstract class State{
	public abstract void WriteProgram(Work w);
}
class Work{
	private State current;
	private double hour;
	private boolean finish=false;
	public Work() {
		current=new ForenoonState();
	}
	public State getCurrent() {
		return current;
	}
	public void setCurrent(State current) {
		this.current = current;
	}
	public double getHour() {
		return hour;
	}
	public void setHour(double hour) {
		this.hour = hour;
	}
	public boolean isFinish() {
		return finish;
	}
	public void setFinish(boolean finish) {
		this.finish = finish;
	}
	public void SetState(State s) {
		current=s;
	}
	public void WriteProgram() {
		current.WriteProgram(this);
	}
}
class ForenoonState extends State{
	public void WriteProgram(Work w) {
		if(w.getHour()<12) {
			System.out.println("当前时间"+w.getHour()+"点 上午工作，精神百倍");
		}else {
			w.SetState(new NoonState());
			w.WriteProgram();
		}
	}
}
class NoonState extends State{
	public void WriteProgram(Work w) {
		if(w.getHour()<13) {
			System.out.println("当前时间"+w.getHour()+"点 饿了，午饭；犯困，午休。");
		}else {
			w.SetState(new AfternoonState());
			w.WriteProgram();
		}
	}
}
class AfternoonState extends State{
	public void WriteProgram(Work w) {
		if(w.getHour()<17) {
			System.out.println("当前时间"+w.getHour()+"点 下午状态不错，继续努力");
		}else {
			w.SetState(new EveningState());
			w.WriteProgram();
		}
	}
}
class EveningState extends State{
	public void WriteProgram(Work w) {
		if(w.isFinish()) {
			w.SetState(new RestState());
			w.WriteProgram();
		}
		else{
			if(w.getHour()<21) {
				System.out.println("当前时间"+w.getHour()+"点 加班哦，疲惫至极");
		}else {
			w.SetState(new SleepingState());
			w.WriteProgram();
		}
	}
	}
}
class SleepingState extends State{
		public void WriteProgram(Work w) {
			
		System.out.println("当前时间"+w.getHour()+"点 不行了，睡着了。");
			
		}
}	
class RestState extends State{
	public void WriteProgram(Work w) {
		
	System.out.println("当前时间"+w.getHour()+"点 下班回家了");
		
	}
}	
public  class Main{
	public static void main(String[] args){
	Work emergencyProjects=new Work();
	emergencyProjects.setHour(9);
	emergencyProjects.WriteProgram();
	emergencyProjects.setHour(10);
	emergencyProjects.WriteProgram();
	emergencyProjects.setHour(12);
	emergencyProjects.WriteProgram();
	emergencyProjects.setHour(13);
	emergencyProjects.WriteProgram();
	emergencyProjects.setHour(14);
	emergencyProjects.WriteProgram();
	emergencyProjects.setHour(17);
	emergencyProjects.WriteProgram();
	
	emergencyProjects.setFinish(false);
	emergencyProjects.WriteProgram();
	emergencyProjects.setHour(19);
	emergencyProjects.WriteProgram();
	emergencyProjects.setHour(22);
	emergencyProjects.WriteProgram();
	}
}

结果为：
当前时间9.0点 上午工作，精神百倍
当前时间10.0点 上午工作，精神百倍
当前时间12.0点 饿了，午饭；犯困，午休。
当前时间13.0点 下午状态不错，继续努力
当前时间14.0点 下午状态不错，继续努力
当前时间17.0点 加班哦，疲惫至极
当前时间17.0点 加班哦，疲惫至极
当前时间19.0点 加班哦，疲惫至极
当前时间22.0点 不行了，睡着了。 

状态模式(State ) :当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了它的类。
状态模式主要解决的是当控制一个对象状态转接的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的逻拜简化。

abstract class State{
	public abstract void Handle(Context context);
}
class ConcreteStateA extends State{

	@Override
	public void Handle(Context context) {
		// TODO Auto-generated method stub
		context.setState(new ConcreteStateB());
	}
	
}
class ConcreteStateB extends State{

	@Override
	public void Handle(Context context) {
		// TODO Auto-generated method stub
		context.setState(new ConcreteStateA());
	}
	
}
class Context{
	private State state;
	public Context(State state) {
		this.state=state;
	}
	public State getState() {
		return state;
	}
	public void setState(State state) {
		this.state = state;
		System.out.println("当前状态："+state.toString());
	}
	public void Request() {
		state.Handle(this);
	}
	
}

public  class Main{
	public static void main(String[] args){
	Context c=new Context(new ConcreteStateA());
	c.Request();
	c.Request();
	c.Request();
	c.Request();
	}
}

 结果为：
当前状态：fx.ConcreteStateB@106d69c
当前状态：fx.ConcreteStateA@52e922
当前状态：fx.ConcreteStateB@25154f
当前状态：fx.ConcreteStateA@10dea4e

优点：
1、将与特定状态相关的行为局部化，并旦将不同状态的行为分割开来。
2、消除庞大的条件分支语句，把各种状态转移逻辑分布到State的子类之间，减少了相互间的依赖。
3、显式进行状态转换：为不同的状态引入独立的对象，使得状态的转接变得更加明确。而且状态对象可以保证上下文不会发生内部状态不一致的状况，因为上下文中只有一个变量来记录状态对象，只需为这一个变量赋值就可以了。
缺点：
State模式的问题主要是逻辑分散化，状态逻辑分布到了很多的State的子类中，很难看到整个的状态逻辑图，这也带来了代码的维护问题。

什么时候使用状态模式？
1、当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变行为时，就可以考虑使用状态模式。
2、另外如果业务需求某项业务有多个状态，通常都是一些枚举常量，状态的变化都是依靠大量的多分支判断语句来实现，此时应该考虑每一种业务状态定义为一个State的子类。这样这些对象就可以不依赖于其他对象而独立变化了，如果需要更改需求，增加或减少业务状态或改变状态流程，都不困难了。