设计模式之策略模式

1.策略模式定义

• 策略模式（Strategy Pattern）中，定义算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户
• 这算法体现了几个设计原则

1. 把变化的代码从不同的代码中分离出来
2. 针对接口编程而不是具体类（定义了策略接口）
3. 多用组合.聚合。少用继承（客户通过组合方式使用策略）

•  客户context有成员变量strategy或者其他的策略接口，具体使用哪个策略，可以在构造器中指定

---

 2.策略模式应用（解决鸭子问题）

FlyBehavior.java

package strategy;

public interface FlyBehavior {

	void fly();
}

GoodFlyBehavior.java

package strategy;

public class GoodFlyBehavior implements FlyBehavior{

	@Override
	public void fly() {
	  System.out.println("飞翔技术高超!!!");
	}

}

BadFlyBehavior.java

package strategy;

public class BadFlyBehavior implements FlyBehavior {

	@Override
	public void fly() {
		System.out.println("飞翔技术一般");
	}

}

NoFlyBehavior.java

package strategy;

public class NoFlyBehavior implements FlyBehavior {

	@Override
	public void fly() {
		System.out.println("不会飞翔");
	}

}

Duck.java

package strategy;

public abstract class Duck {

//	属性。策略接口
	FlyBehavior flyBehavior;
	
//	其他属性接口--
	
	public Duck() {
		
	}
	
//	显示鸭子信息
	public abstract void display();
	
	public void quack() {
		System.out.println("鸭子嘎嘎叫.....");
	}
	
	public void swim() {
		System.out.println("鸭子会游泳......");
	}
	
	public void fly() {
//		改进
		if(flyBehavior!=null) {
			flyBehavior.fly();
		}
	}
	
	public void setFlyBehavior(FlyBehavior flyBehavior) {
		this.flyBehavior = flyBehavior;
	}
}

WildDuck.java

package strategy;

public class WildDuck  extends Duck{

//	构造器传入FlyBehavior的对象
	public WildDuck() {
		flyBehavior=new GoodFlyBehavior();
	}

	@Override
	public void display() {
		System.out.println("这是野鸭");
	}
	
	
	
	

}

PekingDuck.java

package strategy;

public class PekingDuck  extends Duck{

	public PekingDuck() {
		flyBehavior=new BadFlyBehavior();
	}
	
	@Override
	public void display() {
		System.out.println("这是北京鸭");
	}
	
	

}

ToyDuck.java

package strategy;

public class ToyDuck extends Duck{

	public ToyDuck() {
		flyBehavior=new NoFlyBehavior();
	}
	
	@Override
	public void display() {
		System.out.println("这是玩具鸭");
	}

}

Client.java

package strategy;

public class Client {

	public static void main(String[] args) {
		
		WildDuck wildDuck = new WildDuck();
		wildDuck.fly();
		
		ToyDuck toyDuck = new ToyDuck();
		toyDuck.fly();
		
		PekingDuck pekingDuck = new PekingDuck();
		pekingDuck.fly();
		
//		动态改变某个对象的行为,北京鸭不能飞
		pekingDuck.setFlyBehavior(new NoFlyBehavior());
		System.out.println("北京鸭实际飞翔行为：");
		pekingDuck.fly();
	}
}

控制台

飞翔技术高超!!!
不会飞翔
飞翔技术一般
北京鸭实际飞翔行为：
不会飞翔

---

3.策略模式在JDK-Arrays应用的源码分析

package strategy;

import java.util.Arrays;
import java.util.Comparator;

public class Test {

	public static void main(String[] args) {
		
//		数组
		Integer [] data= {9,1,2,8,4,3};
		
//		实现了comparator 接口（策略接口）
//		对象new Comparator<Integer>()就是实现策略接口的对象
//		public int compare(Integer o1, Integer o2)指定具体的处理方式
		Comparator<Integer> comparator = new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				if(o1>o2) {
					return 1;
				}else {
					return -1;
				}
			
			}
		};
		
//		方式一
		Arrays.sort(data,comparator);
		System.out.println(Arrays.toString(data));
		
		
		
//		方式二：使用lambda表达式
		Integer  []data2= {19,11,12,18,14,13};
		Arrays.sort(data2,(var1,var2) ->{
			if(var1.compareTo(var2)>0) {
				return 1;
			}else {
				return -1;
			}
		});
		
		System.out.println(Arrays.toString(data2));
		
		
		
		
	}
}

控制台

[1, 2, 3, 4, 8, 9]
[11, 12, 13, 14, 18, 19]

---

4.策略模式总结

• 策略模式的关键是分析项目中变化部分与不变部分
• 策略模式的核心思想是:多用组合/聚合，少用继承。用行为类组合，而不是行为的继承，更有弹性
• 体现了对修改关闭，对外扩展原则。客户端增加行为，不用修改原有代码，只有添加一种策略就可以。避免使用多重转移语句（if...else）
• 提供了可以替换继承关系的方法，策略模式将算法封装在独立的Strategy类中，可以独立于Context改变。易于切换，易于理解，易于扩展

每增加一个策略就要增加一个类，当策略过多会导致类数量很大