行为型设计模式之二

1.state状态

考虑代码中出现许多if ~else if~else if~~或者switch语句时，可使用。

1. /**  
2.  * State类，抽象状态类，定义一个接口以封装  
3.  * 与Context的一个特定状态相关的行为。  
4.  * @author Andy  
5.  *  
6.  */  
7. public abstract class State {  
8.       
9.     protected Account account;  
10.     protected double balance;  
11.   
12.     protected double interest;  
13.     protected double lowerLimit;  
14.     protected double upperLimit;  
15.   
16.     //-------------Properties------------------//  
17.     public Account getAccount() {  
18.         return account;  
19.     }  
20.     public void setAccount(Account account) {  
21.         this.account = account;  
22.     }  
23.       
24.     public double getBalance() {  
25.         return balance;  
26.     }  
27.     public void setBalance(double balance) {  
28.         this.balance = balance;  
29.     }  
30.     //------------------------------------------//  
31.       
32.     /**存入金额*/  
33.     public abstract void deposit(double amount);  
34.     /**支出金额*/  
35.     public abstract void withdraw(double amount);  
36.     /**利息*/  
37.     public abstract void payInterest();  
38.   
39. }  

1. /**  
2.  * 用户账户状态:RedState  
3.  * @author Andy  
4.  * ConcreteState类，具体状态，每一个子类实现一个与  
5.  * Context的一个状态相关的行为。  
6.  */  
7. public class RedState extends State {  
8.       
9.     private double serviceFee;  
10.   
11.     public RedState(State state) {  
12.         this.balance = state.getBalance();  
13.         this.account = state.getAccount();  
14.         initialize();  
15.     }  
16.   
17.      /** 模拟初始化基础数据*/  
18.     private void initialize() {  
19.         interest = 0.0;  
20.         lowerLimit = -100.0;  
21.         upperLimit = 0.0;  
22.         serviceFee = 15.00;  
23.     }  
24.   
25.     @Override  
26.     public void deposit(double amount) {  
27.           balance += amount;  
28.           stateChangeCheck();  
29.     }  
30.   
31.     @Override  
32.     public void withdraw(double amount) {  
33.           amount = amount - serviceFee;  
34.           System.out.println("No funds available for withdrawal!");  
35.     }  
36.   
37.     @Override  
38.     public void payInterest() {  
39.         // No interest is paid  
40.     }  
41.       
42.     /** 状态检测 */  
43.     private void stateChangeCheck() {  
44.         if (balance > upperLimit) {  
45.             account.setState(new SilverState(this));  
46.         }  
47.     }  
48.   
49. }  

1. /**  
2.  * 用户账户状态:SilverState  
3.  * @author Andy  
4.  * ConcreteState类，具体状态，每一个子类实现一个与  
5.  * Context的一个状态相关的行为。  
6.  */  
7. public class SilverState extends State {  
8.       
9.     public SilverState(State state){  
10.         this(state.balance,state.account);  
11.     }  
12.   
13.     public SilverState(double balance, Account account){  
14.       this.balance = balance;  
15.       this.account = account;  
16.       initialize();  
17.     }  
18.   
19.     /** 模拟初始化基础数据*/  
20.     private void initialize(){  
21.       interest = 0.0;  
22.       lowerLimit = 0.0;  
23.       upperLimit = 1000.0;  
24.     }  
25.   
26.     @Override  
27.     public void deposit(double amount) {  
28.           balance += amount;  
29.           stateChangeCheck();  
30.     }  
31.   
32.     @Override  
33.     public void withdraw(double amount) {  
34.           balance -= amount;  
35.           stateChangeCheck();  
36.     }  
37.   
38.     @Override  
39.     public void payInterest() {  
40.           balance += interest * balance;  
41.           stateChangeCheck();  
42.     }  
43.       
44.     /** 状态检测 */  
45.     private void stateChangeCheck(){  
46.       if (balance < lowerLimit){  
47.           account.setState(new RedState(this));  
48.       }  
49.       else if (balance > upperLimit){  
50.           account.setState(new GoldState(this));  
51.       }  
52.     }  
53.   
54. }  

