设计模式之状态模式（下）

3）共享状态

1.概述

在某些情况下，多个环境对象可能需要共享同一个状态，如果希望在系统中实现多个环境对象共享一个或多个状态对象，那么需要将这些状态对象定义为环境类的静态成员对象。

2.案例

背景：要求两个开关对象要么都处于开的状态，要么都处于关的状态，在使用时它们的状态必须保持一致，开关可以由开转换到关，也可以由关转换到开。

3.结构图

4.代码实现

开关类Switch

复制代码

public class Switch {
  //定义三个静态的状态对象
	private static State state,onState,offState; 
	private String name;
	
	public Switch(String name) {
		this.name = name;
		onState = new OnState();
		offState = new OffState();
		this.state = onState;
	}
 
	public void setState(State state) {
		this.state = state;
	}
 
	public static State getState(String type) {
		if (type.equalsIgnoreCase("on")) {
			return onState;
		}else {
			return offState;
		}
	}
		
  //打开开关
	public void on() {
		System.out.print(name);
		state.on(this);
	}
	
  //关闭开关
	public void off() {
		System.out.print(name);
		state.off(this);
	}
}

抽象状态类

复制代码

abstract class State {
	public abstract void on(Switch s);
	public abstract void off(Switch s);
}

具体状态类

复制代码

//打开状态
public class OnState extends State {
	public void on(Switch s) {
		System.out.println("已经打开！");
	}
	
	public void off(Switch s) {
		System.out.println("关闭！");
		s.setState(Switch.getState("off"));
	}
}
 
//关闭状态
public class OffState extends State {
	public void on(Switch s) {
		System.out.println("打开！");
		s.setState(Switch.getState("on"));
	}
	
	public void off(Switch s) {
		System.out.println("已经关闭！");
	}
}

客户端类

复制代码

public class Client {
	public static void main(String[] args) {
	  // 开关1 和 开关2 共享了开、关的状态
		Switch s1,s2;
		s1=new Switch("开关1");
		s2=new Switch("开关2");
		
		s1.on();
		s2.on();
		s1.off();
		s2.off();
		s2.on();
		s1.on();	
	}
}

4）使用环境类实现状态转换

1.概述

由环境类Context作为一个状态管理器实现状态之间的转换。

2.优点

对于客户端来说，无须关心状态类，可以为环境类设置默认的状态类，而将状态的转换工作交给具体状态类或环境类来完成，具体的转换细节对于客户端而言是透明的。

3.缺点

增加新的具体状态类可能需要修改其他具体状态类或者环境类的源代码，否则系统无法转换到新增状态。

4.结构图

5.代码实现

复制代码

//屏幕类
public class Screen {
  //枚举所有的状态，currentState表示当前状态
	private State currentState, normalState, largerState, largestState;
 
	public Screen() {
    	this.normalState = new NormalState(); //创建正常状态对象
    	this.largerState = new LargerState(); //创建二倍放大状态对象
    	this.largestState = new LargestState(); //创建四倍放大状态对象
    	this.currentState = normalState; //设置初始状态
    	this.currentState.display();
	}
	
	public void setState(State state) {
		this.currentState = state;
	}
	
    //单击事件处理方法，封转了对状态类中业务方法的调用和状态的转换
	public void onClick() {
    	if (this.currentState == normalState) {
    		this.setState(largerState);
    		this.currentState.display();
    	}else if (this.currentState == largerState) {
    		this.setState(largestState);
    		this.currentState.display();
    	}
    	else if (this.currentState == largestState) {
    		this.setState(normalState);
    		this.currentState.display();
    	}
	}
}
 
//抽象状态类
abstract class State {
	public abstract void display();
}
 
//正常状态类
public class NormalState extends State{
	public void display() {
		System.out.println("正常大小！");
	}
}
 
//二倍状态类
public class LargerState extends State{
	public void display() {
		System.out.println("二倍大小！");
	}
}
 
//四倍状态类
public class LargestState extends State{
	public void display() {
		System.out.println("四倍大小！");
	}
}

客户端类

复制代码

public class Client {
	public static void main(String[] args) {
		Screen screen = new Screen();
		screen.onClick();
		screen.onClick();
		screen.onClick();
	}
}

注意：

所有的状态转换操作都由环境类Screen实现，此时，环境类充当了状态管理器角色。

如果需要增加新的状态，例如"八倍状态类"，需要修改环境类，这在一定程度上违背了"开闭原则"，但对其他状态类没有任何影响。

5）总结

1.优点

封装了状态的转换规则，在状态模式中可以将状态的转换代码封装在环境类或者具体状态类中，可以对状态转换代码进行集中管理，而不是分散在一个个业务方法中。
将所有与某个状态有关的行为放到一个类中，只需要注入一个不同的状态对象即可使环境对象拥有不同的行为。
允许状态转换逻辑与状态对象合成一体，而不是提供一个巨大的条件语句块，状态模式可以避免使用庞大的条件语句来将业务方法和状态转换代码交织在一起。
可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。

2.缺点

状态模式的使用必然会增加系统中类和对象的个数，导致系统运行开销增大。
状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱，增加系统设计的难度。
状态模式对"开闭原则"的支持并不好，增加新的状态类需要修改那些负责状态转换的源代码，否则无法转换到新增状态；而且修改某个状态类的行为也需修改对应类的源代码。

3.适用场景

对象的行为依赖于它的状态（如某些属性值），状态的改变将导致行为的变化。
在代码中包含大量与对象状态有关的条件语句，这些条件语句的出现，会导致代码的可维护性和灵活性变差，不能方便地增加和删除状态，并且导致客户类与类库之间的耦合增强。