首页 > 代码库 > java设计模式 -------- 行为模式 之 策略模式(1)

java设计模式 -------- 行为模式 之 策略模式(1)

[本文是自己学习所做笔记,欢迎转载,但请注明出处:http://blog.csdn.net/jesson20121020]

我们实现一个排序类,使其可以实现对数组中元素进行排序,以及打印数组的功能。如下所示,可以这样设计:

DataSorter.java

/**
 * 排序类
 * 
 * @author jesson
 * 
 */
public class DataSorter {
	/**
	 * 冒泡排序方法
	 * 
	 * @param a
	 */
	public static void bubbleSort(int[] a) {
		for (int i = a.length - 1; i >= 1; i--) {
			for (int j = 0; j < i; j++) {
				if (a[j] > a[j + 1]) {
					swap(a, j, j + 1);
				}
			}
		}
	}

	/**
	 * 交换两个数据
	 * 
	 * @param a
	 *            数组
	 * @param x
	 *            数组下标1
	 * @param y
	 *            数组下标2
	 */
	private static void swap(int[] a, int x, int y) {
		// TODO Auto-generated method stub
		int temp = a[x];
		a[x] = a[y];
		a[y] = temp;
	}

	/**
	 * 打印数组
	 * 
	 * @param a
	 */
	public static void print(int[] a) {
		for (int i = 0; i < a.length; i++)
			System.out.print(a[i] + " ");
		System.out.println();
	}

}</span>
Test.java
/**
 * 测试类
 * @author jesson
 *
 */
public class Test {
	public static void main(String[] args) {
		int[] a = new int[]{9,8,2,4,5,6,7};
		DataSorter.print(a);
		DataSorter.bubbleSort(a);
		DataSorter.print(a);
	}
}
</span>

  通过这个DataSorter可以实现将数组进行冒泡排序,以及输出数组的功能。

  

  但是现在,需求变了,我们不仅要实现对整数数组进行排序,还要对float型和double型数组进行排序,当然了,想必大家也想到了,这可以重载排序方法,以实现不同类型的数组进行排序,是,这是一种方法。但是,现在需求又变了,不仅要实现对这些常规类型的数组进行排序,还要对其他自定义的一些类进行排序,如,我们要对Cat进行排序,并输出,这是怎么做呢??想必大家很容易想到用重载,如下,可以这样写:

Cat.java

/**
 * Cat类 有属性身高,体重及toString()方法
 * 
 * @author jesson
 * 
 */
public class Cat {
	private int height; // 身高
	private int weight; // 体重

	public Cat(int height, int weight) {
		// TODO Auto-generated constructor stub
		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;
	}

	/**
	 * 重写toString()方法
	 */
	@Override
	public String toString() {
		return this.getHeight() + "|" + this.getWeight();
	}

}
</span>
DataSorter.java

/**
 * 排序类
 * 
 * @author jesson
 * 
 */
public class DataSorter {

	/**
	 * 冒泡排序方法
	 * 
	 * @param Cat类型数组
	 */
	public static void bubbleSort(Cat[] a) {
		for (int i = a.length - 1; i >= 1; i--) {
			for (int j = 0; j < i; j++) {
				if (a[j].getHeight() > a[j + 1].getHeight()) {
					swap(a, j, j + 1);
				}
			}
		}
	}

	/**
	 * 冒泡排序方法
	 * 
	 * @param a
	 *            整数数组
	 */
	public static void bubbleSort(int[] a) {
		for (int i = a.length - 1; i >= 1; i--) {
			for (int j = 0; j < i; j++) {
				if (a[j] > a[j + 1]) {
					swap(a, j, j + 1);
				}
			}
		}
	}

	/**
	 * 交换两个数据
	 * 
	 * @param a
	 *            数组
	 * @param x
	 *            数组下标1
	 * @param y
	 *            数组下标2
	 */
	private static void swap(Cat[] a, int x, int y) {
		// TODO Auto-generated method stub
		Cat temp = a[x];
		a[x] = a[y];
		a[y] = temp;
	}

	/**
	 * 交换两个数据
	 * 
	 * @param a
	 *            数组
	 * @param x
	 *            数组下标1
	 * @param y
	 *            数组下标2
	 */
	private static void swap(int[] a, int x, int y) {
		// TODO Auto-generated method stub
		int temp = a[x];
		a[x] = a[y];
		a[y] = temp;
	}

	/**
	 * 打印数组
	 * 
	 * @param a
	 *            Cat类型数组
	 */
	public static void print(Cat[] a) {
		for (int i = 0; i < a.length; i++)
			System.out.print(a[i] + " ");
		System.out.println();
	}

	/**
	 * 打印数组
	 * 
	 * @param a
	 *            int类型数组
	 */
	public static void print(int[] a) {
		for (int i = 0; i < a.length; i++)
			System.out.print(a[i] + " ");
		System.out.println();
	}

}
Test.java 

/**
 * 测试类
 * @author jesson
 *
 */
public class Test {
	public static void main(String[] args) {
		//int[] a = new int[]{9,8,2,4,5,6,7};
		Cat[] a = {new Cat(5,5),new Cat(3,3),new Cat(1,1)};
		DataSorter.print(a);
		DataSorter.bubbleSort(a);
		DataSorter.print(a);
	}
}
   这样,不仅可以对int类型的数组进行冒泡排序,还可以对Cat类型的数组进行排序。

   现在问题又来了,需求变化,要实现对Dog类型的数组进行排序,该怎么办呢,当然了,还是可以用上面重载的方法,但是太麻烦了,如果以后又要对其他类型的数组进行排序,岂不是又要重载排序方法,所以,这种方法不可取。那么,如何用一个统一的排序方法,对所有类型的数组都能进行排序呢?答案是肯定的。

   为了实现对所有的类都能进行排序,所以需要定义比较的规则,所以要比较的类首先是可以进行比较的,也就是这些待比较的所有类都有一个共同的特征,即可比较,因此,我们定义一个Comparable接口,让需要排序的类都实现这个接口,这样,我们再将DataSorter类中的排序方法中对Cat类进行排序的代码进行修改,类型定义为Object,这样,所有的类都可进行排序了,具体如下:

Comparable.java

/**
 * 可比较接口
 * 定义了一个比较方法
 * @author jesson
 *
 */
public interface Comparable {
	public int compareTo(Object o);
}

Cat.java

/**
 * Cat类 有属性身高,体重及toString()方法
 * 
 * @author jesson
 * 
 */
public class Cat implements Comparable {
	private int height; // 身高
	private int weight; // 体重

	public Cat(int height, int weight) {
		// TODO Auto-generated constructor stub
		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;
	}

	/**
	 * 重写toString()方法
	 */
	@Override
	public String toString() {
		return this.getHeight() + "|" + this.getWeight();
	}

	/**
	 * 实现Comparable接口的compareTO方法 返回1:当前的比参数中的对象大 返回-1:当前的比参数中的对象小 返回0:
	 * 当前的和参数中的对象相等
	 */
	@Override
	public int compareTo(Object o) {
		// TODO Auto-generated method stub
		Cat cat = (Cat) o;
		if (this.height > cat.getHeight())
			return 1;
		else if (this.height < cat.getHeight())
			return -1;
		else
			return 0;

	}
}
Dog.java

public class Dog implements Comparable {
	private int food;

	public Dog(int food) {
		super();
		// TODO Auto-generated constructor stub
		this.food = food;
	}

	public int getFood() {
		return food;
	}

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

	@Override
	public int compareTo(Object o) {
		// TODO Auto-generated method stub
		Dog dog = (Dog) o;
		if (this.food > dog.getFood())
			return 1;
		else if (this.food < dog.getFood())
			return -1;
		else
			return 0;
	}
	
	@Override
	public String toString(){
		return this.food + "";
	}
}
DataSorter.java

/**
 * 排序类
 * 
 * @author jesson
 * 
 */
public class DataSorter {

	
	
	
	/**
	 * 冒泡排序方法
	 * 
	 * @param Cat类型数组
	 */
	public static void bubbleSort(Object[] a) {
		for (int i = a.length - 1; i >= 1; i--) {
			for (int j = 0; j < i; j++) {
				Comparable o1 = (Comparable)a[j];
				Comparable o2 = (Comparable)a[j+1];
				if (o1.compareTo(o2) == 1) {
					swap(a, j, j + 1);
				}
			}
		}
	}

	/**
	 * 冒泡排序方法
	 * 
	 * @param a
	 *            整数数组
	 */
	public static void bubbleSort(int[] a) {
		for (int i = a.length - 1; i >= 1; i--) {
			for (int j = 0; j < i; j++) {
				if (a[j] > a[j + 1]) {
					swap(a, j, j + 1);
				}
			}
		}
	}

	/**
	 * 交换两个数据
	 * 
	 * @param a
	 *            Object类型数组
	 * @param x
	 *            数组下标1
	 * @param y
	 *            数组下标2
	 */
	private static void swap(Object[] a, int x, int y) {
		// TODO Auto-generated method stub
		Object temp = a[x];
		a[x] = a[y];
		a[y] = temp;
	}

	/**
	 * 交换两个数据
	 * 
	 * @param a
	 *            数组
	 * @param x
	 *            数组下标1
	 * @param y
	 *            数组下标2
	 */
	private static void swap(int[] a, int x, int y) {
		// TODO Auto-generated method stub
		int temp = a[x];
		a[x] = a[y];
		a[y] = temp;
	}

	/**
	 * 打印数组
	 * 
	 * @param a
	 *            Object类型数组
	 */
	public static void print(Object[] a) {
		for (int i = 0; i < a.length; i++)
			System.out.print(a[i] + " ");
		System.out.println();
	}

	/**
	 * 打印数组
	 * 
	 * @param a
	 *            int类型数组
	 */
	public static void print(int[] a) {
		for (int i = 0; i < a.length; i++)
			System.out.print(a[i] + " ");
		System.out.println();
	}

}
Test.java

/**
 * 测试类
 * @author jesson
 *
 */
public class Test {
	public static void main(String[] args) {
		//int[] a = new int[]{9,8,2,4,5,6,7};
		//Cat[] a = {new Cat(5,5),new Cat(3,3),new Cat(1,1)};
		Dog[] a = {new Dog(3),new Dog(2),new Dog(6)};
		DataSorter.print(a);
		DataSorter.bubbleSort(a);
		DataSorter.print(a);
	}
}
   这样修改之后,DataSorter不仅可以对Cat类型的数组进行排序,也可以对Dog类型的数组进行排序,而且,这时,如果需要对新定义的类也能进行排序的话,只要让其实现Comparable接口,并具体实现compareTo()方法,就可以不用再改动DataSorter类,就可以直接用DataSorter对新定义的类型的数组进行排序,达到了代码重用的目的。

java设计模式 -------- 行为模式 之 策略模式(1)