1. /**  
2.  * 用户账户状态:GoldState  
3.  * @author Andy  
4.  * ConcreteState类，具体状态，每一个子类实现一个与  
5.  * Context的一个状态相关的行为。  
6.  */  
7. public class GoldState extends State {  
8.       
9.     public GoldState(State state){  
10.         this(state.balance, state.account);  
11.     }  
12.   
13.     public GoldState(double balance, Account account){  
14.       this.balance = balance;  
15.       this.account = account;  
16.       initialize();  
17.     }  
18.   
19.     /** 模拟初始化基础数据*/  
20.     private void initialize(){  
21.       interest = 0.05;  
22.       lowerLimit = 1000.0;  
23.       upperLimit = 10000000.0;  
24.     }  
25.   
26.     @Override  
27.     public void deposit(double amount) {  
28.          balance += amount;  
29.          stateChangeCheck();  
30.     }  
31.   
32.     @Override  
33.     public void withdraw(double amount) {  
34.           balance -= amount;  
35.           stateChangeCheck();  
36.     }  
37.   
38.     @Override  
39.     public void payInterest() {  
40.           balance += interest * balance;  
41.           stateChangeCheck();  
42.     }  
43.       
44.     /** 状态检测 */  
45.     private void stateChangeCheck() {  
46.         if (balance < 0.0) {  
47.             account.setState(new RedState(this));  
48.         } else if (balance < lowerLimit) {  
49.             account.setState(new SilverState(this));  
50.         }  
51.     }  
52.   
53. }  

1. /**  
2.  * Context类，维护一个ConcreteState子类的实例  
3.  * 这个实例定义当前的状态。  
4.  * @author Andy  
5.  *  
6.  */  
7. public class Account {  
8.       
9.     private State state;  
10.     private String owner;  
11.   
12.     public Account(String owner){  
13.       // 新开账户默认为 Silver状态  
14.       this.owner = owner;  
15.       this.state = new SilverState(0.0, this);  
16.     }  
17.   
18.     public State getState() {  
19.         return state;  
20.     }  
21.   
22.     public void setState(State state) {  
23.         this.state = state;  
24.     }  
25.   
26.     public void deposit(double amount) {  
27.         state.deposit(amount);  
28.         System.out.println(owner + " Deposited  " + amount);  
29.         System.out.println(owner + " Balance =  " + state.getBalance());  
30.         System.out.println("Status = " + state.getClass().getSimpleName());  
31.         System.out.println("==============================================");  
32.     }  
33.    
34.     public void withdraw(double amount){  
35.         state.withdraw(amount);  
36.         System.out.println(owner + " Withdrew  " + amount);  
37.         System.out.println(owner + " Balance =  " + state.getBalance());  
38.         System.out.println("Status = " + state.getClass().getSimpleName());  
39.         System.out.println("==============================================");  
40.     }  
41.    
42.     public void payInterest(){  
43.         state.payInterest();  
44.         System.out.println(owner + " Interest Paid  ");  
45.         System.out.println(owner + " Balance =  " + state.getBalance());  
46.         System.out.println("Status = " + state.getClass().getSimpleName());  
47.         System.out.println("==============================================");  
48.     }  
49.   
50. }  

1. public class StateClient {  
2.       
3.     public static void main(String[] args) {  
4.           // 新开一个银行账户  
5.           Account account = new Account("Andy.Chen");  
6.   
7.           // 存取款等系列操作  
8.           account.deposit(500.0);  
9.           account.deposit(300.0);  
10.           account.deposit(550.0);  
11.           account.payInterest();  
12.           account.withdraw(2000.00);  
13.           account.withdraw(1100.00);  
14.     }  
15.   
16. }  

2.strategy策略

考虑一个功能的多种算法实现，如排序。

