Java 设计模式之 策略模式

思维导图：

我们先来看 STRATEGY 设计模式的通俗解释：

跟不同类型的MM约会，要用不同的策略，有的请电影比较好，有的则去吃小吃效果不错，有的去海边浪漫最合适，但目的都是为了得到 MM 的芳心，我的追 MM 锦囊中有好多 Strategy 哦。
策略模式：

策略模式针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。

策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模式把行为和环境分开。环境类负责维持和查询行为类，各种算法在具体的策略类中提供。由于算法和环境独立开来，算法的增减，修改都不会影响到环境和客户端。

例1：

首先定义一个接口，这个接口是诸葛亮给赵云三个妙计的接口。

1、将公共的部分抽象为接口；

下面这个接口是算法类的公共接口。

package com.liwei.strategy;
/**
 * 首先定义一个接口，这个接口是诸葛亮给赵云三个妙计的接口
 * @author Administrator
 *
 */
public interface IStrategy {
    /**
     * 每个妙计都是一个可以执行的算法
     */
    public void operate();
}

2、写好三个实现类

package com.liwei.strategy.impl;

import com.liwei.strategy.IStrategy;
/**
 * 妙计实现类之一
 * @author Administrator
 *
 */
public class BackDoor implements IStrategy {
    @Override
    public void operate() {
        System.out.println("找乔国老开后门，让吴国太给孙权施加压力，使孙权不能杀刘备。");
    }

}

package com.liwei.strategy.impl;

import com.liwei.strategy.IStrategy;

/**
 * 妙计实现类之一
 * 
 * @author Administrator
 * 
 */
public class BlackEnemy implements IStrategy {
    @Override
    public void operate() {
        System.out.println("孙夫人出面，挡住追兵。");
    }

}

package com.liwei.strategy.impl;

import com.liwei.strategy.IStrategy;
/**
 * 妙计实现类之一
 * @author Administrator
 *
 */
public class GivenGreenLight implements IStrategy {
    @Override
    public void operate() {
        System.out.println("求吴国太开个绿灯，甘露寺解围！");
    }
    
}

3、把实现类放在一个环境里（无须实现接口、可以认为是对外提供一个方法）

package com.liwei.strategy;
/**
 * 这是锦囊，存放妙计的地方
 * @author Administrator
 *
 */
public class Context {
    private IStrategy strategy;

    /**
     * 使用构造函数注入，指明你要使用哪一条妙计
     * @param strategy
     */
    public Context(IStrategy strategy) {
        this.strategy = strategy;
    }
    
    /**
     * 这是锦囊的方法，由锦囊产生妙计，而妙计由注入的妙计接口来决定
     */
    public void oper(){
        /**
         * 这个时候，真正传进来的妙计要真正出马了
         */
        this.strategy.operate();
    }
}

4、编写测试类

package com.liwei.strategy;

import com.liwei.strategy.impl.BackDoor;
import com.liwei.strategy.impl.BlackEnemy;
import com.liwei.strategy.impl.GivenGreenLight;

public class Test {
    /**
     * 这里要注意：是锦囊执行了操作
     * @param args
     */
    public static void main(String[] args) {
        Context context;
        // 刚到吴国的时候拆开第 1 个
        System.out.println("------刚到吴国的时候拆开第 1 个锦囊了------");
        context = new Context(new BackDoor());
        context.oper();
        System.out.println("

");
        System.out.println("------这时刘备乐不思蜀，开始拆第 2 个锦囊了------");
        context = new Context(new GivenGreenLight());
        context.oper();
        System.out.println("

");
        System.out.println("------孙权追兵到了，开始拆第 3 个锦囊了------");
        context = new Context(new BlackEnemy());
        context.oper();
    }
}

例2：

1、定义一个算法类的公共接口；

这个接口只是定义了计算，如何计算？两个操作数是加、减、乘、除？

package com.shejimoshi.celue;

public interface Strategy {
    public int calculate(int a,int b);
}

2、实现算法接口的类；

package com.shejimoshi.celue;

public class AddStrategy implements Strategy {

    @Override
    public int calculate(int a, int b) {
        return a + b;
    }

}

package com.shejimoshi.celue;

public class SubtractStrategy implements Strategy {

    @Override
    public int calculate(int a, int b) {
        return a - b;
    }

}

package com.shejimoshi.celue;

public class MulStrategy implements Strategy {

    @Override
    public int calculate(int a, int b) {
        return a * b;
    }

}

3、定义一个环境类；

package com.shejimoshi.celue;

public class Environment {
    private Strategy strategy;

    public Environment(Strategy strategy) {
        super();
        this.strategy = strategy;
    }

    public Strategy getStrategy() {
        return strategy;
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public int calculate(int a, int b) {
        return this.strategy.calculate(a, b);
    }
}

4、由环境类执行操作。

package com.shejimoshi.celue;

public class Client {
    public static void main(String[] args) {
        /**
         * 理解策略设计模式要注意留意 Java 中多态的概念
         */
        AddStrategy addStrategy = new AddStrategy();
        Environment environment = new Environment(addStrategy);
        System.out.println(environment.calculate(4, 3));

        // 减法
        SubtractStrategy subStrategy = new SubtractStrategy();
        environment.setStrategy(subStrategy);
        System.out.println(environment.calculate(4, 3));

        // 乘法
        MulStrategy multiplyStrategy = new MulStrategy();
        environment.setStrategy(multiplyStrategy);
        System.out.println(environment.calculate(4, 3));
    }
}