【设计模式】策略模式Strategy_01

下面我们来探讨一下设计模式里面的策略模式Strategy

首先我们在Eclipse里面创建一个名为Strategy的工程

我们在里面先写一个排序的测试类

package cn.edu.hpu.Strategy;

public class Test {
	public static void main(String[] args) {
		int[] a={9,5,3,7,1}; 
		DataSorter.sort(a); 
		DataSorter.p(a);
	}
}

这里的DataSorter.sort(a);与DataSorter.p(a);分别对数组a进行了排序和打印。

那么DataSorter怎么实现呢？其实并不难，大家不妨自己先设计一个，然后再往下看。

当你设计一个类的时候，你站在使用者的角度去考虑的话，对于这个类对外提供的一些接口你考虑起来就会更加方便一些。

PS:对于排序教大家一句简单的口诀，这个口诀可以让你记住最常见的一些排序方法(大概有7种)
"冒择路(插入)兮(希尔)快归堆",就是"贸然选择一条路可能会使你过早的进入坟墓"。(下面我们使用冒泡排序来实现排序方法)

下面我们来实现DataSorter类

package cn.edu.hpu.Strategy;


public class DataSorter {


	public static void sort(int[] a) {
		for (int i = a.length; i >0; i--) {
			for (int j = 0; j < i-1; j++) {
				if(a[j]>a[j+1]){
					swap(a,j,j+1);
				}
			}
		}
		
	}


	private static void swap(int[] a, int x, int y) {
		int temp=a[x];
		a[x]=a[y];
		a[y]=temp;
		
	}


	public static void p(int[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+" ");
		}
		System.out.println();
	}


}

我们测试一下结果：

1 3 5 7 9

发现可以进行排序。好了，我们的客户现在又说要对浮点数进行排序，怎么办？很简单，我们再以float数组为参数重载一个sort方法不就行了吗？那我再加double呢？重载方法依然可以。好了，现在客户给你出难题了，有一个Dog类，它是这样的:

package cn.edu.hpu.Strategy;

public class Dog {
	//狗的身高
	private int height;
	//狗的体重
	private int weight;
	
	public Dog(int height, int weight) {
		super();
		this.height = height;
		this.weight = weight;
	}
	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;
	}
	
}

现在客户有两只狗，希望你使用DataSorter对他们进行排序，这下该怎么办？使用一般的重载方法:（默认用狗的高度来比较狗的大小）

public static void sort(Dog[] a) {
	for (int i = a.length; i >0; i--) {
		for (int j = 0; j < i-1; j++) {
			if(a[j].getHeight()>a[j+1].getHeight()){
				swap(a,j,j+1);
			}
		}
	}
	
}


private static void swap(Dog[] a, int x, int y) {
	Dog temp=a[x];
	a[x]=a[y];
	a[y]=temp;
	
}


public static void p(Dog[] a) {
	for (int i = 0; i < a.length; i++) {
		System.out.print(i+"号狗的高度:"+a[i].getHeight());
	}
	System.out.println();
}

测试:
0号狗的高度:1
1号狗的高度:3
2号狗的高度:5


现在我们的DataSorter类既可以排序int类，又可以满足float、double和Dog类，是不是变得很高级呢？不要飘飘然，现在可怕的用户又来改需求了，他们要求你来对Cat进行排序！！！尼玛！

为了防止用户进一步的设置排序要求，我们不能再使用之前的重载方法这种行为了，因为人的欲望是无限的，要求什么就写什么样的排序方法会累死的...所以我们不能这么写。

我们可以写一个算法，然后可以使它重用。无论使用什么样的参数传进去我们都能对他们进行排序。这样一个方法是不是很神奇？参数我们就设定为Object数组就可以了呗，那么我们考虑一下，这样的一个方法它的要点在哪里？对，就是如何判定其中的两个元素的对比方法(如谁大谁小？使用哪个参数进行比较等)。设个事儿就比较麻烦了......

问题就归结于:我们怎么样去判断一个Object数组里面的元素到底谁大谁小。
我们来想想，既然比较大小的方式，现在不是能确定的，那么干脆我就交给它的子类去确定，交给将来去扩展好了。一谈到拓展，我们就会使用到多态。

