下面我们来探讨一下设计模式里面的策略模式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