策略模式

说明：本文版本有二个版本，每个版本都不断深化的

一、模式的提出

它定义了算法家族，分别封装起来， 让他们之间可以互相替换，此模式让算法变化，不会影响到使用算法的客户。

当不同的行为堆砌在一个类中时，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类消除条件语句。策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法的完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。

二、业务背景

 对狗和猫相关信息如何进行排序？

三、UML图

四、代码详解

所有类型比较的公共接口

package cn.com.hewen.strategy;
/**
 * 所有类型排序的一个公共接口，一个类型要进行排序必须要实现该接口，
 * 比如：对猫的身高和狗的食量进行排序，这两个类都要实现该接口
 * @author Administrator
 *
 */
public interface Comparable {
	public int compareTo(Object o);
}

 对狗食量进行排序

package cn.com.hewen.strategy;
/**
 * 对狗的食量大小进行比较，模仿JDK实现comparable接口
 * @author Administrator
 *
 */
public class Dog implements Comparable{
	private int height;
	private int foodWeight;

	public Dog(int height, int foodWeight) {
		this.height = height;
		this.foodWeight = foodWeight;
	}
	/**
	 * 狗的食量进行比较
	 */
	
	public int compareTo(Object o) {
		if(o instanceof Dog){
			Dog dog=(Dog)o;
			if(this.foodWeight>dog.foodWeight)
				return 1;
		}
		return 0;
	}

	public int getHeight() {
		return height;
	}

	public void setHeight(int height) {
		this.height = height;
	}

	public int getFoodWeight() {
		return foodWeight;
	}

	public void setFoodWeight(int foodWeight) {
		this.foodWeight = foodWeight;
	}

	@Override
	public String toString() {
		return "狗的食量排列顺序是"+this.foodWeight+"|"+this.height;
	}

}

猫的身高进行排序

package cn.com.hewen.strategy;

public class Cat implements Comparable{
	private int height;//猫的高度
	private int weight;//猫的重量

	public Cat(int height, int weight) {
		this.height = height;
		this.weight = weight;
	}
/**
 * Object 对象进行比较猫的大小
 * return 如果本对象大于比较的对象的高度就返回1
 */
	public int compareTo(Object o) {
		if (o instanceof Cat) {//对象转化的时候最好判断一下是否是该对象
			Cat cat = (Cat) o;
			if (this.height > cat.height)
				return 1;
		}
		return 0;
	}

	public int getHeight() {
		return height;
	}

	public void setHeight(int height) {
		this.height = height;
	}

	public int getWeight() {
		return weight;
	}

	public void setWeight(int weight) {
		this.weight = weight;
	}

	@Override
	public String toString() {
		return "猫的高度排列顺序："+this.height+"|"+this.weight;
	}
	

}

冒泡排序的类

package cn.com.hewen.strategy;
/**
 * 大小的比较进行冒泡排序
 * @author Administrator
 *
 */
public class DateSorter {
/**
 * 冒泡算法
 * @param a
 */
	public static void sort(Comparable[] a) {
		for(int i=a.length;i>0;i--)
			for(int j=0;j<a.length-1;j++){
				if(a[j].compareTo(a[j+1])==1)
						swap(a,j,j+1);
			}
	}
	/**
	 * 数组的顺序换顺序
	 * @param a 数组
	 * @param x 数组元素
	 * @param y 数组元素
	 */

	private static void swap(Object[] a, int x, int y) {
		Object temp=a[x];
		a[x]=a[y];
		a[y]= temp;
	}
	/**
	 * 打印数组中的相关信息
	 * @param a数组
	 */
	public static void p(Object[] a) {
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+" ");
		}
	}

	
}

 客户端的代码

package cn.com.hewen.strategy;
/**
 * 排序口诀
 * 冒择插入兮（希）快归堆
 * @author Administrator
 *
 */
public class Test {
	public static void  main(String[] args){
		//		int[] a={9,4,7,5,1,6};
		Comparable[] a={new Cat(9,9),new Cat(4,4),new Cat(7,7),new Cat(1,1),new Cat(5,5)};
//		Comparable[] a={new Dog(20,20),new Dog(3,3),new Dog(32,32),new Dog(7,7),new Dog(17,17)};
		DateSorter.sort(a);
		DateSorter.p(a);
	}
}

 运行的结果

猫的高度排列顺序：1|1 猫的高度排列顺序：4|4 猫的高度排列顺序：5|5 猫的高度排列顺序：7|7 猫的高度排列顺序：9|9

   业务背景添加新的需求：如果需要对猫的身高、猫的体重、狗的身高、狗的食量进行排序那应该如何处理这样的变化？

解决方案：添加一个简单的工厂方法，来判断用户是根据什么信息排序？

代码详解 

新添加一个接口：什么类型具体信息的比较的通用接口

package cn.com.hewen.strategy;
/**
 * 什么类型具体信息的比较的通用接口，
 * 如要实现按照猫的体重进行排序必须要实现给接口
 * @author Administrator
 *
 */
public interface Comparator {
	public int compare(Object o1, Object o2);
}

 所有具体信息的比较类型排序必须实现Comparator

package cn.com.hewen.strategy;
/**
 * 按照猫的身高进行比较
 * @author Administrator
 *
 */
public class CatHeightCompare implements Comparator {

	public int compare(Object o1, Object o2) {
		if(o1 instanceof Cat && o2 instanceof Cat){
			Cat cat1=(Cat)o1;
			Cat cat2=(Cat)o2;
			if(cat1.getHeight()>cat2.getHeight())
				return 1;
		}
		return 0;
	}

}

package cn.com.hewen.strategy;
/**
 * 按照猫的重量进行排序
 * @author Administrator
 *
 */