#ifndef _STRATEGY_H_
 2 #define _STRATEGY_H_
 3 
 4 class Strategy
 5 {
 6 public:
 7     ~Strategy();
 8     virtual void AlgrithmInterface()=0;
 9 protected:
10     Strategy();
11 private:
12 };
13 
14 class ConcreteStrategyA : public Strategy
15 {
16 public:
17     ConcreteStrategyA();
18     ~ConcreteStrategyA();
19     virtual void AlgrithmInterface();
20 protected:
21 private:
22 };
23 
24 class ConcreteStrategyB : public Strategy
25 {
26 public:
27     ConcreteStrategyB();
28     ~ConcreteStrategyB();
29     virtual void AlgrithmInterface();
30 protected:
31 private:
32 };
33 
34 /*这个类是Strategy模式的关键，
35   也是Strategy模式和Template模式的根本区别所在。
36   *Strategy通过“组合”（委托）方式实现算法（实现）的异构，
37   而Template模式则采取的是继承的方式
38   这两个模式的区别也是继承和组合两种实现接口重用的方式的区别
39 */
40 class Context
41 {
42 public:
43     Context(Strategy*);
44     ~Context();
45     void DoAction();
46 private:
47     Strategy* _strategy;
48 };
49 #endif

 1 #include "Strategy.h"
 2 #include "iostream"
 3 
 4 using namespace std;
 5 
 6 Strategy::Strategy()
 7 {}
 8 
 9 Strategy::~Strategy()
10 {}
11 
12 ConcreteStrategyA::ConcreteStrategyA()
13 {}
14 
15 ConcreteStrategyA::~ConcreteStrategyA()
16 {}
17 
18 void ConcreteStrategyA::AlgrithmInterface()
19 {
20     cout << "ConcreteStrategyA::AlgrithmInterface" << endl;
21 }
22 
23 ConcreteStrategyB::ConcreteStrategyB()
24 {}
25 
26 ConcreteStrategyB::~ConcreteStrategyB()
27 {}
28 
29 void ConcreteStrategyB::AlgrithmInterface()
30 {
31     cout << "ConcreteStrategyB::AlgrithmInterface" << endl;
32 }
33 
34 Context::Context(Strategy* strategy)
35 {
36     this->_strategy = strategy;
37 }
38 
39 Context::~Context()
40 {
41     delete this->_strategy;
42 }
43 
44 void Context::DoAction()
45 {
46     this->_strategy->AlgrithmInterface();
47 }

 1 #include "Strategy.h"
 2 
 3 int main()
 4 {
 5     /*
 6     Strategy模式和Template模式实际是实现一个抽象接口的两种方式：继承和组合之间的区别。
 7     要实现一个抽象接口，继承是一种方式：我们将抽象接口声明在基类中，将具体的实现放在具体子类中。
 8     组合（委托）是另外一种方式：我们将接口的实现放在被组合对象中，将抽象接口放在组合类中。
 9     这两种方式各有优缺点
10     */
11     //策略A与B可替换
12     Strategy* pStr = new ConcreteStrategyA();
13     Context* pcon = new Context(pStr);
14     pcon->DoAction();
15 
16     pStr = new ConcreteStrategyB();
17     pcon = new Context(pStr);
18     pcon->DoAction();
19 
20     return 0;
21 }

3.template   method模板方法

  使用继承，达到多种实现

 1 #ifndef _TEMPLATEMETHOD_H_
 2 #define _TEMPLATEMETHOD_H_
 3 
 4 //抽象模板，并定义了一个模板方法。
 5 class AbstractClass
 6 {
 7 public:
 8     ~AbstractClass();
 9     //具体的模板方法，给出了逻辑的骨架，而逻辑的组成是一些相应的抽象操作，它们都推迟到子类中实现
10     void TemplateMethod();
11     //一些抽象行为，放到子类中去实现
12     virtual void PrimitiveOperation1()=0;
13     virtual void PrimitiveOperation2()=0;
14 protected:
15     AbstractClass();
16 private:
17 };
18 
19 //实现基类所定义的抽象方法
20 class ConcreteClassA : public AbstractClass
21 {
22 public:
23     ConcreteClassA();
24     ~ConcreteClassA();
25     //实现基类定义的抽象行为
26     virtual void PrimitiveOperation1();
27     virtual void PrimitiveOperation2();
28 private:
29 };
30 
31 //实现基类所定义的抽象方法
32 class ConcreteClassB : public AbstractClass
33 {
34 public:
35     ConcreteClassB();
36     ~ConcreteClassB();
37     //实现基类定义的抽象行为
38     virtual void PrimitiveOperation1();
39     virtual void PrimitiveOperation2();
40 private:
41 };
42 #endif

1 #include "TemplateMethod.h"
 2 #include <iostream>
 3 
 4 using namespace std;
 5 
 6 AbstractClass::AbstractClass()
 7 {}
 8 
 9 AbstractClass::~AbstractClass()
