java設計模式 -------- 行爲模式 之 策略模式(3)

[本文是自己學習所做筆記，歡迎轉載，但請註明出處：http://blog.csdn.net/jesson20121020]

　　繼續上節內容，到目前爲至，其實已經很好的實現了對各種類型的數組進行排序，而且，擴展性也不錯，我們定義的比較器接口，可以適應不同的比較策略，但是我們注意到一點，在實現compare()方法時，我們需要向下轉型，將Object類型轉換成具體的類型，還是覺得有點麻煩，有沒有一種方法，使得我們在實現Comparator接口時就規定了具體要比較的類型呢？這時，我們很容易想到JDK中的<T> 泛型就能實現這種功能。所以，我們就將<T> 泛型應用在我們的比較器中，我們應用JDK中Comparator和Comparable到我們的程序，如下：

Cat.java

import java.util.Comparator;
/**
 * Cat類 有屬性身高，體重及toString()方法
 * 
 * @author jesson
 * 
 */
public class Cat implements java.lang.Comparable<Cat> {
	private int height; // 身高
	private int weight; // 體重

	//private Comparator comparator = new CatHeightComparator(); // 高度比較器
	private Comparator<Cat> comparator = new CatWeightComparator(); // 重量比較器

	public Comparator getComparator() {
		return comparator;
	}

	public void setComparator(Comparator comparator) {
		this.comparator = comparator;
	}

	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方法 
	 * 調用具體的比較器進行比較大小
	 */
	@Override
	public int compareTo(Cat o) {
		return comparator.compare(this, o);
	}
}

CatHeightComparator.java

import java.util.Comparator;

/**
 * Cat類型高度比較器
 * 
 * @author jesson
 * 
 */
public class CatHeightComparator implements Comparator<Cat> {

	@Override
	public int compare(Cat o1, Cat o2) {
		// TODO Auto-generated method stub
		if (o1.getHeight() > o2.getHeight())
			return 1;
		else if (o1.getHeight() < o2.getHeight())
			return -1;
		else
			return 0;
	}
}

CatWeightComparator.java

import java.util.Comparator;

/**
 * Cat類型重量比較器
 * 
 * @author jesson
 * 
 */
public class CatWeightComparator implements Comparator<Cat> {

	@Override
	public int compare(Cat o1, Cat o2) {
		// TODO Auto-generated method stub
		if (o1.getWeight() > o2.getWeight())
			return -1;
		else if (o1.getWeight() < o2.getWeight())
			return 1;
		else
			return 0;
	}
}

DataSorter

import java.lang.Comparable;

/**
 * 排序類
 * 
 * @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(1,1),new Cat(3,3)};
		//Dog[] a = {new Dog(3),new Dog(2),new Dog(6)};
		DataSorter.print(a);
		//DataSorter.bubbleSort(a);
		java.util.Arrays.sort(a);
		DataSorter.print(a);
	}
}

　　　可以看出，我們這裏沒有用自己定義的Comparable和Comparator，而是用JDK中的Comparable<T>和Comparator<T>接口，其實JDK已經封裝好了sort()方法，我們直接拿來用，但是有個前提，需要被排序的類要實現JDK的Comparable接口；所以在測試程序裏，我們可以直接用JDK中的sort(Object[] o)方法對我們定義的類型的數組進行排序。

　　　以上，我們所寫的Comparable和Comparator接口只是用來模擬JDK中的對應接口，在實際的開發過程中，我們一般直接拿來用即可。