1、策略模式（Strategy）的定义

策略模式（Strategy）定义了不同的算法，分别分装起来，让他们可以互相替换，即使算法变化了，也不会影响到使用算法的用户。策略模式让算法独立于使用它的客户而独立变化。

策略模式本质是：分离算法，选择实现。

通俗来讲：策略模式对应于解决某一个问题的一个算法族，允许用户从该算法族中任选一个算法解决某一问题，同时可以方便的更换算法或者增加新的算法。并且由客户端决定调用哪个算法。

2、模式（Strategy）优缺点

策略模式是一种行为型设计模式。其主要优缺点如下：

优点：

可以动态的改变对象的行为。

上下文和具体策略是松耦合关系。因此上下文只知道它要使用某一个实现Strategy接口类的实例，但不需要知道具体是哪一个类。

策略模式满足“开-闭原则”。当增加新的具体策略时，不需要修改上下文类的代码，上下文就可以引用新的具体策略的实例。

缺点：

客户端必须知道所有的策略类，并自行决定使用哪一个策略类。

策略模式将造成产生很多策略类。

3、模式（Strategy）适用环境

JAVASE中GUI编程中，布局管理。

Spring框架中，Resource接口，资源访问策略。

javax.servlet.http.HttpServlet#service()。

针对同一类型问题的多种处理方式，仅仅是具体行为有差别时。

需要安全的封装多种同一类型的操作时。

出现同一抽象多个子类，而又需要使用if-else 或者 switch-case来选择时。

可以和工厂模式结合使用。

4、模式（Strategy）的结构

策略模式涉及到三个角色：

环境角色（Context） ：用于连接上下文，持有一个策略Strategy的引用。

抽象策略角色（Strategy） ：这是一个抽象角色，通常由一个接口或抽象类实现，此角色给出所有具体策略类所需的接口。

具体策略角色（Concrete Strategy） ：包装了相关算法或行为。

5、模式（Strategy）的应用实例

5.1 实例一：报价策略

某个市场人员接到单后的报价策略(CRM系统中常见问题)。报价策略很复杂，可以简单作如下分类：

普通客户小批量报价

普通客户大批量报价

老客户小批量报价

老客户大批量报价

具体选用哪个报价策略，这需要根据实际情况来确定。这时候，如果我们用普通的方式来实现如下：

public double getPrice(String type, double price) {
	if (type.equals("普通客户小批量")) {
		System.out.println("不打折,原价");
		return price;
	} else if (type.equals("普通客户大批量")) {
		System.out.println("打九折");
		return price * 0.9;
	} else if (type.equals("老客户小批量")) {
		System.out.println("打八五折");
		return price * 0.85;
	} else if (type.equals("老客户大批量")) {
		System.out.println("打八折");
		return price * 0.8;
	}
	return price;
}

这种通过条件判断的方式来实现比较符合普通程序员的思维习惯，但是算法比较复杂时，整个条件控制代码会变得很长，难于维护。

使用策略模式

上面的案例就非常适合使用策略模式。策略模式对应于解决某一个问题的一个算法族，允许用户从该算法族中任选一个算法解决某一问题，同时可以方便的更换算法或者增加新的算法。并且由客户端决定调用哪个算法。我们通过案例来说明。

// Strategy接口
public interface Strategy {
	public double getPrice(double  standardPrice);
}

// 四种算法实现
public class NewCustomerFewStrategy implements Strategy {
	@Override
	public double getPrice(double standardPrice) {
		System.out.println("不打折，原价");
		return standardPrice;
	}
}

public class NewCustomerManyStrategy implements Strategy {
	@Override
	public double getPrice(double standardPrice) {
		System.out.println("打九折");
		return standardPrice*0.9;
	}
}

public class OldCustomerFewStrategy implements Strategy {
	@Override
	public double getPrice(double standardPrice) {
		System.out.println("打八五折");
		return standardPrice*0.85;
	}
}

