HeadFirst设计模式 -策略模式

策略模式

策略模式的关键是封装。针对接口编程而不是实现。将具体的行为独立出来，降低类之间的耦合度。

具体的从下面的代码中寻出其内在。多用组合，少用继承。

using System;
using System.Collections.Generic;
using System.Text;

namespace DesignModel
{
    class MiniDuckSimulator1
    {
      
    }


    class Duck1
    {
        public void quack(){}
        public void swim(){}
        public void display(){}
        public void fly(){}//并不是每个鸭子都有飞行的行为。那么如果其它的类继承此，代码出现冗余。
                           //或许我们想将次提取出来，那么这就是将不同的提取出来并将其封装。思抽象类，于是定义一个飞行的类

    }

    /// <summary>
    /// 下面添加一个飞行的类，且鸭子类将此类进行组合以获得飞行
    /// </summary>
    class FlyAble
    {
        public  void fly();//那么此时其它的方法继承此
    }
    class Duck2
    {
        public void display(){}
    }
    class MallardDuck1:Duck2
    {
        FlyAble flyable;//将飞行的行为组合进鸭子的类中
                         //有问题吗？？
                        //设想不是每个鸭子的飞行方式都是一样的，那么如何同一个行为呈现不同的方式呢？多态告诉我们
    }


    
    /// <summary>
    /// 定义一个飞行的抽象类
    /// </summary>
    interface IFlayable
    {
        public abstract void fly();//对于飞行来说，已经完全与鸭子的行为分离开来。不仅仅是适用于鸭子。对于任何一个鸟类都可以组合
    }
    class FlyWithWings1:IFlayable
    {
        public override void fly()//此时
        {

        }
    }
    class Duck3
    {
        IFlayable flyable;//此接口通过创建不同对象表现不同的行为
        public void display(){}
    }
    class MallardDuck2:Duck3
    {
        MallardDuck2()
        {
            flyable = new FlyWithWings1();
        }
    }

下面对其进行改进

using System;
using System.Collections.Generic;
using System.Text;


namespace DesignModel
{
    /// <summary>
    /// 
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Duck mallard = new MallardDull();
            mallard.performFly();
            mallard.performQuack();
            Console.ReadLine();
        }
    }

    //飞行的抽象类
    public interface FlyBehavior
    {
        void fly();
    }

    class FlyWithWings:FlyBehavior
    {
       public void fly()
        {
            Console.WriteLine("I'm flying!");
        }
    }
    class FlyNoWay:FlyBehavior
    {
        public void fly()
        {
            Console.WriteLine("I can't fly");
        }
    }


    //发声的抽象类
    public interface QuackBehavior
    {
         void quack();
    }

    class Quack:QuackBehavior
    {
        public void quack()
        {
            Console.WriteLine("Quack");
        }
    }

    class MuteQuack:QuackBehavior
    {
        public void quack()
        {
            Console.WriteLine("《Silence》");
        }
    }

    //抽象的鸭子类
    abstract class Duck
    {
        public FlyBehavior flyBehavior;
        public  QuackBehavior quackBehavior;
        public Duck()
        {

        }
        public abstract void display();
        public void performFly()//调用飞行行为
        {
            flyBehavior.fly();
        }
        public void performQuack()
        {
            quackBehavior.quack();
        }
        public void swim()
        {
            Console.WriteLine("All ducks float,even decoys!");
        }
    }
    
    class MallardDull:Duck
    {
        public MallardDull()
        {
            quackBehavior = new Quack();
            flyBehavior = new FlyWithWings();
        }
        public override void display()
        {
            Console.WriteLine("I am a real Mallard Duck");
        }
    }
}

//这就是策略模式，设计原则：找出应用中可能的变化之处对其封装，而不变的部分依旧放在类中。赋予其弹性
//针对的是接口编程，而不是实现编程
//多用组合，组合更为的灵活，耦合性更低。少用继承

运行结果为：