侧边栏壁纸
博主头像
孔子说JAVA博主等级

成功只是一只沦落在鸡窝里的鹰,成功永远属于自信且有毅力的人!

  • 累计撰写 292 篇文章
  • 累计创建 132 个标签
  • 累计收到 4 条评论

目 录CONTENT

文章目录

JAVA设计模式之策略模式

孔子说JAVA
2019-11-21 / 0 评论 / 0 点赞 / 94 阅读 / 4,911 字 / 正在检测是否收录...

1、策略模式(Strategy)的定义

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

  • 策略模式本质是:分离算法,选择实现。

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

2、模式(Strategy)优缺点

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

优点:

  1. 可以动态的改变对象的行为。
  2. 上下文和具体策略是松耦合关系。因此上下文只知道它要使用某一个实现Strategy接口类的实例,但不需要知道具体是哪一个类。
  3. 策略模式满足“开-闭原则”。当增加新的具体策略时,不需要修改上下文类的代码,上下文就可以引用新的具体策略的实例。

缺点:

  1. 客户端必须知道所有的策略类,并自行决定使用哪一个策略类。
  2. 策略模式将造成产生很多策略类。

3、模式(Strategy)适用环境

  1. JAVASE中GUI编程中,布局管理。
  2. Spring框架中,Resource接口,资源访问策略。
  3. javax.servlet.http.HttpServlet#service()。
  4. 针对同一类型问题的多种处理方式,仅仅是具体行为有差别时。
  5. 需要安全的封装多种同一类型的操作时。
  6. 出现同一抽象多个子类,而又需要使用if-else 或者 switch-case来选择时。
  7. 可以和工厂模式结合使用。

4、模式(Strategy)的结构

image-1649480838869

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

  • 环境角色(Context) :用于连接上下文,持有一个策略Strategy的引用。
  • 抽象策略角色(Strategy) :这是一个抽象角色,通常由一个接口或抽象类实现,此角色给出所有具体策略类所需的接口。
  • 具体策略角色(Concrete Strategy) :包装了相关算法或行为。

5、模式(Strategy)的应用实例

5.1 实例一:报价策略

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

  1. 普通客户小批量报价
  2. 普通客户大批量报价
  3. 老客户小批量报价
  4. 老客户大批量报价
  • 具体选用哪个报价策略,这需要根据实际情况来确定。这时候,如果我们用普通的方式来实现如下:
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));
	}
}
0

评论区