泛型基礎知識

1、泛型是什麼

        泛型是指參數化類型的能力，其做用域爲編譯期。使用泛型能定義帶泛型類型的類或方法，編譯器在編譯時判斷程序中泛型類型是否正確，而後提示錯誤或用具體類型來替換泛型類型。

2、爲何用泛型

        使用泛型可以在編譯時而不是運行時發現錯誤，提升程序的可讀性和可靠性，同時便於通用編程。泛型類或方法容許指定對象容許的類型，以和這個類或方法一塊兒工做。若是試圖使用帶有不兼容對象的類或方法，編譯器會檢測出這個錯誤。

3、泛型規則（怎麼用）

        一、泛型應用

                ①、泛型類和接口：指定類對象的應用類型，隨後可將泛型<E>應用於類內屬性類型、方法返回類型、方法參數類型。

                ②、泛型方法：指定方法的應用類型，隨後可將泛型<E>應用於方法內屬性類型、方法返回值類型、方法參數類型。

        二、通配泛型

                ①、？：非受限通配，與？ extends Object效果同樣。

                ②、？ extends T：受限通配，表示T或T的一個未知子類。

                ③、？ super T：下限通配，表示T或T的一個未知父類型。

        三、應用限制：①、不能使用泛型類型參數來建立實例。    ②、不能使用泛型類型參數來建立數組。    ③、不能在靜態環境中使用類的泛型類型參數。    ③、在異常類中不能使用泛型類型參數

4、泛型實現（編譯器後續工做）

        編譯器使用稱爲類型消除的方法來實現泛型。編譯器使用泛型類型信息來編譯代碼，一但判斷代碼是正確的即用具體類型替換泛型參數，造成類字節碼。所以，泛型信息在運行時是不可用的。

5、泛型實例——矩陣簡單運算

        

/**
 * 通用矩陣抽象類
 * @author FF
 *
 */
public abstract class GenericMatrix<E extends Number> {
	/** 抽象方法，返回兩元素的相加結果 */
	protected abstract E add(E e1, E e2);
	
	/** 抽象方法，返回兩元素的相乘結果 */
	protected abstract E multiply(E e1, E e2);
	
	/** 抽象方法，返回0值*/
	protected abstract E zero();
	
	/** 矩陣加法 */
	public E[][] matrixAdd(E m1[][], E m2[][]) {
		// 矩陣邊界判斷
		if (m1.length != m2.length || m1[0].length != m2[0].length)
			throw new RuntimeException("矩陣類型不一致，沒法進行加法計算");
		
		E[][] result = (E[][])new Number[m1.length][m2[0].length];
		
		// 相加操做
		for (int i = 0; i < result.length; i++)
			for (int j = 0; j < result[0].length; j++) {
				result[i][j] = (E) this.add(m1[i][j], m2[i][j]);
			}
		return result;
	}
	
	/** 矩陣乘法 */
	public E[][] matrixMultiply(E m1[][], E m2[][]) {
		// 矩陣邊界判斷
		if (m1[0].length != m2.length)
			throw new RuntimeException("矩陣類型不匹配，沒法進行乘法計算");
		
		E[][] result = (E[][])new Number[m1.length][m2[0].length];
		
		// 乘法操做 
		for (int i = 0; i < result.length; i++)
			for (int j = 0; j < result[0].length; j++) {
				result[i][j] = this.zero();
				
				for (int k = 0; k < m1[0].length; k++) {
					result[i][j] = this.add(result[i][j], this.multiply(m1[i][k], m2[k][j]));
				}
			}
		return result;
	}
	
	/** 打印輸出 */
	public void printResult(Number m1[][], Number m2[][], Number m3[][], char op) {
		for (int i = 0; i < m1.length; i++) {
			for (int j = 0; j < m1[0].length; j++)
				System.out.print(" " + m1[i][j]);
			
			if (i == m1.length / 2)
				System.out.print(" " + op + " ");
			else
				System.out.print("   ");
			
			for (int j = 0; j < m2[0].length; j++)
				System.out.print(" " + m2[i][j]);
			
			if (i == m1.length / 2)
				System.out.print(" " + "=" + " ");
			else
				System.out.print("   ");
			
			for (int j = 0; j < m3.length; j++)
				System.out.print(m3[i][j] + " ");
			
			System.out.println ();
		}
	}
}



/**
 * 整型矩陣類
 * @author FF
 *
 */
public class IntegerMatrix extends GenericMatrix<Integer>{
	
	@Override
	protected Integer add(Integer e1, Integer e2) {
		return e1 + e2;
	}

	@Override
	protected Integer multiply(Integer e1, Integer e2) {
		return e1 * e2;
	}

	@Override
	protected Integer zero() {
		return 0;
	}
}



/**
 * 有理數矩陣類
 * @author FF
 *
 */
public class RationalMatrix extends GenericMatrix<Rational>{

	@Override
	protected Rational add(Rational r1, Rational r2) {
		return r1.add(r2);
	}

	@Override
	protected Rational multiply(Rational r1, Rational r2) {
		return r1.multiply(r2);
	}

	@Override
	protected Rational zero() {
		return new Rational(0, 1);
	}
}



/** 測試IntegerMatrix類 */
	@Test
	public void testIntegerMatrix() {
		GenericMatrix<Integer> gm = new IntegerMatrix();
		Integer[][] m1 = {{1, 2, 3}, {4, 5, 6}, {1, 1, 1}};
		Integer[][] m2 = {{1, 1, 1}, {2, 2, 2}, {0, 0, 0}};
		
		gm.printResult(m1, m2, gm.matrixAdd(m1, m2), '+');
		System.out.println("");
		gm.printResult(m1, m2, gm.matrixMultiply(m1, m2), '*');		
	}
	
	
	
/**  測試RationalMatrix類 */
	@Test
	public void testRationalMatrix() {
		Rational[][] r1 = new Rational[3][3];
		Rational[][] r2 = new Rational[3][3];
		for (int i = 0; i < r1.length; i++)
			for (int j = 0; j < r1[0].length; j++) {
				r1[i][j] = new Rational(i + 1, j + 5);
				r2[i][j] = new Rational(i + 1, j + 6);
			}
		
		GenericMatrix<Rational> rm = new RationalMatrix();
		
		rm.printResult(r1, r2, rm.matrixAdd(r1, r2), '+');
		System.out.println("");
		rm.printResult(r1, r2, rm.matrixMultiply(r1, r2), '*');
	}