java 泛型

java 泛型（generics）提供了編譯時類型安全檢測機制，該機制允許程序員在編譯時檢測到非法的類型。 泛型的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數。

假定我們有這樣一個需求：寫一個排序方法，能夠對整型數組、字符串數組甚至其他任何類型的數組進行排序，該如何實現？

答案是可以使用 java 泛型。

使用 java 泛型的概念，我們可以寫一個泛型方法來對一個對象數組排序。然后，調用該泛型方法來對整型數組、浮點數數組、字符串數組等進行排序。

1. 泛型方法

你可以寫一個泛型方法，該方法在調用時可以接收不同類型的參數。根據傳遞給泛型方法的參數類型，編譯器適當地處理每一個方法調用。

下面是定義泛型方法的規則：

• 所有泛型方法聲明都有一個類型參數聲明部分（由尖括號分隔），該類型參數聲明部分在方法返回類型之前（在下面例子中的<e>）。
• 每一個類型參數聲明部分包含一個或多個類型參數，參數間用逗號隔開。一個泛型參數，也被稱為一個類型變量，是用于指定一個泛型類型名稱的標識符。
• 類型參數能被用來聲明返回值類型，并且能作為泛型方法得到的實際參數類型的占位符。
• 泛型方法體的聲明和其他方法一樣。注意類型參數只能代表引用型類型，不能是原始類型（像int,double,char的等）。

范例如下：

下面的例子演示了如何使用泛型方法打印不同類型的數組元素：

public class genericmethodtest
{
    // 泛型方法 printarray                         
    public static <e> void printarray( e[] inputarray )
    {
        // 輸出數組元素            
            for ( e element : inputarray ){        
                system.out.printf( "%s ", element );
            }
    }
    
    public static void main( string args[] )
    {
        // 創建不同類型數組： integer, double 和 character
        integer[] intarray = { 1, 2, 3, 4, 5 };
        double[] doublearray = { 1.1, 2.2, 3.3, 4.4 };
        character[] chararray = { 'h', 'e', 'l', 'l', 'o' };
    
        system.out.println( "整型數組元素為:" );
        printarray( intarray  ); // 傳遞一個整型數組
    
        system.out.println( "\n雙精度型數組元素為:" );
        printarray( doublearray ); // 傳遞一個雙精度型數組
    
        system.out.println( "\n字符型數組元素為:" );
        printarray( chararray ); // 傳遞一個字符型數組
    } 
}

編譯以上代碼，運行結果如下所示：

整型數組元素為:
1 2 3 4 5 

雙精度型數組元素為:
1.1 2.2 3.3 4.4 

字符型數組元素為:
h e l l o 

有界的類型參數:

可能有時候，你會想限制那些被允許傳遞到一個類型參數的類型種類范圍。例如，一個操作數字的方法可能只希望接受 number 或者 number 子類的范例。這就是有界類型參數的目的。

要聲明一個有界的類型參數，首先列出類型參數的名稱，后跟 extends 關鍵字，最后緊跟它的上界。

范例如下：

下面的例子演示了 "extends" 如何使用在一般意義上的意思 "extends"（類）或者 "implements"（接口）。該例子中的泛型方法返回三個可比較對象的最大值。

public class maximumtest
{
    // 比較三個值并返回最大值
    public static <t extends comparable<t>> t maximum(t x, t y, t z)
    {                     
        t max = x; // 假設x是初始最大值
        if ( y.compareto( max ) > 0 ){
            max = y; //y 更大
        }
        if ( z.compareto( max ) > 0 ){
            max = z; // 現在 z 更大           
        }
        return max; // 返回最大對象
    }
    public static void main( string args[] )
    {
        system.out.printf( "%d, %d 和 %d 中最大的數為 %d\n\n",
                    3, 4, 5, maximum( 3, 4, 5 ) );
    
        system.out.printf( "%.1f, %.1f 和 %.1f 中最大的數為 %.1f\n\n",
                    6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );
    
        system.out.printf( "%s, %s 和 %s 中最大的數為 %s\n","pear",
            "apple", "orange", maximum( "pear", "apple", "orange" ) );
    }
}    

編譯以上代碼，運行結果如下所示：

3, 4 和 5 中最大的數為 5

6.6, 8.8 和 7.7 中最大的數為 8.8

pear, apple 和 orange 中最大的數為 pear

2. 泛型類

泛型類的聲明和非泛型類的聲明類似，除了在類名后面添加了類型參數聲明部分。

和泛型方法一樣，泛型類的類型參數聲明部分也包含一個或多個類型參數，參數間用逗號隔開。一個泛型參數，也被稱為一個類型變量，是用于指定一個泛型類型名稱的標識符。因為他們接受一個或多個參數，這些類被稱為參數化的類或參數化的類型。

范例如下：

如下范例演示了我們如何定義一個泛型類:

public class box<t> {
    private t t;
    
    public void add(t t) {
        this.t = t;
    }
    
    public t get() {
        return t;
    }
    
    public static void main(string[] args) {
        box<integer> integerbox = new box<integer>();
        box<string> stringbox = new box<string>();
    
        integerbox.add(new integer(10));
        stringbox.add(new string("碩編程"));
    
        system.out.printf("整型值為 :%d\n\n", integerbox.get());
        system.out.printf("字符串為 :%s\n", stringbox.get());
    }
}

編譯以上代碼，運行結果如下所示：

整型值為 :10

字符串為 :碩編程

3. 類型通配符

1、類型通配符一般是使用?代替具體的類型參數。例如 list<?> 在邏輯上是list<string>,list<integer> 等所有list<具體類型實參>的父類。

import java.util.*;

public class generictest {
        
    public static void main(string[] args) {
        list<string> name = new arraylist<string>();
        list<integer> age = new arraylist<integer>();
        list<number> number = new arraylist<number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
    
        getdata(name);
        getdata(age);
        getdata(number);
    }
    
    public static void getdata(list<?> data) {
        system.out.println("data :" + data.get(0));
    }
}

輸出結果為：

data :icon
data :18
data :314

解析： 因為 getdata() 方法的參數是 list 類型的，所以name，age，number 都可以作為這個方法的實參，這就是通配符的作用

2、類型通配符上限通過形如 list 來定義，如此定義就是通配符泛型值接受 number 及其下層子類類型。

import java.util.*;

public class generictest {
        
    public static void main(string[] args) {
        list<string> name = new arraylist<string>();
        list<integer> age = new arraylist<integer>();
        list<number> number = new arraylist<number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
    
        //getupernumber(name);//1
        getupernumber(age);//2
        getupernumber(number);//3
    }
    
    public static void getdata(list<?> data) {
        system.out.println("data :" + data.get(0));
    }
    
    public static void getupernumber(list<? extends number> data) {
            system.out.println("data :" + data.get(0));
        }
}

輸出結果：

data :18
data :314

解析： 在(//1)處會出現錯誤，因為 getupernumber() 方法中的參數已經限定了參數泛型上限為 number，所以泛型為 string 是不在這個范圍之內，所以會報錯

3、類型通配符下限通過形如 list<? super number>來定義，表示類型只能接受 number 及其三層父類類型，如 object 類型的范例。