设计模式（一）简单工厂与策略模式

设计模式用 UML 类图来描述比较普遍。如样例所示，注意前面的符号：

‘+’ 表示 Public，‘-’ 表示 Private，‘#’ 表示 Protected；

继承关系用 空心三角形 + 实线 来表示；

实现接口用 空心三角形 + 虚线 来表示；

关联关系用 实线箭头 来表示（当一个类需要 ‘知道’ 另一个类）；

聚合关系用 空心的菱形 + 实线箭头 来表示（聚合(Aggregation)表示一种弱的 ‘拥有’ 关系，体现的是 A 对象可以包含 B 对象，但 B 对象不是 A 对象的一部分）；

合成关系用 实心的菱形 + 实线箭头 来表示（合成（Composition），或称组合，是一种强的 ‘拥有’ 关系，体现了严格的部分与整体的关系，部分和整体的生命周期是一样的）；如果一个类可能有无数个实例，则就用 ‘n’ 来表示。关联关系、聚合关系也可以有基数的。

依赖关系用 虚线箭头 来表示（Dependency ）。

 面向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类。

interface IFly
{
    void Fly();
}
interface ILanguage
{
    void Speak();
}
// 继承动物类
class Bird : Animal
{
}
// 实现飞翔接口
class WideGoose : IFly
{
}
// 企鹅引用到气候对象
class Penguin : Bird
{
    private Climate climate;
}
// 雁群 类中有 大雁数组 对象
class WideGooseAggregate
{
    private WideGoose[] arrayWideGoose;
}
// 在鸟类初始化时，实例化翅膀Wing，它们之间同时生成
class Bird
{
    private Wing wing;
    public Bird()
    {
        wing = new Wing();
    }   
}
abstract class Animal
{
    public Metabolism(Oxygen oxygen, Water water)
    {
    }
}

一、简单工厂模式

代码实现

// 运算类
public class Operation
{
  private double _numberA = 0;
  private double _numberB = 0;

  public double NumberA
  {
    get{ return _numberA; }
    set{ _numberA = value; }
  }

  public double NumberB
  {
    get{ return _numberB; }
    set{ _numberB = value; }
  }

  public virtual double GetResult()
  {
    double result = 0;
    return result;
  }
}
// 加法类，继承 运算类
class OperationAdd : Operation
{
  public override double GetResult()
  {
    double result = 0;
    result = NumberA + NumberB;
    return result;
  }
}
// 减法类，继承 运算类
class OperationSub : Operation
{
  public override double GetResult()
  {
    double result = 0;
    result = NumberA - NumberB;
    return result;
  }
}
// 乘法类，继承 运算类
class OperationMul : Operation
{
  public override double GetResult()
  {
    double result = 0;
    result = NumberA * NumberB;
    return result;
  }
}
// 除法类，继承 运算类
class OperationDiv : Operation
{
  public override double GetResult()
  {
    double result = 0;
    if(NumberB == 0)
      throw new Exception("除数不能为零");
    result = NumberA / NumberB;
    return result;
  }
}
// 
punlic class OperationFactory
{
  public static Operation createOperate(string operate)
  {
    Operation  oper = null;
    switch(operate)
    {
      case "+":
        oper = new OperationAdd();
        break;
      case "-":
        oper = new OperationSub();
        break;
      case "*":
        oper = new OperationMul();
        break;
      case "/":
        oper = new OperationDiv();
        break;
    }
    return oper;
  }

}

// 客户端代码
Operation oper;
oper = OperationFactory.createOperate("+");
oper.NumberA = 1;
oper.NumberB = 1;
double result = oper.GetResult();

 

代码结构图

// 现金收费抽象类
abstract class CashSuper
{
  // 现金收取超类的抽象方法，收取现金，参数为原价，返回为当前价
  public abstract double acceptCash(double money)
}
// 正常收费子类
class CashNormal : CashSuper
{
  // 正常收费，原价返回
  public override double acceptCash(double money)
  {
    return money;
  }
}
// 打折收费子类
class CashRebate : CashSuper
{
  private double moneyRebate = 1d;

  public CashRebate(string moneyRebate)
  {
    // 打折收费，初始化时，必需要输入折扣率，如八折，就是 0.8
    this.moneyRebate = double.Parse(moneyRebate);
  }

  public override double accepeCash(double money)
  {
    return money * moneyRebate;
  }

}
// 返利收费子类
class CashReturn : CashSuper
{
  private double moneyCondition = 0.0d;
  private double moneyReturn = 0.0d;

  // 返利收费，初始化时必须要输入返利条件和返利值，比如满 300 返 100，则 moneyCondition = 300，moneyReturn = 100
  public CashReturn(string moneyCondition, string moneyReturn)

