策略模式

来源：互联网发布：智睿高清网络电视安卓编辑：程序博客网时间：2024/06/05 20:08

namespace DuckExample
{
    //策略模式(Strategy Pattern)：
    //定义了算法族，分别封装起来，让它们之间可以互相替换，
    //此模式让算法的变化独立于使用算法的客户。
    class Program
    {
        static void Main(string[] args)
        {
            Duck dark = new MallardDark();
            dark.PerformQuack();
            dark.PerformFly();
            dark.Swim();
            dark.Display();
            Console.WriteLine("---------------------------");
            Console.WriteLine("Below is model duck Action:");
            Duck model=new ModelDuck();
            model.PerformQuack();
            model.PerformFly();
            //运行时，想改变鸭子的行为，只需要调用鸭子的setter方法就OK
            model.SetFlyable(new FlyRocketPowered());
            model.PerformFly();
            model.Swim();
            model.Display();
            Console.ReadKey(true);
        }
    }
    public abstract class Duck
    {
        protected IQuackble quackble;
        protected IFlyable flyable;
        //为了在运行时动态的改变行为
        public void SetQuackable(IQuackble qa)
        {
            quackble = qa;
        }
        public void SetFlyable(IFlyable fa)
        {
            flyable = fa;
        }
        public void PerformQuack()
        {
            quackble.Quack();
        }
        public void PerformFly()
        {
            flyable.Fly();
        }
        public void Swim()
        {
            Console.WriteLine("正在游泳");
        }
        public abstract void Display();
    }
    //叫
    public interface IQuackble
    {
        void Quack();
    }
    public interface IFlyable

    {
        void Fly();
    }
    #region 封装变化的行为
    /*1、把变化的部分取出并“封装”起来，好让其他部分不会受到影响。
     *   意图：代码变化引起的不经意后果变少，系统变得更有弹性！
     *   设计原则：找出应用中可能需要变化之处，把它们独立出来，
     *   不要和那些不需要变化的代码混在一起。
     *
     *2、鸭子的行为将放在分开的类中（此类专门提供某行为接口的实现）。
     *   这样，鸭子类就不再需要知道行为的实现细节
     *   设计原则：针对接口编程，而不是针对实现编程
     *
     * 3、鸭子的行为不是继承来的，而是和适当的行为对象“组合”来的。
     *    设计原则：多用组合，少用继承。
     * 总结：这样的设计，可以让飞行和呱呱叫的动作被其他的对象复用，
     * 因为这些行为已经于鸭子类无关了。而我们可以新增一些行为，不会
     * 影响到既有的行为类，也不会影响“使用”到飞行行为的鸭子类
     * 这么一来，有了继承的“复用”好处，却没有继承所带的包袱。
     */

    // 负责实现呱呱叫的行为类
    class Quack:IQuackble
    {
        void IQuackble.Quack()
        {
            Console.WriteLine("呱呱叫");
        }
    }
    // 负责实现橡皮鸭子吱吱叫的行为类
    class Squeak:IQuackble
    {
        public void Quack()
        {
            Console.WriteLine("吱吱叫");
        }
    }
    // 名为呱呱叫，其实不出声
    class MuteQuack:IQuackble
    {
        public void Quack()
        {
            Console.WriteLine("不会叫");
        }
    }
    // 所有带翅膀会飞行的鸭子
    class FlyWithWings:IFlyable
    {
        public void Fly()
        {
            Console.WriteLine("鸭子起飞");
        }
    }
    // 所有不会飞的鸭子
    class FlyNoWay : IFlyable
    {
        public void Fly()
        {
            Console.WriteLine("俺不会飞");
        }
    }
    // 火箭动力推动
    class FlyRocketPowered : IFlyable
    {
        public void Fly()
        {
            Console.WriteLine("I am flying with a rocket.");
        }
    }
    #endregion

    //绿头鸭(会呱呱叫，会飞，会游泳，外观绿色)
    class MallardDark:Duck
    {
       public MallardDark()
       {
           quackble=new Quack();
           flyable=new FlyWithWings();
       }

       public override void Display()
       {
           Console.WriteLine("我的外观是绿色的");
       }
    }
    //模型鸭原本不会飞，现在使用火箭动力使其能飞
    class ModelDuck : Duck
    {
        public ModelDuck()
        {
            quackble=new Quack();
            flyable=new FlyNoWay();
        }
        public override void Display()
        {
            Console.WriteLine("I am a model duck.");
        }
    }
}

0 0