泛型類、泛型方法及泛型應用

泛型是Java SE 1.5的新特性，泛型的本質是引數化型別，也就是說所操作的資料型別被指定為一個引數。這種引數型別可以用在類、介面和方法的建立中，分別稱為泛型類、泛型介面、泛型方法。 Java語言引入泛型的好處是安全簡單。

在Java SE 1.5之前，沒有泛型的情況的下，透過對型別Object的引用來實現引數的“任意化”，“任意化”帶來的缺點是要做顯式的強制型別轉換，而這種轉換是要求開發者對實際引數型別可以預知的情況下進行的。對於強制型別轉換錯誤的情況，編譯器可能不提示錯誤，在執行的時候才出現異常，這是一個安全隱患。

泛型的好處是在編譯的時候檢查型別安全，並且所有的強制轉換都是自動和隱式的，以提高程式碼的重用率。

規則限制：

1、同一種泛型可以對應多個版本（因為引數型別是不確定的），不同版本的泛型類例項是不相容的。

2、泛型的引數型別可以使用extends語句，例如<T extends superclass>。習慣上稱為“有界型別”。

3、泛型的引數型別還可以是萬用字元型別。例如Class<?> classType = Class.forName("java.lang.String");

泛型還有介面、方法等等，內容很多，需要花費一番功夫才能理解掌握並熟練應用。在此給出我曾經瞭解泛型時候寫出的兩個例子（根據看的印象寫的），實現同樣的功能，一個使用了泛型，一個沒有使用，透過對比，可以很快學會泛型的應用，學會這個基本上學會了泛型70%的內容。

例子一：使用了泛型

    class Gen<T> {

    private T ob; // 定義泛型成員變數

 

    public Gen(T ob) {

        this.ob = ob;

    }

 

    public T getOb() {

        return ob;

    }

 

    public void setOb(T ob) {

        this.ob = ob;

    }

 

    public void showType() {

        System.out.println("T的實際型別是: " + ob.getClass().getName());

    }

}

 

public class GenDemo {

    public static void main(String[] args) {

        // 定義泛型類Gen的一個Integer版本

        Gen<Integer> intOb = new Gen<Integer>(88);

        intOb.showType();

        int i = intOb.getOb();

        System.out.println("value= " + i);

        System.out.println("----------------------------------");

        // 定義泛型類Gen的一個String版本

        Gen<String> strOb = new Gen<String>("Hello Gen!");

        strOb.showType();

        String s = strOb.getOb();

        System.out.println("value= " + s);

    }

}

例子二：沒有使用泛型

?

    class Gen2 {

    private Object ob; // 定義一個通用型別成員

 

    public Gen2(Object ob) {

        this.ob = ob;

    }

 

    public Object getOb() {

        return ob;

    }

 

    public void setOb(Object ob) {

        this.ob = ob;

    }

 

    public void showTyep() {

        System.out.println("T的實際型別是: " + ob.getClass().getName());

    }

}

 

public class GenDemo2 {

    public static void main(String[] args) {

        // 定義類Gen2的一個Integer版本

        Gen2 intOb = new Gen2(new Integer(88));

        intOb.showTyep();

        int i = (Integer) intOb.getOb();

        System.out.println("value= " + i);

        System.out.println("---------------------------------");

        // 定義類Gen2的一個String版本

        Gen2 strOb = new Gen2("Hello Gen!");

        strOb.showTyep();

        String s = (String) strOb.getOb();

        System.out.println("value= " + s);

    }

}

執行結果：

兩個例子執行Demo結果是相同的,控制檯輸出結果如下：

T的實際型別是:

java.lang.Integer

value= 88

----------------------------------

T的實際型別是: java.lang.String

value= Hello Gen!

Process finished with exit code 0

看明白這個，以後基本的泛型應用和程式碼閱讀就不成問題了。

泛型介紹：

一.自定義泛型介面、泛型類和泛型方法

在泛型介面、泛型類和泛型方法的定義過程中，我們常見的如T、E、K、V等形式的引數常用於表示泛型形參，由於接收來自外部使用時候傳入的型別實參。那麼對於不同傳入的型別實參，生成的相應物件例項的型別是不是一樣的呢？

 1 public class GenericTest {

 2

 3     public static void main(String[] args) {

 4

 5         Box<String> name = new Box<String>("corn");

 6         Box<Integer> age = new Box<Integer>(712);

 7

 8         System.out.println("name class:" + name.getClass());      // com.qqyumidi.Box

 9         System.out.println("age class:" + age.getClass());        // com.qqyumidi.Box

10         System.out.println(name.getClass() == age.getClass());    // true

11

12     }

13

14 }

究其原因，在於Java中的泛型這一概念提出的目的，導致其只是作用於程式碼編譯階段，【在編譯過程中，對於正確檢驗泛型結果後，會將泛型的相關資訊擦出，】也就是說，成功編譯過後的class檔案中是不包含任何泛型資訊的。泛型資訊不會進入到執行時階段。

對此總結成一句話：泛型型別在邏輯上看以看成是多個不同的型別，實際上都是相同的基本型別。

二.型別萬用字元

1.類似於Box<Number>和Box<Integer>是否可以看成具有父子關係的泛型型別呢？

 public class GenericTest {

 2

 3     public static void main(String[] args) {

 4

 5         Box<Number> name = new Box<Number>(99);

 6         Box<Integer> age = new Box<Integer>(712);

 7

 8         getData(name);

 9         

10         //The method getData(Box<Number>) in the type GenericTest is

11         //not applicable for the arguments (Box<Integer>)

12         getData(age);   // 1

13

14     }

15     

16     public static void getData(Box<Number> data){

17         System.out.println("data :" + data.getData());

18     }

19

顯然，透過提示資訊，我們知道Box<Number>在邏輯上不能視為 Box<Integer>的父類。