public class CatWeightCompare implements Comparator {

	public int compare(Object o1, Object o2) {
		if(o1 instanceof Cat && o2 instanceof Cat){
			Cat cat1=(Cat)o1;
			Cat cat2=(Cat)o2;
			if(cat1.getWeight()>cat2.getWeight())
				return 1;
		}
		return 0;
	}

	
}

package cn.com.hewen.strategy;

public class DogFoodCompare implements Comparator{

	public int compare(Object o1, Object o2) {
		if(o1 instanceof Dog && o2 instanceof Dog){
			Dog dog1=(Dog)o1;
			Dog dog2=(Dog)o2;
			if(dog1.getFoodWeight()>dog2.getFoodWeight())
				return 1;
		}
		return 0;
	}

}

什么类型的比较的通用接口，定义一个类型的排序派实现该接口 

package cn.com.hewen.strategy;
/**
 * 什么类型的比较的通用接口，
 * 定义一个类型的排序派实现该接口
 * @author Administrator
 *
 */
public interface Comparable {
	public int compareTo(Object o1);
}

 实现一个类型的排序的该接口

package cn.com.hewen.strategy;

public class Cat implements Comparable{
	private int height;
	private int weight;
	private String compareName;
	/**
	 * 客户调用的构造函数
	 * @param height
	 * @param weight
	 * @param compareName 按照猫的什么信息进行比较
	 */
	public Cat(int height, int weight,String compareName) {
		this.height = height;
		this.weight = weight;
		this.compareName=compareName;
	}
	
	public int compareTo(Object o) {
		/**
		 * 这个按什么类型进行比较的判断就转交给比较工厂做判断
		 */
		return CompareFactory.getCompareTypeClass(compareName).compare(this,o);
	}

	public int getHeight() {
		return height;
	}

	public void setHeight(int height) {
		this.height = height;
	}

	public int getWeight() {
		return weight;
	}

	public void setWeight(int weight) {
		this.weight = weight;
	}

	@Override
	public String toString() {
			return compareName+this.height+"|"+this.weight;
	}

	public String getCompareName() {
		return compareName;
	}

	public void setCompareName(String compareName) {
		this.compareName = compareName;
	}


}

package cn.com.hewen.strategy;

public class Dog implements Comparable{
	private int height;//狗的身高
	private int foodWeight;//狗的食量
	private String compareName;//按照什么信息进行排序
	public Dog(int height, int foodWeight,String compareName) {
		this.height = height;
		this.foodWeight = foodWeight;
		this.compareName=compareName;
	}

	public int compareTo(Object o) {
		/*
		 * 这个按什么类型进行比较的判断就转交给比较工厂做判断
		 */
		return CompareFactory.getCompareTypeClass(compareName).compare(this,o);
	}

	public int getHeight() {
		return height;
	}

	public void setHeight(int height) {
		this.height = height;
	}

	public int getFoodWeight() {
		return foodWeight;
	}

	public void setFoodWeight(int foodWeight) {
		this.foodWeight = foodWeight;
	}

	@Override
	public String toString() {
		return compareName+this.foodWeight+"|"+this.height;
	}

	public String getCompareName() {
		return compareName;
	}

	public void setCompareName(String compareName) {
		this.compareName = compareName;
	}

}

 一个通用的冒泡排序算法

package cn.com.hewen.strategy;

public class DateSorter {

	public static void sort(Comparable[] a) {
		for(int i=a.length;i>0;i--)
			for(int j=0;j<a.length-1;j++){
				if(a[j].compareTo(a[j+1])==1)
						swap(a,j,j+1);
			}
	}
	
	private static void swap(Object[] a, int x, int y) {
		Object temp=a[x];
		a[x]=a[y];
		a[y]= temp;
	}
	public static void p(Object[] a) {
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+" ");
		}
	}
}

 根据客户的需要，什么类型是按照什么信息(compareName)进行排序

package cn.com.hewen.strategy;
/**
 * 根据客户的需要，什么类型是按照什么信息(compareName)进行排序
 * 比如 按照猫的体重还是按照猫的身高进行排序
 * @author Administrator
 *
 */
public class CompareFactory{
	private static Comparator comparator=null;//具体类型的具体信息比较器的接口
	
	public static Comparator getCompareTypeClass(String compareName){
		if(compareName.equals("按猫的重量")){
			return comparator=new CatWeightCompare();
		}else if(compareName.equals("按猫的身高")){
			return comparator=new CatHeightCompare();
		}if(compareName.equals("按狗的食量")){
			return comparator=new DogFoodCompare();
		}
		return null;
	}

	
}

 客户测试类

package cn.com.hewen.strategy;
/**
 * 排序口诀
 * 冒择插入兮（希）快归堆
 * @author Administrator
 *
 */
public class Test {
	public static void  main(String[] args){
		//		int[] a={9,4,7,5,1,6};
		/*高度 ，重量*/
		Comparable[] a={new Cat(9,3,"按猫的重量"),new Cat(4,2,"按猫的重量"),
				new Cat(7,1,"按猫的重量"),new Cat(1,4,"按猫的重量"),new Cat(5,9,"按猫的重量")};
//		Comparable[] a={new Dog(20,20,"按狗的食量"),new Dog(3,3,"按狗的食量"),
//				new Dog(32,32,"按狗的食量"),new Dog(7,7,"按狗的食量"),new Dog(17,17,"按狗的食量")};
		DateSorter.sort(a);
		DateSorter.p(a);
	}
}

按猫的重量7|1 按猫的重量4|2 按猫的重量9|3 按猫的重量1|4 按猫的重量5|9