设计模式一状态模式

状态模式

   状态模式把所研究的对象的行为包装在不同的状态对象里，

   每一个状态对象都属于一个抽象状态类的一个子类。

   状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。

状态（stateing）模式的定义：
      类似策略模式
      对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，
      允许状态对象在其内部状态发生改变时改变其行为。

环境（Context）角色：
　　也称为上下文，它定义了客户感兴趣的接口，维护一个当前状态，
　　并将与状态相关的操作委托给当前状态对象来处理。
抽象状态（stateing）角色：
　　定义一个接口，用以封装环境对象中的特定状态所对应的行为。
具体状态（Concrete stateing）角色：
　　实现抽象状态所对应的行为。

  1 public class stateing {
  2     public static void main(String[] args) {
  3         context context = new context();
  4         context.setSta(context.getClose());
  5         context.close();
  6         context.open();
  7         context.run();
  8         context.close();
  9     }
 10 }
 11 
 12 //环境角色
 13 class context {
 14     //状态
 15     private state sta;
 16     //行为
 17     private opening open;
 18     private closeing close;
 19     private runing run;
 20 
 21     public void setSta(state sta) {
 22         this.sta = sta;
 23         //将状态类添加环境变量，便于在状态类改变环境变量
 24         sta.setCon(this);
 25     }
 26 
 27     public context() {
 28         this.open = new opening();
 29         this.close = new closeing();
 30         this.run = new runing();
 31     }
 32 
 33     public void open() {
 34         sta.open();
 35     }
 36 
 37     public void close() {
 38         sta.close();
 39     }
 40 
 41     public void run() {
 42         sta.run();
 43     }
 44 
 45     public state getSta() {
 46         return sta;
 47     }
 48 
 49     public opening getOpen() {
 50         return open;
 51     }
 52 
 53     public void setOpen(opening open) {
 54         this.open = open;
 55     }
 56 
 57     public closeing getClose() {
 58         return close;
 59     }
 60 
 61     public void setClose(closeing close) {
 62         this.close = close;
 63     }
 64 
 65     public runing getRun() {
 66         return run;
 67     }
 68 
 69     public void setRun(runing run) {
 70         this.run = run;
 71     }
 72 
 73 }
 74 
 75 //状态
 76 abstract class state {
 77     //用于改变状态
 78     private context con;
 79 
 80     public context getCon() {
 81         return con;
 82     }
 83 
 84     public void setCon(context con) {
 85         this.con = con;
 86     }
 87 
 88     public abstract void open();
 89 
 90     public abstract void close();
 91 
 92     public abstract void run();
 93 }
 94 
 95 //具体行为
 96 class opening extends state {
 97 
 98     @Override
 99     public void open() {
100         System.out.println("错误状态");
101     }
102 
103     @Override
104     public void close() {
105         System.out.println("关闭");
106         context con = super.getCon();
107         con.setSta(con.getClose());
108     }
109 
110     @Override
111     public void run() {
112         System.out.println("错误状态");
113     }
114 }
115 
116 class closeing extends state {
117 
118     @Override
119     public void open() {
120         System.out.println("开启");
121         context con = super.getCon();
122         con.setSta(con.getOpen());
123     }
124 
125     @Override
126     public void close() {
127         System.out.println("错误状态");
128     }
129 
130     @Override
131     public void run() {
132         System.out.println("运行");
133         context con = super.getCon();
134         con.setSta(con.getRun());
135     }
136 }
137 
138 class runing extends state {
139 
140     @Override
141     public void open() {
142         System.out.println("错误状态");
143     }
144 
145     @Override
146     public void close() {
147         System.out.println("错误状态");
148     }
149 
150     @Override
151     public void run() {
152         System.out.println("正在runing");
153     }
154 }