行为型设计模式--策略模式(Strategy)

策略模式(Strategy)

    定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。该模式使得算法可独立于它们的客户变化。

 

 

    抽象策略(Strategy)角色：策略类，通常由一个接口或者抽象类实现
    具体策略(ConcreteStrategyA)角色：包装了相关的算法和行为
    环境(Context)角色：持有一个策略类的引用，最终给客户端调用的。

// 抽象策略角色
public abstract class AbstractStrategy {
	public abstract String calculate(float a, float b);
}

// 具体策略角色
public class AddStrategy extends AbstractStrategy {
	public String calculate(float a, float b) {
		float result = a + b;
		return "相加结果为:" + result;
	}
}

public class SubStrategy extends AbstractStrategy {
	public String calculate(float a, float b) {
		float result = a - b;
		return "相减结果为:" + result;
	}
}

// 环境角色
public class ContextRole {
	// 拥有一个策略类的引用
	private AbstractStrategy abstactStrategy;

	public ContextRole(AbstractStrategy abstactStrategy) {
		this.abstactStrategy = abstactStrategy;
	}

	public String calculate(float a, float b) {
		String result = abstactStrategy.calculate(a, b);
		return result;
	}
}

// 客户端
public class Test {
	public static void main(String[] args) {
		float a = 200;
		float b = 25;
		ContextRole contextRole1 = new ContextRole(new AddStrategy());
		contextRole1.calculate(a, b);
	}
}

// 与工厂模式结合
public class ContextRole {
	// 拥有一个策略类的引用
	private AbstractStrategy abstactStrategy;

	public ContextRole(String type) {
		switch (type) {
		case "+":
			abstactStrategy = new AddStrategy();
			break;
		case "-":
			abstactStrategy = new SubStrategy();
			break;
		}
	}

	public void calculate(float a, float b) {
		abstactStrategy.calculate(a, b);
	}
}

public class Test {
	public static void main(String[] args) {
		float a = 200;
		float b = 25;
		ContextRole contextRole1 = new ContextRole("+");
		contextRole1.calculate(a, b);
	}
}

 

    优点:
    1. 可以很方便的动态改变算法或行为
    2. Strategy模式提供了用条件判断语句以外的另一中选择，消除条件判断语句，就是在解耦合。
    3. 简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。

    缺点:
    1. 客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
    2. 造成很多的策略类。

   

    含有许多条件判断语句的代码通常都需要Strategy模式

    在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式的Context对象

    策略模式与简单工厂模式结合后，选择具体实现的职责也可以由Context来承担，这就最大化的减轻了客户端的压力