10 {}
11 
12 void AbstractClass::TemplateMethod()
13 {
14     this->PrimitiveOperation1();
15     this->PrimitiveOperation2();
16 }
17 
18 ConcreteClassA::ConcreteClassA()
19 {}
20 
21 ConcreteClassA::~ConcreteClassA()
22 {}
23 
24 void ConcreteClassA::PrimitiveOperation1()
25 {
26     cout << "ConcreteClassA::PrimitiveOperation1" << endl;
27 }
28 
29 void ConcreteClassA::PrimitiveOperation2()
30 {
31     cout << "ConcreteClassA::PrimitiveOperation2" << endl;
32 }
33 
34 ConcreteClassB::ConcreteClassB()
35 {}
36 
37 ConcreteClassB::~ConcreteClassB()
38 {}
39 
40 void ConcreteClassB::PrimitiveOperation1()
41 {
42     cout << "ConcreteClassB::PrimitiveOperation1" << endl;
43 }
44 
45 void ConcreteClassB::PrimitiveOperation2()
46 {
47     cout << "ConcreteClassB::PrimitiveOperation2" << endl;
48 }

 1 #include "TemplateMethod.h"
 2 
 3 int main()
 4 {
 5     //ConcreteClassA与ConcreteClassB可相互替换
 6     AbstractClass* pAbstract = new ConcreteClassA();
 7     pAbstract->TemplateMethod();
 8 
 9     pAbstract = new ConcreteClassB();
10     pAbstract->TemplateMethod();
11     
12     return 0;
13 }

4.visitor访问者

考虑类似集合的对象组，通过访问者操作

// "Visitor"
abstract class Visitor
{
  // Methods
  abstract public void VisitConcreteElementA(
    ConcreteElementA concreteElementA );
  abstract public void VisitConcreteElementB(
    ConcreteElementB concreteElementB );
}

// "ConcreteVisitor1"
class ConcreteVisitor1 : Visitor
{
  // Methods
  override public void VisitConcreteElementA(
    ConcreteElementA concreteElementA )
  {
    Console.WriteLine( "{0} visited by {1}",
      concreteElementA, this );
  }

  override public void VisitConcreteElementB(
    ConcreteElementB concreteElementB )
  {
    Console.WriteLine( "{0} visited by {1}",
      concreteElementB, this );
  }
}

// "ConcreteVisitor2"
class ConcreteVisitor2 : Visitor
{
  // Methods
  override public void VisitConcreteElementA(
    ConcreteElementA concreteElementA )
  {
    Console.WriteLine( "{0} visited by {1}",
      concreteElementA, this );
  }
  override public void VisitConcreteElementB(
    ConcreteElementB concreteElementB )
  {
    Console.WriteLine( "{0} visited by {1}",
      concreteElementB, this );
  }
}

// "Element"
abstract class Element
{
  // Methods
  abstract public void Accept( Visitor visitor );
}

// "ConcreteElementA"
class ConcreteElementA : Element
{
  // Methods
  override public void Accept( Visitor visitor )
  {
    visitor.VisitConcreteElementA( this );
  }

  public void OperationA()
  {
  }
}

// "ConcreteElementB"
class ConcreteElementB : Element
{
  // Methods
  override public void Accept( Visitor visitor )
  {
    visitor.VisitConcreteElementB( this );
  }

  public void OperationB()
  {
  }
}

// "ObjectStructure"
class ObjectStructure
{
  // Fields
  private ArrayList elements = new ArrayList();

  // Methods
  public void Attach( Element element )
  {
    elements.Add( element );
  }

  public void Detach( Element element )
  {
    elements.Remove( element );
  }

  public void Accept( Visitor visitor )
  {
    foreach( Element e in elements )
      e.Accept( visitor );
  }
}

/// <summary>
/// Client test
/// </summary>
public class Client
{
  public static void Main( string[] args )
  {
    // Setup structure
    ObjectStructure o = new ObjectStructure();
    o.Attach( new ConcreteElementA() );
    o.Attach( new ConcreteElementB() );

    // Create visitor objects
    ConcreteVisitor1 v1 = new ConcreteVisitor1();
    ConcreteVisitor2 v2 = new ConcreteVisitor2();

    // Structure accepting visitors
    o.Accept( v1 );
    o.Accept( v2 );
  }
}