要我直接說出泛型是個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 ));
}
}
實作泛型接口的方式有兩種,一種是在實作的時候指定泛型類型
另一種是依然使用泛型,在構造的時候确定泛型類型