处理对象的多种状态及其相互转换——状态模式（四）

4 共享状态

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

下面通过一个简单实例来说明如何实现共享状态：

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

可以使用状态模式来实现开关的设计，其结构如图5所示：

处理对象的多种状态及其相互转换——状态模式（四） - 图1

图5 开关及其状态设计结构图

开关类Switch代码如下所示：

  1. class Switch {  
  2.     private static State state,onState,offState; //定义三个静态的状态对象  
  3.     private String name;  
  5.     public Switch(String name) {  
  6.         this.name = name;  
  7.         onState = new OnState();  
  8.         offState = new OffState();  
  9.         this.state = onState;  
  10.     }  
  12.     public void setState(State state) {  
  13.         this.state = state;  
  14.     }  
  16.     public static State getState(String type) {  
  17.         if (type.equalsIgnoreCase("on")) {  
  18.             return onState;  
  19.         }  
  20.         else {  
  21.             return offState;  
  22.         }  
  23.     }  
  25.     //打开开关  
  26.     public void on() {  
  27.         System.out.print(name);  
  28.         state.on(this);  
  29.     }  
  31. //关闭开关  
  32.     public void off() {  
  33.         System.out.print(name);  
  34.         state.off(this);  
  35.     }  
  36. }

抽象状态类如下代码所示：

  1. abstract class State {  
  2.     public abstract void on(Switch s);  
  3.     public abstract void off(Switch s);  
  4. }

两个具体状态类如下代码所示：

  1. //打开状态  
  2. class OnState extends State {  
  3.     public void on(Switch s) {  
  4.         System.out.println("已经打开！");  
  5.     }  
  7.     public void off(Switch s) {  
  8.         System.out.println("关闭！");  
  9.         s.setState(Switch.getState("off"));  
  10.     }  
  11. }  
  13. //关闭状态  
  14. class OffState extends State {  
  15.     public void on(Switch s) {  
  16.         System.out.println("打开！");  
  17.         s.setState(Switch.getState("on"));  
  18.     }  
  20.     public void off(Switch s) {  
  21.         System.out.println("已经关闭！");  
  22.     }  
  23. }

编写如下客户端代码进行测试：

  1. class Client {  
  2.     public static void main(String args[]) {  
  3.         Switch s1,s2;  
  4.         s1=new Switch("开关1");  
  5.         s2=new Switch("开关2");  
  7.         s1.on();  
  8.         s2.on();  
  9.         s1.off();  
  10.         s2.off();  
  11.         s2.on();  
  12.         s1.on();      
  13.     }  
  14. }

输出结果如下：

  1. 开关1已经打开！
  2. 开关2已经打开！
  3. 开关1关闭！
  4. 开关2已经关闭！
  5. 开关2打开！
  6. 开关1已经打开！

从输出结果可以得知两个开关共享相同的状态，如果第一个开关关闭，则第二个开关也将关闭，再次关闭时将输出“已经关闭”；打开时也将得到类似结果。