下面我们讲一其中个实现方式:
再写一个Cat类，有一个"饭量"的属性

package cn.edu.hpu.Strategy;

public class Cat {
	//猫的饭量
	private int food;
	
	public Cat(int food) {
		super();
		this.food = food;
	}


	public int getFood() {
		return food;
	}


	public void setFood(int food) {
		this.food = food;
	}
	
}

我们写一个Comparable接口，只要实现这个接口的类都表示可以被排序，并且必须要实现其中的比较方法：

package cn.edu.hpu.Strategy;


public interface Comparable {
	/*实现这个接口的对象使用这个方法进行比较时，
	*返回1是比那个对象大，返回0是相等，返回-1是比那个对象小*/
	public int compareTo(Object o);
}

下面让狗去实现这个接口

package cn.edu.hpu.Strategy;

public class Dog implements Comparable{
	//狗的身高
	private int height;
	//狗的体重
	private int weight;
	
        //省略部分代码。。。
	
	@Override
	public int compareTo(Object o) {
		if(o instanceof Dog){
			Dog d=(Dog)o;
			if(this.getHeight()>d.getHeight()) return 1;
			else if(this.getHeight()<d.getHeight()) return -1;
			else return 0;
		}
		//不属于Dog类，不能进行比较，这里要抛异常的，为了简单起见，返回一个-100
		return -100;
	}
	
}

这个类进行比较的方法就可以这么写了：

<pre name="code" class="java">public static void sort(Object[] a) {
	for (int i = a.length; i >0; i--) {
		for (int j = 0; j < i-1; j++) {
			Comparable o1=(Comparable)a[j];
			Comparable o2=(Comparable)a[j+1];
			if(o1.compareTo(o2)==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]+" ");
	}
	System.out.println();
}

改写Dog的toString方法

@Override
public String toString() {
	return this.getHeight()+"|"+this.getWeight();
}

测试：

package cn.edu.hpu.Strategy;


public class Test {
	public static void main(String[] args) {


		Dog[] dogs={new Dog(3,3),new Dog(5,5),new Dog(1,1)};
		DataSorter.sort(dogs); 
		DataSorter.p(dogs);
	}
}

测试结果:
1|1 3|3 5|5 

下面我们用同样的方法去对Cat进行排序：
首选是Cat实现Comparable接口及相应排序方法

package cn.edu.hpu.Strategy;


public class Cat implements Comparable{
	//猫的饭量
	private int food;
	
	public Cat(int food) {
		super();
		this.food = food;
	}


	public int getFood() {
		return food;
	}


	public void setFood(int food) {
		this.food = food;
	}


	@Override
	public int compareTo(Object o) {
		if(o instanceof Cat){
			Cat c=(Cat)o;
			if(this.getFood()>c.getFood()) return 1;
			else if(this.getFood()<c.getFood()) return -1;
			else return 0;
		}
		//不属于Cat类，不能进行比较，这里要抛异常的，为了简单起见，返回一个-100
		return -100;
	}


	@Override
	public String toString() {
		return this.getFood()+" ";
	}
}

然后测试:

package cn.edu.hpu.Strategy;


public class Test {
	public static void main(String[] args) {
		
		Cat[] cats={new Cat(21),new Cat(15),new Cat(9)};
		DataSorter.sort(cats); 
		DataSorter.p(cats);
	}
}

测试结果：
9  15  21  

我们发现我们写的DataSorter类竟然具备这么一种能力:它的sort算法写了一次之后，这辈子都不用再变了，而且它对于不同类型的参数都能够进行排序。这个可扩展性就好多了，当然他有条件，只要进行排序的类，都是实习了Comparable接口的类。

定义Comparable接口的意义：
(1)定义这个类到底能不能比较大小
(2)为了我们写的一些算法我们能够重复使用

Java在java.lang包中含有了一个Comparable接口，里面也有一个ComparaTo方法，跟我们写的差不多。里面还使用到了泛型。我们写的接口就模拟了JDK给我们的接口。

刚刚只是热身，我们下一篇总结继续探讨策略模式。

转载请注明出处：http://blog.csdn.net/acmman/article/details/46634355