简单工厂模式和策略模式的差别

直接上代码:

简单工厂模式:

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

------------------------------2个实现类   --------------------------

//继承自抽象类
class A:AbsClass
{
    //详细方法：提供一些列的算法操作
    public override double acceptCash(string org)

{

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

  }
}

//继承自抽象类
class B:AbsClass
{
    //详细方法：提供一些列的算法操作
    public override double acceptCash(string org)

{

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

  }
}

------------------------------简单工厂类   --------------------------

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

client调用:

/利用简单工厂模式依据下拉选择框，生成对应的对象
AbsClass csuper = CashFactory.createCashAccept("A");// 通过传入type 就能够得到详细的实现类。就好比：你去机场，你直接跟你秘书说，我们开车去机场。这个时候你秘书开车载我去，你负责坐车到机场就能够了。

AbsClass csuper= CashFactory.createCashAccept("B"); //或者 秘书去叫出租车 我们打车去

------------------------------策略模式:   --------------------------

 前面的类没有不论什么变化，仅仅是把Factory变成了CaseContext策略类

//策略Context
class CashContext
{
    //声明一个现金收费父类对象
    private AbsClass cs;

    //设置策略行为，參数为详细的现金收费子类（正常，打折或返利）
    public CashContext(AbsClass csuper)
    {
        this.cs = csuper;
    }

    //得到现金促销计算结果（利用了多态机制，不同的策略行为导致不同的结果）
    public double GetResult(double money)
    {
        return cs.acceptCash(money);
    }
}

client调用:

AbsClass cc = null;
   switch (cbxType.SelectedItem.ToString())
            {
                case "A":
                    cc = new CashContext(new A()); //相同是去机场，此时：自己开车去
                    break;
                case "B":
                    cc = new CashContext(new B());//或者自己打车去
                    break;
                case "...":
                    ... ....
                    break;
            }

最后概括总结一下:

策略模式和简单工厂模式看起来很相似，都是通过多态来实现不同子类的选取，这样的思想应该是从程序的总体来看得出的。

假设从使用这两种模式的角度来看的话，我们会发如今简单工厂模式中我们仅仅须要传递对应的条件就能得到想要的一个对象（告诉别人我要干嘛、别人去做），然后通过这个对象实现算法的操作。

而策略模式，使用时必须首先创建一个想使用的类对象（自己去 做）。然后将该对象最为參数传递进去，通过该对象调用不同的算法。在简单工厂模式中实现了通过条件选取一个类去实例化对象，策略模式则将选取对应对象的工作交给模式的使用者，它本身不去做选取工作。

结合上面的代码和以下的释义不难看出。事实上两个的区别非常微妙,Factory是直接创建详细的对象并用该对象去运行对应的动作，而Context将这个操作给了Context类。没有创建详细的对象，实现的代码的进一步封装，client代码并不须要知道详细的实现过程。

当然用的最多的还是两者的结合使用

------------------------------策略模式和简单工厂模式:   --------------------------

 前面的类没有不论什么变化，仅仅是把Factory变成了CaseContext策略类

//策略Context
class CashContext
{
    //声明一个现金收费父类对象
    private AbsClass cs;

  public CashContext(String typr)
    {
        switch (type)     //跟秘书打个招呼 我要去机场
             {
                case "A":
                    cc = new CashContext(new A()); //相同是去机场，此时：自己开车去
                    break;
                case "B":
                    cc = new CashContext(new B());//或者自己打车去
                    break;
                case "...":
                    ... ....
                    break;
             }

  }

    //得到现金促销计算结果（利用了多态机制，不同的策略行为导致不同的结果）
    public double GetResult(double money)
    {
        return cs.acceptCash(money);
    }
}

client调用:

CashContext context= CashContext("A");

double a=context.GetResult(double money);

总结：简单工厂模式：只须要发出命令，由他人去实现，策略模式：不只要发出命令，还得由自己亲自去做。