设计模式之状态模式

内容抄自《设计模式》清华大学出版社，2011

模式动机：   在软件系统中大量存在状态，如考虑某酒店订房系统，可以将酒店房间设计为一个类，酒店房间对象将
会存在已预订，空闲、已入住等状态，这些状态之间可以相互转换，对于客户而言，这些状态的转换细节无须知道。

模式定义：   允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。

结构分析：

包含角色：
1.Context（环境类）
2.State（抽象状态类）
3.ConcreteState（具体状态类）

public class Context{
    private State state;
    public Context(State state){
        this.state = state;
    }
    public void handler(){
        this.state.doHandler(this);
    }
}

public interface State{
    public void doHandler(Context cxt);
}

public class ConcreteState implements State{
    @Override
    public void doHandler(Context cxt){
        if(xxx){
            cxt.setState(new xxx);
        }
        else{
            cxt.setState(new xxx);
        }
    }
}

优点：
1.封装了状态转化规则，无须使用条件语句判断状态和转变状态，提供了代码的可维护性。
2.枚举可能的状态
3.将所有的与某个状态有关的行为放到环境类中。
4.可以让多个环境共享一个状态对象

缺点：
1.会增加系统类和对象的个数
2.使系统复杂
3.开闭原则 不是很好的支持

适用环境：
1.对象依赖状态，并且根据状态的改变从而改变它的相关行为
2.代码中包含大量与对象状态有关的条件语句

无状态：

public class UselessStatus {

	private static final String STATUS_DRAFT = "草稿";
	private static final String STATUS_ACTIVE = "生效";
	private static final String STATUS_CANCLE = "取消";
	
	//订单类
	static class Order{
		public int id;
		public String status;
		public Order(int id, String status) {
			this.id = id;
			this.status = status;
		}
	}
	
	public static Order init(int id){
		return new Order(id,STATUS_DRAFT);
	}
	
	public static void active(Order order){
		if(order.status==STATUS_DRAFT){
			System.out.println("生效成功");
			order.status=STATUS_ACTIVE;
		}
		else{
			 System.out.println("当前状态为:"+order.status+"，不支持生效");
		}
	}
	
	public static void cancle(Order order){
		if(order.status==STATUS_DRAFT||order.status==STATUS_ACTIVE){
			System.out.println("取消成功");
			order.status=STATUS_CANCLE;
		}
		else{
			 System.out.println("当前状态为:"+order.status+"，不支持取消");
		}
	}
	
	public static void main(String[] args) {
		Order order = init(1);
		cancle(order);
		active(order);
	}
	
}

有状态:

public class UseStatus {

	//订单类
	static class Order{
		public int id;
		public OrderStatus status;
		public Order(int id) {
			this.id = id;
			this.status = new Draft();
		}
		public void active(){
			status.active(this);
		}
		public void cancle(){
			status.cancle(this);
		}
	}
	
	static interface OrderStatus{
		public void active(Order order);
		public void cancle(Order order);
	}
	static class Draft implements OrderStatus{
		@Override
		public void active(Order order) {
			order.status = new Active();
			System.out.println("订单状态改变为active");
		}
		@Override
		public void cancle(Order order) {
			order.status = new Cancle();
			System.out.println("订单状态改变为cancle");
		}
	}
	static class Active implements OrderStatus{

		@Override
		public void active(Order order) {
			System.out.println("不支持的操作");
		}

		@Override
		public void cancle(Order order) {
			order.status = new Cancle();
			System.out.println("订单状态改变为cancle");
		}
			
	}
	static class Cancle implements OrderStatus{
		@Override
		public void active(Order order) {
			System.out.println("不支持的操作");
		}
		@Override
		public void cancle(Order order) {
			System.out.println("不支持的操作");
		}
	}
	
	public static void main(String[] args) {
		Order order = new Order(1);
		order.cancle();
		order.active();
		order.cancle();
	}
}