策略模式（Header-First笔记）

策略模式和设计原则（主要是自己的笔记：水平较低，请勿语言攻击）

如果想理解的深入建议深入的读读headfirst，这个真有用，如果只是随便看看，其实是学不到啥东西的。

本文包括两部分（1.Petshop中策略模式的应用、2.控制台小应用程序）

1.Petshop中策略模式的应用

至于在程序中的应用，我也是个新手，不知道何时需要这种模式，可以参考下petshop中的策略模式，理解下在真实项目中如何使用。我对petshop中策略模式的理解就是里面处理订单时可能有同步和异步插入数据两种方式，具体用那种方式直接在配置文件中修改即可。看文字不如看图片，自己画了画UML图，不会用工具但是意思差不多。

这是IBLLStrategy类库中的接口IBLLStrage，为了同步异步插入订单的实现，如果有新的订单插入方式，可以继承此接口

这两个类是处理同步异步的订单类。继承于IBLLStrage，分别实现自己的插入方法。

在BLL层中的order类中private static readonly PetShop.IBLLStrategy.IOrderStrategy orderInsertStrategy = LoadInsertStrategy();

LoadInsertStrategy方法决定了实例化的是同步传送订单还是异步传送订单。在BLL逻辑层中，Order订单中会改变的是insert方法，所以根据设计原则，把需要改变的独立出来。

2.控制台小应用程序　　

实例描述，模拟鸭子应用，由于后期需要可能有N种鸭子，鸭子可不可以飞，怎样飞，鸭子可不可以叫，怎么叫，如果仅仅写两个接口Ifly和Iquack，子类要么继承，要么不继承，对飞的行为无法控制，因为飞的动作和叫的方式千变万化。

设计原则

　　1.找出应用中可能需要变化之处，把他们独立出来，不要和那些不需要变化的代码混合在一起（此例子中鸭子的行为属于变化）

　　2.针对接口编程，而不是针对实现编程

　　针对接口编程是真正的意思是针对超类型编程，利用多态，程序可以针对超类型编程，声明一个类时通常是一个超类或者是一个接口，这也意味着声明类时，不用理会以后执行的真正对象，举例Animal是一个抽象类，有两个子类Dog和Cat继承Animal

针对实现的编程是:

　　Cat c = new Cat();

　　c.meow();　　　　//猫叫的方式

　　Dog d = new Dog();

　　d.bark();　　　　//狗叫的方式

针对接口的编程是：

　　Animal a = new Dog();

　　a.makeSound();　　//makeSound中会调用bark();

　　Animal a = new Cat();

　　a.makeSound();　　//makeSound中会调用meow();

 3.多用组合，少用继承

根据读headfirst策略模式做的c#的例子

///<summary>
    /// 鸭子超类
    ///</summary>
publicabstractclass Duck
    {
        IFly fly ;
        IQuack quack;
        publicvoid SetFly(IFly fly)
        {
            this.fly = fly;
        }
        publicvoid SetQuack(IQuack quack)
        {
            this.quack = quack;
        }

        publicabstractvoid Display();

        publicvoid Swim()
        {
            Console.WriteLine("I'm Swimming");
        }

        publicvoid PerFormFly()
        {
            fly.Fly();
        }

        publicvoid PerFormQuack()
        {
            quack.QuackSuper();
        }
    }

    ///<summary>
    /// 飞行行为的接口
    ///</summary>
publicinterface IFly
    {
        void Fly();
    }

    publicclass FlyWithWings : IFly
    {
        publicvoid Fly()
        {
            Console.WriteLine("I'm flying");
        }
    }

    publicclass FlyNoWay : IFly
    {
        publicvoid Fly()
        {
            Console.WriteLine("I can't fly");
        }
    }

    publicclass FlayWithRocket : IFly
    {
        publicvoid Fly()
        {
            Console.WriteLine("I'm flying with rocket");
        }
    }

    ///<summary>
    /// 叫的行为接口
    ///</summary>
publicinterface IQuack
    {
        void QuackSuper();
    }

    publicclass Quack : IQuack
    {
        publicvoid QuackSuper()
        {
            Console.WriteLine("鸭子呱呱叫");
        }
    }

    publicclass SQuack : IQuack
    {
        publicvoid QuackSuper()
        {
            Console.WriteLine("鸭子吱吱叫");
        }
    }

    publicclass MuteQuack : IQuack
    {
        publicvoid QuackSuper()
        {
            Console.WriteLine("鸭子不会叫");
        }
    }
    publicclass MallardDuck : Duck
    {
        publicoverridevoid Display()
        {
            Console.WriteLine("绿头鸭子");
        }
    }
    publicclass RedHeadDuck : Duck
    {
        publicoverridevoid Display()
        {
            Console.WriteLine("红头鸭子");
        }
    }
    publicclass RubberDuck : Duck
    {
        publicoverridevoid Display()
        {
            Console.WriteLine("橡皮鸭子");
        }
    }
    publicclass DecoyDuck : Duck
    {
        publicoverridevoid Display()
        {
            Console.WriteLine("诱饵鸭子");
        }
    }


 class Program
    {
        staticvoid Main(string[] args)
        {
            Duck duck =new MallardDuck();
            duck.Display();
            duck.SetFly (new FlyNoWay());
            duck.SetQuack(new SQuack());
            duck.PerFormFly();
            duck.PerFormQuack();
            duck.Swim();
            Console.Read();
        }
    }

策略模式：定义了算法族，分别封装起来，让他们之间可以相互替换，次模式让算法的变化独立于使用算法的客户