设计模式（十九）State模式

　　在面向对象编程中，是用类表示对象的。也就是说，程序的设计者需要考虑用类来表示什么东西。类对应的东西可能存在于真实世界中，也可能不存在于真实世界中。对于后者，可能有人看到代码后会感到吃惊：这些东西居然也可以是类啊。　　

　　在State模式中，用类来表示状态。用类来表示状态后，就能通过切换类方便地改变对象的状态，当需要增加新的状态时，如何修改代码这个问题也会很明确。

　　示例程序的类图如上图所示。

 package bigjunoba.bjtu.state;

 public interface Context {
     public abstract void setClock(int hour);                // 设置时间
     public abstract void changeState(State state);          // 改变状态
     public abstract void callSecurityCenter(String msg);    // 联系警报中心
     public abstract void recordLog(String msg);             // 在警报中心留下记录
 }

　　Context接口是负责管理状态和联系警报中心的接口。

package bigjunoba.bjtu.state;

public interface State {
    public abstract void doClock(Context context, int hour);    // 设置时间
    public abstract void doUse(Context context);                // 使用金库
    public abstract void doAlarm(Context context);              // 按下警铃
    public abstract void doPhone(Context context);              // 正常通话
}

　　State接口是表示金库状态的接口。这些方法接收的参数Context是管理状态的接口。

 package bigjunoba.bjtu.state;

 public class DayState implements State {
     private static DayState singleton = new DayState();

     private DayState() { // 构造函数的可见性是private
     }

     public static State getInstance() { // 获取唯一实例
         return singleton;
     }

     public void doClock(Context context, int hour) { // 设置时间
         if (hour < 9 || 17 <= hour) {
             context.changeState(NightState.getInstance());
         }
     }

     public void doUse(Context context) { // 使用金库
         context.recordLog("使用金库(白天)");
     }

     public void doAlarm(Context context) { // 按下警铃
         context.callSecurityCenter("按下警铃(白天)");
     }

     public void doPhone(Context context) { // 正常通话
         context.callSecurityCenter("正常通话(白天)");
     }

     public String toString() { // 显示表示类的文字
         return "[白天]";
     }
 }

　　DayState类表示白天的状态。对于每个表示状态的类，都只生成一个实例，因为如果每次发生状态改变时都生成一个实例的话，太浪费内存和时间了。因此，使用了Singleton模式。doClock方法是用于设置时间的方法。如果接收到的参数表示晚上的时间，就会切换到夜间状态，即发生状态变化，用程序表现就是获取夜晚状态的类的实例，然后通过changeState方法实现。

　　

 package bigjunoba.bjtu.state;

 import java.awt.Frame;
 import java.awt.Label;
 import java.awt.Color;
 import java.awt.Button;
 import java.awt.TextField;
 import java.awt.TextArea;
 import java.awt.Panel;
 import java.awt.BorderLayout;
 import java.awt.event.ActionListener;

 import javax.swing.JButton;

 import java.awt.event.ActionEvent;

 public class SafeFrame extends Frame implements ActionListener, Context {
     private TextField textClock = new TextField(60); // 显示当前时间
     private TextArea textScreen = new TextArea(10, 60); // 显示警报中心的记录
     private JButton buttonUse = new JButton("使用金库"); // 金库使用按钮
     private JButton buttonAlarm = new JButton("按下警铃"); // 按下警铃按钮
     private JButton buttonPhone = new JButton("正常通话"); // 正常通话按钮
     private JButton buttonExit = new JButton("结束"); // 结束按钮

     private State state = DayState.getInstance(); // 当前的状态

     // 构造函数
     public SafeFrame(String title) {
         super(title);
         setBackground(Color.lightGray);
         setLayout(new BorderLayout());
         // 配置textClock
         add(textClock, BorderLayout.NORTH);
         textClock.setEditable(false);
         // 配置textScreen
         add(textScreen, BorderLayout.CENTER);
         textScreen.setEditable(false);
         // 为界面添加按钮
         Panel panel = new Panel();
         panel.add(buttonUse);
         panel.add(buttonAlarm);
         panel.add(buttonPhone);
         panel.add(buttonExit);
         // 配置界面
         add(panel, BorderLayout.SOUTH);
         // 显示
         pack();
         show();
         // 设置监听器
         buttonUse.addActionListener(this);
         buttonAlarm.addActionListener(this);
         buttonPhone.addActionListener(this);
         buttonExit.addActionListener(this);
     }

     // 按钮被按下后该方法会被调用
     public void actionPerformed(ActionEvent e) {
         System.out.println(e.toString());
         if (e.getSource() == buttonUse) { // 金库使用按钮
             state.doUse(this);
         } else if (e.getSource() == buttonAlarm) { // 按下警铃按钮
             state.doAlarm(this);
         } else if (e.getSource() == buttonPhone) { // 正常通话按钮
             state.doPhone(this);
         } else if (e.getSource() == buttonExit) { // 结束按钮
             System.exit(0);
         } else {
             System.out.println("?");
         }
     }

     // 设置时间
     public void setClock(int hour) {
         String clockstring = "现在时间是";
         if (hour < 10) {
             clockstring += "0" + hour + ":00";
         } else {
             clockstring += hour + ":00";
         }
         System.out.println(clockstring);
         textClock.setText(clockstring);
         state.doClock(this, hour);
     }

     // 改变状态
     public void changeState(State state) {
         System.out.println("从" + this.state + "状態变为了" + state + "状态。");
         this.state = state;
     }

     // 联系警报中心
     public void callSecurityCenter(String msg) {
         textScreen.append("call! " + msg + "\n");
     }

     // 在警报中心留下记录
     public void recordLog(String msg) {
         textScreen.append("record ... " + msg + "\n");
     }
 }

　　SafeFrame类是使用GUI实现警报系统界面的类。这里要注意的是，没有先去判断时间是白天还是晚上，也没有判断金库的状态，如果按下按钮就立即执行对应的方法。changeState方法会调用白天状态和晚上状态两个类，当状态发生迁移时，实际改变状态的是this.state = state;这句话就是给代表状态的字段赋予表示当前状态的类的实例，就相当于进行了状态迁移。

　　上图为状态改变前后doUse方法的调用流程。一开始调用DayState类的doUse方法，当changeState后，变为了调用NightState类的doUse方法。

 package bigjunoba.bjtu.state;

 public class Main {
     public static void main(String[] args) {
         SafeFrame frame = new SafeFrame("State Sample");
         while (true) {
             for (int hour = 0; hour < 24; hour++) {
                 frame.setClock(hour); // 设置时间
                 try {
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                 }
             }
         }
     }
 }

　　Main类作为测试类，很容易理解，就不做解释了。

　　实际效果图如上。

　　State模式的类图如上图。

　　State模式扩展知识：

　　1.分而治之。在大规模的复杂处理时，不能用一般的方法解决时，会先将多个问题分解为多个小问题来解决。

　　2.在State接口中声明的所有方法都是“依赖于状态的处理”，都是“状态不同处理也不同”。实现起来总结为：1.定义接口，声明抽象方法。 2.定义多个类，实现具体方法。

　　3.实例的多面性