一般实现

• 创建执行方法

    public static void main(String[] args) {
        ExcuMenthod em = new ExcuMenthod();
        em.method1();
        em.method2();
        em.method3();
    }

• 测试类

    public static void main(String[] args) {
        ExcuMenthod em = new ExcuMenthod();
        em.method1();
        em.method2();
        em.method3();
    }

• 问题
  在执行方法中添加或修改方法时，需要修改执行类的源代码，及客户端调用的方法。

策略模式

• 需要创建
  一个容器类（Context），一个策略接口（IStrategy），多个策略类（Strategy implement IStrategy）及一个测试类。
• 代码实现

  容器类：通过构造方法注入IStrategy接口的实现类，然后调用接口的执行方法；

    public class Context {
    
        private IStrategy strategy;
    
        public Context(IStrategy strategy){
            this.strategy = strategy;
        }
    
        public void operator (){
            strategy.operator();
        }
    }

策略接口：定义策略的执行方法；

    public interface IStrategy {
    
        void operator();
    
    }

策略接口：实现策略接口，拥有具体的执行方法；

    public class Strategy1 implements IStrategy{
        
        @Override
        public void operator() {
            System.out.println("FIRST OPERATOR ...");
        }
    }

    public class Strategy2 implements IStrategy{
        
        @Override
        public void operator() {
            System.out.println("SECOND OPERATOR ...");
        }
    }

    public class Strategy3 implements IStrategy{
        
        @Override
        public void operator() {
            System.out.println("THIRD OPERATOR ...");
        }
    }

• 具体实现

  在测试方法中实例化一个容器，通过构造方法利用多态的性质传入具体的实现类，调用容器的执行方法，即实现具体策略类的执行方法。

     public static void main(String[] args) {
        Context context = new Context(new Strategy1());
        context.operator();

        context = new Context(new Strategy2());
        context.operator();

        context = new Context(new Strategy3());
        context.operator();
    }

输出：

    FIRST OPERATOR ...
    SECOND OPERATOR ...
    THIRD OPERATOR ...

• 优点

  动态改变对象的行为。

• 缺点
  客户端需要知道所有的策略类，从而决定具体调用；会产生大量策略类。

源码

https://github.com/Seasons20/DisignPattern.git
   

END