元哥的筆記

目的：將各種演算法(策略)，包裝成一個類別

何謂策略模式?
A:定義了演算法家族，個別封裝起來，讓它們之間可以互相替換，此模式讓演算法的變動不會影響到使用演算法的程式。

為什麼要用策略模式?
A:透過動態方式所使用的演算法而不變動到使用演算法的程式，降低程式間的耦合度。

什麼時機適合用此模式?
A:頻繁的更換或動態的指定所使用的演算法而不變動到使用演算法的程式時，就是用此模式。

How: 若要使用此模式，如何使用呢?

   class Program
    {
        static void Main(string[] args)
        {
            Adventurer adventurer = null;
            Console.WriteLine("史萊姆");
            adventurer = new Adventurer(new NormalAttack());

            adventurer.Attack(); Console.WriteLine("小頭目");
            adventurer = new Adventurer(new UseSkill());
            adventurer.Attack();

        }
    }

    class Adventurer
    {
        private IFlightStrategy iFilightStrategy;

        public Adventurer(IFlightStrategy filightStrategy)
        {
            this.iFilightStrategy = filightStrategy;
        }

        public void Attack()
        {
            if (iFilightStrategy ==null)
            {
                iFilightStrategy = new NormalAttack();
            }
            iFilightStrategy.execute();
        } 
    }

    interface IFlightStrategy
    {
        void execute();
    }

    class NormalAttack :IFlightStrategy
    {
        public void execute()
        {
            Console.WriteLine("一般攻擊");
        }
    }

    class UseSkill:IFlightStrategy
    {
        public void execute()
        {
            Console.WriteLine("使用技能");
        }
    }

    class UseItem : IFlightStrategy
    {
        public void execute()
        {
            Console.WriteLine("使用道具");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Context context = null;
            context = new Context(new ConcreteStrategyA());
            context.ContextInterface();
            context = new Context(new ConcreteStrategyB());
            context.ContextInterface();

        }
    }

    abstract class Strategy
    {
        public abstract void AlgorithmInterface();
    }

    class ConcreteStrategyA:Strategy
    {
        public override void AlgorithmInterface()
        {
            Console.WriteLine("ConcreteStrategyA");
        }
    }
    class ConcreteStrategyB:Strategy
    {
        public override void AlgorithmInterface()
        {
            Console.WriteLine("ConcreteStrategyB");
        }
    }

    class Context
    {
        private Strategy _strategy;

        public Context(Strategy strategy)
        {
            _strategy = strategy;
        }

        public void ContextInterface()
        {
            _strategy.AlgorithmInterface();
        }
    }

 優點：
1.提供OCP原則的支持下，可以在不修改原有的架構，可以增加新的演算法。
2.管理演算法整個辦法。
3.可以避免多重條件移轉語句。

缺點：
1.必須知道所有的策略類，並自己使用哪一個策略類。
2. 會產生很多策略類，可以透過使用享元模式在一定程度減少物件的數量。

元哥的筆記