简单工厂模式与策略模式

简单工厂模式是属于创建型模式，简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

//抽象类
abstract class AbsClass
{
    //抽象方法：提供一些列的算法操作
    public abstract void returnCash(string org);
}

//继承自抽象类
class A:AbsClass
{
    //具体方法：提供一些列的算法操作
    public override double returnCash()

｛
         Console.WriterLine("A类方法");
  }
}

 

//继承自抽象类
class B:AbsClass
{
    //具体方法：提供一些列的算法操作
    public override double returnCash()

｛

         Console.WriterLine("B类方法");

  }
}


简单工厂类

//现金收取工厂
class CashFactory
{
    //根据条件返回相应的对象
    public static AbsClass createCashAccept(string type)
    {
        AbsClass cs = null;
        switch (type)
        {
            case "A":
                cs = new A();
                break;
            case "B":
                cs = new B();
                break;
            case "...":
                ........ ....
                break;
        }
        return cs;
    }
}

客户端调用：
AbsClass csuper = CashFactory.createCashAccept("A");
csuper .returnCash();

 策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

//策略Context
class CashContext
{
    //声明一个现金收费父类对象
    private AbsClass cs;
    //设置策略行为，参数为具体的现金收费子类（正常，打折或返利）
    public CashContext(AbsClass csuper)
    {
        this.cs = csuper;
    }
    //得到现金促销计算结果（利用了多态机制，不同的策略行为导致不同的结果）
    public double GetResult(double money)
    {
        return cs.acceptCash(money);
    }
}

客户端调用:
AbsClass cc = null;
cc = new CashContext(new A());
cc.GetResult(100);
Console.Read();
 

 这两个模式比较类似，一直纠结于两者区别：

1、面向对象编程的一种重要思维方式是要将变化点封装，对于类似于商场促销等变化点就是选择所谓的算法对象，在这个场景中，任何一个改变都会引起客户端和实现的对象的改变，股选择减少变化点，策略类就出现了，而常用的简单工厂和策略模式相结合，此处却不是很合适，否则又会回到单纯的简单工厂模式；

2、策略模式要求定义了算法家族并分别封装起来，即为了实现一种结果在不同的条件下可能有不同的的方法，但是条件却相对固定，这时可以考虑使用简单工厂和策略模式相结合的方法，将算法封装，之队客户端(调用者)提供工厂对象，这样子客户端子需要了解工厂对象就可以了，降低耦合度；

3、对于在不同的条件下实例化不同的对象，而且实现的方法不同(或者说，需要不同的对象)此时应只使用简单工厂模式。例：Obj A->a():bool 和Obj B->b():string对象，调用A返回结果是true 或者false；使用B返回是string类型，也可以说，使用A和B是为了实现不同的作用。这个时候就要使用简单工厂模式。

个人总结，可能有不对的地方，欢迎讨论拍砖~！