策略模式（示例1：通过实现Comparator接口定义不同的比较策略；示例2：促销策略）-设计模式

目录

1、基本说明

2、比较一般对象大小，实现对象排序

（1）实现Comparable接口，定义了单种比较的规则

（2）实现Comparator接口，对于多种比较规则做到扩展兼容

3、另一个例子：促销策略的定义与扩展

---

1、基本说明

策略模式核心是Java多态，具体是使用面向接口的编程思想。看代码就懂。

优点在于满足了开闭原则，保证原有代码不做修改，而可以实现新的策略类实现扩展，从而满足新的需求。

可以应用于功能目的相同但性能或面向场景不同的算法动态切换选择。不同的算法就是不同的策略类。

 

2、比较一般对象大小，实现对象排序

场景：如何比较普通对象Cat的大小，从而实现对象排序。

只需要实现compareTo（）方法，定义比较的规则。

（1）实现Comparable接口，定义了单种比较的规则

代码如下：

https://github.com/phs999/DesignPatterns/blob/ae201f5da166e589c8bdad7d850a2f1e525a81a8/design_pattern/src/behavioral/strategy/example2

package behavioral.strategy.example2;

public class Cat implements Comparable{
	int weight,height;
	public Cat(int weight,int height) {
		this.weight=weight;
		this.height=height;
	}
	
	@Override
	public String toString() {
		return "Cat [weight=" + weight + ", height=" + height + "]";
	}

	@Override
	public int compareTo(Cat cat) {
		if (this.weightcat.weight) {
			return 1;
		}else {
			return 0;
		}
	}
	

}

package behavioral.strategy.example2;

public class Sorter {
	
	public static void sort(Cat [] array) {
		for (int i = 0; i < array.length-1; i++) {
			int minPos=i;
			for (int j = i+1; j < array.length; j++) {
				minPos=array[j].compareTo(array[minPos])<0 ? j:minPos;
			}
			swap(array,i,minPos);
		}
	}

	private static void swap(Cat[] array,int i,int j) {
		Cat temp=array[i];
		array[i]=array[j];
		array[j]=temp;
	}

}

（2）实现Comparator接口，对于多种比较规则做到扩展兼容

可如果比较标准变了呢？之前通过weight现在通过height决定Cat对象的大小呢，或者同时使用这两个变量决定大小呢？

为了保证开闭原则，尽量不对原有的类做更改，所以这时候就推出了策略模式，即将比较的规则策略抽象一下用接口表示，不同的比较策略都实现该接口，实现方式不同也即比较规则不同。

代码如下：

https://github.com/phs999/DesignPatterns/tree/75784fa37e011258eeb749faff9fbb0317912c11/design_pattern/src/behavioral/strategy/example2

 

package behavioral.strategy.example2;

public interface Comparator {
	int compare(T o1,T o2);

}

package behavioral.strategy.example2;

public class Sorter {
	
	public void sort(T [] array,Comparator comparator) {
		for (int i = 0; i < array.length-1; i++) {
			int minPos=i;
			for (int j = i+1; j < array.length; j++) {
				minPos=comparator.compare(array[j], array[minPos])<0 ? j:minPos;
			}
			swap(array,i,minPos);
		}
	}


	private void swap(T[] array,int i,int j) {
		T temp=array[i];
		array[i]=array[j];
		array[j]=temp;
	}

}

package behavioral.strategy.example2;


public class Main {

	public static void main(String[] args) {
		//int [] array= {3,25,2,6,8,1};
		Cat [] array= {new Cat(2, 2),new Cat(1, 1),new Cat(4, 4)};
		//Dog[] array= {new Dog(5),new Dog(3),new Dog(2),new Dog(9)};
		Sorter sorter=new Sorter();
		//定义通过speed比较dog对象的大小，通过这种形式，可以定义不同的比较策略
		sorter.sort(array,new Comparator() {
			@Override
			public int compare(Cat o1,Cat o2) {
				if (o1.heighto2.height) {
					return 1;
				}else {
					return 0;
				}
			}
			
		});

		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
	}
}

当然,为了兼容更多的对象，使用了泛型，不管什么对象，只要通过实现Comparator接口定义了比较的规则策略，就可以实现对象排序。

 

3、另一个例子：促销策略的定义与扩展

促销策略统一实现PromotionStrategy促销策略的接口，促销活动PromotionActivity需要什么促销策略就传参什么促销策略。

代码如下：

https://github.com/phs999/DesignPatterns/tree/75784fa37e011258eeb749faff9fbb0317912c11/design_pattern/src/behavioral/strategy/example1/v1

package behavioral.strategy.example1.v1;

/**
 * 促销策略接口
 * @author phs
 *
 */
public interface PromotionStrategy {
	void doPromotion();
}

package behavioral.strategy.example1.v1;

/**
 * 促销活动类
 * @author phs
 *
 */
public class PromotionActivity {
	private PromotionStrategy promotionStrategy;
	
	public PromotionActivity(PromotionStrategy promotionStrategy) {
		this.promotionStrategy=promotionStrategy;
	}
	
	public void executePromotionStrategy() {
		
		promotionStrategy.doPromotion();
	}
}

package behavioral.strategy.example1.v1;

/**
 * 满减促销策略
 * @author phs
 *
 */
public class ManJianPromotionStrategy implements PromotionStrategy{

	@Override
	public void doPromotion() {
		System.out.println("满减促销，满200减20");
	}
	

}