设计模式（二十）状态

一、定义

允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类，状态模式又称为状态对象，它是一种对象行为模式。
二、描述

状态模式是一种较为复杂的设计模式，用于解决系统中复杂对象的状态转换以及不同状态下行为的封装问题，包含以下三个角色：

1、Context（环境类）：环境类又称为上下文类，它是拥有多种状态的对象。由于环境类的状态存在多样性，且在不同状态下对象的行为有所不同，所以将状态独立出去形成单独的状态类。在环境类中维护一个抽象状态类State的实例，这个实例定义当前状态，在具体实现时，它是一个State子类的对象。
2、State（抽象状态类）：它用于定义一个接口以封装与环境类的一个特定状态相关的行为，在抽象状态类中声明了各种不同状态对应的方法，而在其子类中实现了这些方法，由于不同状态下对象的行为可能不同，因此在不同子类中方法的实现可能存在不同，相同的方法可以写在抽象状态类中。
3、ConcreteState（具体状态类）：它是抽象状态类的子类，每一个具体状态类实现一个与环境类的一个状态相关的行为，对应环境类的一个具体状态，不同的具体状态类其行为有所不同。
三、例子

X公司公司要为一银行开发一套信用卡业务系统，银行账户（Account）是该系统的核心类之一，通过分析，系统中账户存在3种状态，根据余额的不同，以上3种状态可发生相互转换，具体说明如下：
（1）如果账户中余额大于等于0，则账户的状态为正常状态(Normal State），此时用户既可以向该账户存款也可以从该账户取款。
（2）如果账户中余额小于0，并且大于一2000，则账户的状态为透支状态（Overdraft State)，此时用户既可以向该账户存款也可以从该账户取款，但需要按天计算利息。
（3）如果账户中余额等于-2000，那么账户的状态为受限状态(Restricted State)，此时用户只能向该账户存款，不能再从中取款，同时也将按天计算利息。

Account：银行账户，充当环境类

1. public class Account
2. {
3.     private AccountState state;  //维持一个对抽象状态对象的引用
4.     private string owner;        //开户名
5.     private double balance = 0;  //账户余额
6.     public Account(string owner, double init)
7.     {
8.         this.owner = owner;
9.         this.balance = init;
10.         this.state = new NormalState(this);
11.         Console.WriteLine("{0}开户,初始金额为{1}", this.owner, init);
12.         Console.WriteLine("------------------------------------");
13.     }
14.     //设置初始状态
15.     public double Balance
16.     {
17.         get { return balance; }
18.         set { balance = value; }
19.     }
20.     public void SetState(AccountState state)
21.     {
22.         this.state = state;
23.     }
24.     public void Deposit(double amount)
25.     {
26.         Console.WriteLine("{0}存款{1}", this.owner, amount);
27.         state.Deposit(amount);// 调用状态对象的Deposit()方法
28.         Console.WriteLine("现在余额为{0}", this.Balance);
29.         Console.WriteLine("现在账户状态为{0}", this.state.GetType().ToString());
30.         Console.WriteLine("------------------------------------");
31.     }
32.     public void Withdraw(double amount)
33.     {
34.         Console.WriteLine("{0}取款{1}", this.owner, amount);
35.         state.Withdraw(amount); //调用状态对象的Withdraw()方法
36.         Console.WriteLine("现在余额为{0}", this.Balance);
37.         Console.WriteLine("现在账户状态为{0}", this.state.GetType().ToString());
38.         Console.WriteLine("------------------------------------");
39.     }
40.     public void ComputeInterest()
41.     {
42.         state.ComputeInterest();   //调用状态对象的computeInterest方法
43.     }
44. }

复制代码

AccountState：账户状态类，充当抽象状态类

1. public abstract class AccountState
2. {
3.     private Account acc;
4.     public Account Acc
5.     {
6.         get { return acc; }
7.         set { acc = value; }
8.     }
9.     public abstract void Deposit(double amount);
10.     public abstract void Withdraw(double amount);
11.     public abstract void ComputeInterest();
12.     public abstract void StateCheck();
13. }

复制代码

NormalState、OverdraftState、RestrictedState：正常状态、透支状态、受限状态，充当具体状态类

1. public class NormalState : AccountState
2. {
3.     public NormalState(Account acc)
4.     {
5.         this.Acc = acc;
6.     }
7.     public NormalState(AccountState state)
8.     {
9.         this.Acc = state.Acc;
10.     }
12.     public override void Deposit(double amount)
13.     {
14.         Acc.Balance = Acc.Balance + amount;
15.         StateCheck();
16.     }
17.     public override void Withdraw(double amount)
18.     {
19.         Acc.Balance = Acc.Balance - amount;
20.         StateCheck();
21.     }
23.     public override void ComputeInterest()
24.     {
25.         Console.WriteLine("正常状态，无需支付利息！");
26.     }
28.     public override void StateCheck()
29.     {
30.         if (Acc.Balance > -2000 && Acc.Balance <= 0)
31.         {
32.             Acc.SetState(new OverdraftState(this));
33.         }
34.         else if (Acc.Balance == -2000)
35.         {
36.             Acc.SetState(new RestrictedState(this));
37.         }
38.         else if (Acc.Balance < -2000)
39.         {
40.             Console.WriteLine("操作受限！");
41.         }
42.     }
43. }
45. public class OverdraftState : AccountState
46. {
47.     public OverdraftState(AccountState state)
48.     {
49.         this.Acc = state.Acc;
50.     }
51.     public override void Deposit(double amount)
52.     {
53.         Acc.Balance = Acc.Balance + amount;
54.         StateCheck();
55.     }
56.     public override void Withdraw(double amount)
57.     {
58.         Acc.Balance = Acc.Balance - amount;
59.         StateCheck();
60.     }
62.     public override void ComputeInterest()
63.     {
64.         Console.WriteLine("计算利息！");
65.     }
67.     public override void StateCheck()
68.     {
69.         if (Acc.Balance > 0)
70.         {
71.             Acc.SetState(new NormalState(this));
72.         }
73.         else if (Acc.Balance == -2000)
74.         {
75.             Acc.SetState(new OverdraftState(this));
76.         }
77.         else if (Acc.Balance < -2000)
78.         {
79.             Console.WriteLine("操作受限！");
80.         }
81.     }
82. }
84. public class RestrictedState : AccountState
85. {
86.     public RestrictedState(AccountState state)
87.     {
88.         this.Acc = state.Acc;
89.     }
90.     public override void Deposit(double amount)
91.     {
92.         Acc.Balance = Acc.Balance + amount;
93.         StateCheck();
94.     }
95.     public override void Withdraw(double amount)
96.     {
97.         Console.WriteLine("账户受限，取款失败！");
98.     }
100.     public override void ComputeInterest()
101.     {
102.         Console.WriteLine("计算利息！");
103.     }
105.     public override void StateCheck()
106.     {
107.         if (Acc.Balance > 0)
108.         {
109.             Acc.SetState(new NormalState(this));
110.         }
111.         else if (Acc.Balance > -2000)
112.         {
113.             Acc.SetState(new OverdraftState(this));
114.         }
115.     }
116. }

复制代码

Program：测试代码

1. Account acc = new Account("段誉", 0.0);
2. acc.Deposit(1000);
3. acc.Withdraw(2000);
4. acc.Deposit(3000);
5. acc.Withdraw(4000);
6. acc.Withdraw(1000);
7. acc.ComputeInterest();
8. Console.ReadLine();

复制代码

四、总结

1、优点

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

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

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！