  //
  public override double accepeCash(double money)
  {
    double result = money;
    // 若大于返利条件，则需要减去返利值
    if(money >= moneyCondition)
      result = money - Math.Floor(money / moneyCondition) * moneyReturn;

    return result;
  }
}
// 现金收费工厂类
class CashFactory
{
  public static CashSuper createCashAccept(string type)
  {
    CashSper cs = null;
    // 根据条件返回相应的对象
    switch(type)
    {
      case "正常收费":
        cs = new CashNormal();
        break;
      case "满 300 返 100":
        CashReturn cr1 = new CashReturn("300","100");
        cs = cr1;
        break;
      case "打 8 折"
        CashRebate cr2 = new CashRebate("0.8");
        cs = cr2;
        break;
    } 
    return cs;
  }
}

// 客户端窗体部分
double total = 0.0d;
private void btnOK_Click(object sender, EventArgs e)
{
  // 利用简单工厂模式根据下拉选择框，生成相应的对象
  CashSuper csuper = CashFactory.createCashAccept(cbxType.SelectedItem.ToString());
  
  double totalPrices = 0d;
  totalPrices = csuper.acceptCash(Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text));

  total = total + totalPrices;
  // 通过多态，可以得到收取费用的结果
  lbxList.Items.Add("单价："+ txtPrice.Text + "数量：" + txtNum.Text + "" + cbxType.SelectedItem + "合计：" + totalPrices.ToString());
  lbxResult.Text = total.ToString();

}

 

二、策略模式

 

策略模式（Strategy）：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。

// 抽象算法类，定义所有支持的算法的公共接口
abstract class Strategy
{
    // 算法方法
    public  abstract  void  AlgorithmInterface();
}

// ConcreteStrategy 封装了具体的算法和行为，继承于 Strategy 
// 具体算法 A
class  ConcreteStrategyA : Strategy
{
    // 算法 A 实现方法
    public  override  void  AlgorithmInterface()
    {
        Console.WriteLine("算法 A 实现");
    }
}
// 具体算法 B
class  ConcreteStrategyB : Strategy
{
    // 算法 B 实现方法
    public  override  void  AlgorithmInterface()
    {
        Console.WriteLine("算法 B 实现");
    }
}
// 具体算法 C
class  ConcreteStrategyC : Strategy
{
    // 算法 C 实现方法
    public  override  void  AlgorithmInterface()
    {
        Console.WriteLine("算法 C 实现");
    }
}

// Context，用一个 ConcreteStrategy 来配置，维护一个对 Strategy 对象的引用。
// 上下文
class Context
{
    Strategy  strategy;
    public  Context(Strategy  strategy)
    {
        this.strategy = strategy;
    }
    // 上下文接口
    public void ContextInterface()
    {
        strategy.AlgorithmInterface();
    }
}

// 客户端代码
static void Main(string[] args)
{
    Context context;

    context = new Context(new ConcreteStrategyA());
    context.ContextInterface();

    context = new Context(new ConcreteStrategyB());
    context.ContextInterface();

    context = new Context(new ConcreteStrategyC());
    context.ContextInterface();

    Console.Read();
}

 【总结】

策略模式是一种定义一系列算法的方法，从概念上讲，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。

策略模式的 Strategy 类层次为 Context 定义了一系列的可供重用的算法和行为。继承有助于析取出这些算法中的公共功能。

策略模式的另一个优点是简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。

策略模式是用来封装算法的，但在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。

在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式的 Context 对象。这本身并没有解除客户端需要选择判断的压力，而策略模式与简单工厂模式结合后，选择具体实现的职责也可以由 Context 来承担，这就最大化地减轻了客户端的职责。

简单工厂模式需要让客户端认识两个类，CashSuper 和 CashFactory；而策略模式与简单工厂结合的用法，客户端就只需要认识一个类 CashContext 就可以了。耦合度更加降低。使得具体的收费算法彻底与客户端分离。

 

// 将实例化具体策略的过程由客户端转移到 Context 类中。简单工厂的应用
class CashContext
{
  CashSuper cs = null;

  public CashContext(string type) // 注意参数不是具体的收费策略对象，而是一个字符串，表示收费类型
  {
    switch(type)
    {
      case "正常收费":
        CashNormal cs0 = new CashNormal();
        cs = cs0;
        break;
      case "满 300 返 100":
        CashReturn cr1 = new CashReturn("300","100");
        cs = cr1;
        break;
      case "打 8 折"
        CashRebate cr2 = new CashRebate("0.8");
        cs = cr2;
        break;      
    }
  }
}

// 客户端窗体部分
double total = 0.0d;
private void btnOK_Click(object sender, EventArgs e)
{
  // 根据下拉选择框，将相应的算法类型字符串传入 CashContext 的对象中
  CashContext csuper = new CashContext(cbxType.SelectedItem.ToString());
  
  double totalPrices = 0d;
  totalPrices = csuper.GetResult(Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text));

  total = total + totalPrices;
  // 
  lbxList.Items.Add("单价："+ txtPrice.Text + "数量：" + txtNum.Text + "" + cbxType.SelectedItem + "合计：" + totalPrices.ToString());
  lbxResult.Text = total.ToString();

}

 

 

【参考文献】

1、《大话设计模式》