策略模式的定义
定义一系列的算法，把它们一个个封装起来，并且使他们可相互替换。本模式使得算法可独立于使用它的客户而变化。
策略模式的本质
分离算法，选择实现。
策略模式的优缺点
缺点
- 客户必须了解每种策略的不同。
- 增加了对象数目
- 只适合扁平的算法结构。如果需要嵌套使用多个算法可以考虑策略模式、变形的职责连、AOP等
示例1
/**
* 策略，定义算法的接口
*/
public interface Strategy {
/**
* 某个算法的接口，可以有传入参数也可以有返回值
*/
void algorithmInterface();
}
/**
* 实现具体的算法
*/
public class ConcreteStrategyA implements Strategy {
@Override
public void algorithmInterface() {
//具体的算法实现
}
}
/**
* 实现具体的算法
*/
public class ConcreteStrategyB implements Strategy {
@Override
public void algorithmInterface() {
//具体的算法实现
}
}
/**
* 实现具体的算法
*/
public class ConcreteStrategyC implements Strategy {
@Override
public void algorithmInterface() {
//具体的算法实现
}
}
/**
* 上下文对象，通常会持有一个具体的策略实现
*/
public class Context {
/**持有一个具体的策略对象*/
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public void contextInterface() {
strategy.algorithmInterface();
}
}
示例2
可以看到，没有上下文策略模式就是普通的接口和实现了，但没有上下文尤其是需要提供一些公共功能、或者存储状态的时候，客户端会变得复杂。
/**
* 策略，定义计算报价算法的接口
*/
public interface Strategy {
/**
* 计算应报的价格
* @param goodsPrice
* @return
*/
double calcPrice(double goodsPrice);
}
/**
* 具体算法实现，为新客户或者是普通客户计算应报的价格
*/
public class NormalCustomerStrategy implements Strategy {
@Override
public double calcPrice(double goodsPrice) {
System.out.println("对于新客户或者普通客户，没有折扣");
return goodsPrice;
}
}
/**
* 具体算法实现，为新客户或者是普通客户计算应报的价格
*/
public class OldCustomerStrategy implements Strategy {
@Override
public double calcPrice(double goodsPrice) {
System.out.println("对于老客户，折扣5%");
return goodsPrice * (1 - 0.05);
}
}
/**
* 具体算法实现，为大客户计算应报的价格
*/
public class LargeCustomerStrategy implements Strategy {
@Override
public double calcPrice(double goodsPrice) {
System.out.println("对于老客户，折扣10%");
return goodsPrice * (1 - 0.1);
}
}
/**
* 价格管理，主要完成计算向客户所报价格的功能
*/
public class Price {
/**持有一个具体的策略对象*/
private Strategy strategy = null;
public Price(Strategy strategy) {
this.strategy = strategy;
}
/**
* 报价，计算对客户的报价
* @param goodsPrice
* @return
*/
public double quote(double goodsPrice) {
return this.strategy.calcPrice(goodsPrice);
}
}
public class TestClient {
public static void main(String[] args) {
Strategy strategy = new LargeCustomerStrategy();
Price ctx = new Price(strategy);
double quote = ctx.quote(1000);
System.out.println("向客户报价："+quote);
}
}
示例3
/**
* 支付工资的策略接口，公司有多种支付工资的算法
* 比如，现金、银行卡、现金价股票、现金加期权、美元支付等
*/
public interface PaymentStrategy {
/**
* 公司给某人真正支付工资
* @param ctx 支付工资的上下文，里面包含算法需要的数据
*/
void pay(PaymentContext ctx);
}
/**
* 人民币现金支付
*/
public class RMBCash implements PaymentStrategy {
@Override
public void pay(PaymentContext ctx) {
System.out.println("现在给"+ctx.getUserName()+
",人民币现金支付"+ctx.getMoney()+"元");
}
}
/**
* 美元现金支付
*/
public class DollarCash implements PaymentStrategy{
@Override
public void pay(PaymentContext ctx) {
System.out.println("现在给"+ctx.getUserName()+
",美元现金支付"+ctx.getMoney()+"元");
}
}
/**
* 支付工资的上下文，每个人的工资不同，支付工资也不同
*/
public class PaymentContext {
/**应被支付工资的人员，简单点用姓名来代替*/
private String userName = null;
/**应该被支付的工资金额*/
private double money = 0.0;
/**支付工资的方式的策略接口*/
private PaymentStrategy strategy = null;
public PaymentContext(String userName, double money, PaymentStrategy strategy) {
this.userName = userName;
this.money = money;
this.strategy = strategy;
}
public String getUserName() {
return userName;
}
public double getMoney() {
return money;
}
/**
* 立即支付工资
*/
public void payNow() {
//使用客户希望的支付策略来支付
this.strategy.pay(this);
}
}
public class TestClient {
public static void main(String[] args) {
PaymentStrategy strategyRMB = new RMBCash();
PaymentStrategy strategyDollar = new DollarCash();
PaymentContext ctx1 = new PaymentContext(
"小李",5000,strategyRMB);
ctx1.payNow();
PaymentContext ctx2 = new PaymentContext(
"Petter",1000,strategyDollar);
ctx2.payNow();
}
}
