java中的泛型總結

要我直接說出泛型是個what我還真講不出來，這里先由一道問題引入：

　　定義一個坐標點類，要求能保存各種類型的數據，如：整形，浮點型，和字符串類型

既然變量類型起先不確定，那么很容易想到就是用所有類型的父類，也就是Object類來代替

不廢話了，用代碼來體現

 

實例1：用Object來實現不確定的數據類型輸入

//這是定義的坐標點類
class Point {
	private Object x;
	private Object y;
	
	//用Object來表示不確定的類型
	public Point(Object x, Object y) {
		this.setX(x);
		this.setY(y);
	}
	public void setX(Object x) {
		this.x = x;
	}
	public Object getX() {
		return x;
	}
	public void setY(Object y) {
		this.y = y;
	}
	public Object getY() {
		return y;
	}

}

//測試類
public class Demo {
	public static void main(String[] args) {
		System.out.println("用浮點數表示坐標: ");
		Point p = new Point(12.23,23.21);
		//這里把Object類轉為Double類，然后自動拆箱，下面兩種一樣
		System.out.println("X的坐標 " + (Double)p.getX());
		System.out.println("Y的坐標 " + (Double)p.getY());
		System.out.println();

		System.out.println("用整數表示坐標: ");
		Point p2 = new Point(12, 23);
		System.out.println("X的坐標 " + (Integer)p2.getX());
		System.out.println("Y的坐標 " + (Integer)p2.getY());
		System.out.println();

		System.out.println("用字符串表示坐標: ");
		Point p3 = new Point("北緯29度", "東經113度");
		System.out.println("X的坐標 " + (String)p3.getX());
		System.out.println("Y的坐標 " + (String)p3.getY());
	}
}

這樣就可以代入不同類型數據了，但你別忘了，此時的數據還是Object型，也就是所有類型的父類

你必須清醒的明白自己傳入的是什么類型，然后將其做向下轉型處理才能使用

雖然這樣做滿足了需求，不過卻隱含了一個不安全因素，為什么說是隱含呢？

比如我們用new Point(12.23,"北緯29度")來構造一個Point對象

然后都用(Double)將其向下轉型，會產生什么結果？

沒錯，編譯會通過，但是一旦運行則會發生類型轉換異常

要避免類轉換異常也很簡單，把Object聲明換成固定類型聲明（如：String x，String y）即可，這樣編譯時就會報錯

然后你就可以尋找出錯的地方進行修改

不過如此一來，我們就滿足不了需求了

為了達到不存在安全隱患和代入各種數據類型的目的，那些牛人們在JDK1.5當中引入了泛型這一概念

我們來看看如何用泛型改寫上面的代碼

 

實例2：泛型類

class Point<T> {
	//這里用T來表示不確定的類型
	private T x;
	private T y;
	public Point(T x, T y) {
		this.setX(x);
		this.setY(y);
	}
	public T getX() {
		return x;
	}
	public void setX(T x) {
		this.x = x;
	}
	public T getY() {
		return y;
	}
	public void setY(T y) {
		this.y = y;
	}
}

public class Demo {
	public static void main(String[] args) {
		System.out.println("用浮點數表示坐標: ");
		//用泛型改寫后，使用數據無需再做向下轉型處理
		Point<Double> p = new Point<Double>(12.23,23.21);
		System.out.println("X的坐標 " + p.getX());
		System.out.println("Y的坐標 " + p.getY());
		System.out.println();

		System.out.println("用整數表示坐標: ");
		Point<Integer> p2 = new Point<Integer>(12, 23);
		System.out.println("X的坐標 " + p2.getX());
		System.out.println("Y的坐標 " + p2.getY());
		System.out.println();

		System.out.println("用字符串表示坐標: ");
		Point<String> p3 = new Point<String>("北緯29度", "東經113度");
		System.out.println("X的坐標 " + p3.getX());
		System.out.println("Y的坐標 " + p3.getY());
	}
}

 使用泛型過后，可減少安全隱患的存在

如果此時我們刻意傳入不一樣的數據類型：

Point<Double> p = new Point<Double>("北緯29度",12.22);

那么，在編譯時就會報錯

雖然定義了泛型，但如果你在構造函數中並未使用泛型機制的話，那么它便會把數據當作Object處理

這樣做的目的主要是為了兼容JDK1.4以前的老代碼，如

Point p = new Point(22.11,23.21);

最終運行結果是一樣的，但在編譯時卻會提示警告信息

 

實例3：泛型方法

由上面的例子可以看到，一旦在構造方法中明確對象類型，那么整個類中就將使用同一種類型

最典型的例子是運用在集合框架里面，如：ArrayList<Integer> al = new ArrayList<Integer>();

此時，al中操作的所有對象類型便都是Integer了

可是，有時候我們並不希望固定死操作的對象，而是希望更夠更加靈活的使用泛型技術

這個時候就可以嘗試泛型方法

//類名后面不再定義泛型
class Print { 
	//在方法中定義泛型
	public <T> void print(T t) {
		System.out.println(t);
	}
	
	public <E> void show(E e) {
		System.out.println(e);
	}
}

public class Demo {
	public static void main(String[] args) {
		Print p = new Print();
		p.print(12);
		p.print("hello");
		p.show(new Integer(33));
		p.show(23);
	}
}

其實這樣一來，與在方法中使用Object對象已經沒有什么太大區別了

何況，JDK1.5之后加入了自動拆裝箱功能，省去了需要向下轉型的麻煩

 

實例4：泛型接口

//定義一個泛型接口
interface Inter<T> 
{
	public void print(T t);
}

//實現方式一：
class InterDemo1 implements Inter<String> {
	public void print(String t) {
		System.out.println("print: " + t);
	}
}

//實現方式二：
class InterDemo2<T> implements Inter<T> {
	public void print(T t) {
		System.out.println("print: " + t);
	}
}

class Demo {
	public static void main(String[] args) {
		InterDemo1 id1 = new InterDemo1();
		id1.print("hello");
		InterDemo2<Integer> id2 = new InterDemo2<Integer>();
		id2.print(new Integer(23));
	}
}

實現泛型接口的方式有兩種，一種是在實現的時候指定泛型類型

另一種是依然使用泛型，在構造的時候確定泛型類型