public class OldCustomerManyStrategy implements Strategy {
	@Override
	public double getPrice(double standardPrice) {
		System.out.println("打八折");
		return standardPrice*0.8;
	}
}

// 对外统一出口
/**
 * 负责和具体的策略类交互
 * 这样的话，具体的算法和直接的客户端调用分离了，使得算法可以独立于客户端独立的变化。
 * 如果使用spring的依赖注入功能，还可以通过配置文件，动态的注入不同策略对象，动态的切换不同的算法.
 * @author Administrator
 *
 */
public class Context {
	//当前采用的算法对象
	private Strategy strategy;	

	//可以通过构造器来注入
	public Context(Strategy strategy) {
		super();
		this.strategy = strategy;
	}
	//可以通过set方法来注入
	public void setStrategy(Strategy strategy) {
		this.strategy = strategy;
	}
	public void pringPrice(double s){
		System.out.println("您该报价："+strategy.getPrice(s));
	}
}

// 测试
public static void main(String[] args) {
	Strategy s1 = new OldCustomerManyStrategy();
	Context ctx = new Context(s1);
	ctx.pringPrice(998);
}

5.2 实例二：数学运算

// 抽象策略类
public interface Strategy {
	public int doOperation(int num1, int num2);
}

// 具体策略类
public class OperationAdd implements Strategy {
	@Override
	public int doOperation(int num1, int num2) {
		return num1 + num2;
	}
}

public class OperationMultiply implements Strategy {
	@Override
	public int doOperation(int num1, int num2) {
		return num1 * num2;
	}
}

public class OperationSubstract implements Strategy {
	@Override
	public int doOperation(int num1, int num2) {
		return num1 - num2;
	}
}

// 应用场景类(上下文)
public class Context {
	private Strategy strategy;

	public Context(Strategy strategy) {
		this.strategy = strategy;
	}

	public int executeStrategy(int num1, int num2) {
		return strategy.doOperation(num1, num2);
	}
}

// 测试类
public class StrategyPatternDemo {
	public static void main(String[] args) {
		Context context = new Context(new OperationAdd());
		System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

		context = new Context(new OperationSubstract());
		System.out.println("10 - 5 = " + context.executeStrategy(10, 5));

		context = new Context(new OperationMultiply());
		System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
	}
}

5.3 和简单工厂模式结合

// 上下文
public class Context2 {
	private Strategy strategy;

	public Context2(String type) {
		switch (type) {
		case "+":
			strategy = new OperationAdd();
			break;
		case "-":
			strategy = new OperationSubstract();
			break;
		case "*":
			strategy = new OperationMultiply();
			break;
		}
	}

	public int executeStrategy(int num1, int num2) {
		return strategy.doOperation(num1, num2);
	}
}

// 测试类
public class StrategyPatternDemo {
	public static void main(String[] args) {
		System.out.println("-----使用简单工厂模式-----");
		Context2 context2 = new Context2("+");
		System.out.println("10 + 5 = " + context2.executeStrategy(10, 5));
		 
		// 使用Lambda表达式，不需要实现策略类
		System.out.println("-----使用Lambda表达式，不需要实现策略类-----");
		Context context3 = new Context((num1, num2) -> num1 + num2);
		System.out.println("10 + 5 = " + context3.executeStrategy(10, 5));

		context3 = new Context((num1, num2) -> num1 - num2);
		System.out.println("10 - 5 = " + context3.executeStrategy(10, 5));

		context3 = new Context((num1, num2) -> num1 * num2);
		System.out.println("10 * 5 = " + context3.executeStrategy(10, 5));
	}
}

目录CONTENT

JAVA设计模式之策略模式

1、策略模式（Strategy）的定义

2、模式（Strategy）优缺点

3、模式（Strategy）适用环境

4、模式（Strategy）的结构

5、模式（Strategy）的应用实例

5.1 实例一：报价策略

5.2 实例二：数学运算

5.3 和简单工厂模式结合

评论区