设计模式——策略模式

最新推荐文章于 2021-10-29 13:02:45 发布

哈喽羊

最新推荐文章于 2021-10-29 13:02:45 发布

阅读量204

点赞数 2

分类专栏：设计模式

本文链接：https://blog.csdn.net/qq_36582604/article/details/82634953

版权

设计模式专栏收录该内容

9 篇文章 0 订阅

订阅专栏

本文主要参考资料：《设计模式之禅》

本文主要目录为：
1）案例

2）策略模式解决

3）策略模式模式的定义

4）总结

1. 案例

看过三国的人就知道，当时赵云陪刘备去吴国娶媳妇的时候，诸葛亮给了刘备三个妙计：找乔国老帮忙（走后门），求吴国太放行（诉苦），孙夫人断后。这三个妙计有一个相似之处，他们都是告诉赵云要怎么执行，也就是说这三个计谋都有一个方法是执行，具体执行什么内容，每个计谋当然不同，分析到这里，我们是不是有这样一个思路：三个妙计应该实现的是同一个接口？聪明，我们来看类图

我们来看代码：

妙计接口，定义了一个方法operate，每个妙计都是可执行的。

public interface IStrategy {
	
	//每个锦囊妙计都是一个可执行的算法
	public void operate();

}

然后时三个妙计

public class BackDoor implements IStrategy {

	public void operate() {
		System.out.println("找乔国老帮忙，让吴国太给孙权施加压力");
	}
}

public class GivenGreenLight implements IStrategy {

	public void operate() {
		System.out.println("求吴国太开个绿灯,放行！");
	}
}

public class BlockEnemy implements IStrategy {

	public void operate() {
		System.out.println("孙夫人断后，挡住追兵");
	}
}

2. 策略模式解决

三个妙计都有了，还缺少两个配角：第一就是装三个妙计的精囊，第二就是妙计的执行人赵云。类图如下：

我们在类图中增加一个Context的封装类（精囊），其作用用来装三个策略，方便赵云使用，代码如下：

public class Context {
	//构造函数，你要使用那个妙计
	private IStrategy straegy;
	public Context(IStrategy strategy){
		this.straegy = strategy;
	}
	
	//使用计谋了，看我出招了
	public void operate(){
		this.straegy.operate();
	}
}

通过构造函数把策略传进来，然后用operate方法来执行相关的策略方法。

最后我们使用赵云来执行策略

public class ZhaoYun {
	 //赵云出场了，他根据诸葛亮给他的交代，依次拆开妙计
	public static void main(String[] args) {
		Context context;
		
		//刚刚到吴国的时候拆第一个
		System.out.println("---刚刚到吴国的时候拆第一个---");
		context = new Context(new BackDoor()); //拿到妙计
		context.operate();  //拆开执行
		System.out.println("\n");
		
		//刘备乐不思蜀了，拆第二个了
		System.out.println("---刘备乐不思蜀了，拆第二个了---");
		context = new Context(new GivenGreenLight());
		context.operate();  //执行了第二个锦囊了
		System.out.println("\n");
		
		//孙权的小兵追了，咋办？拆第三个
		System.out.println("---孙权的小兵追了，咋办？拆第三个---");
		context = new Context(new BlockEnemy());
		context.operate();  //孙夫人退兵
		System.out.println("\n");	
	}
}

3. 策略模式模式的定义

定义：Define a family of algorithms, encapsulate each one, and make them interchangeable.（定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。）

策略模式的通用类图如下图：

策略模式使用的就是面向对象的继承和多态机制，非常容易理解和掌握，我们再来看策略模式的三个角色。

Context角色：起承上启下封装作用，屏蔽高层模块对策略、算法的直接访问，封装可能存在的变化。
Strategy抽象策略角色：策略、算法家族的抽象，通常为接口，定义每个策略或算法必须具有的方法和属性。
ConcreteStrategy具体策略角色：实现抽象策略中的操作，该类含有具体的算法。

我们来看看策略模式的通用源码：

抽象的策略角色

public interface Strategy {
	
	//策略模式的运算法则
	public void doSomething();
}

具体的策略角色：

public class ConcreteStrategy1 implements Strategy {

	public void doSomething() {
		System.out.println("具体策略1的运算法则");
	}
}

public class ConcreteStrategy2 implements Strategy {

	public void doSomething() {
		System.out.println("具体策略2的运算法则");
	}
}

策略模式的重点就是封装角色，它是借用代理模式的思路，那它和代理模式有什么差别呢？差别就是策略模式的封装角色和被封装的策略类不是同一个接口，如果是同一个接口那就成为代理模式了

封装角色的代码：

public class Context {
	//抽象策略
	private Strategy strategy = null;
	
	//构造函数设置具体策略
	public Context(Strategy _strategy){
		this.strategy = _strategy;
	}
	
	//封装后的策略方法
	public void doAnythinig(){
		this.strategy.doSomething();
	}
}

高层模块的调用非常简单，知道要用哪个策略，产生出它的对象，然后放到封装角色中就完成任务了，代码如下：

4, 总结

1.策略模式的优点

算法可以自由切换。
避免使用多重条件判断。
扩展性良好。

2.策略模式的缺点

策略类数量增多：每一个策略都是一个类，复用的可能性很小，类数量增多。
所有的策略类都需要对外暴露。上层模块必须知道有哪些策略，然后才能决定使用哪一种策略，这与迪米特法则是相违背的，我只是想使用一个策略，我凭什么就要了解这个策略呢？那要你的封装类还有什么意义？这是原装策略模式的一个缺点，幸运的是，我们可以使用其他模式来修正这个缺陷，如果工厂方法模式、代理模式或享元模式。

3.策略模式的使用场景