泛型定義

Java 泛型(generics)本質是參數化類型，也就是說所操作的Java數據類型被指定為一個參數。是 JDK 5 中引入的一個新特性, 泛型提供了編譯時類型安全檢測機制，該機制允許程序員在編譯時檢測到非法的類型。

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

使用泛型的意義

1.適用于多種數據類型執行相同的代碼(代碼復用)

未使用泛型前，針對不同的參數類型需要對函數作重載操作

private static int add(int a, int b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}
private static float add(float a, float b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}
private static double add(double a, double b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}

使用泛型后，可以將多種參數類型情況復用為一個函數

private static <T extends Number> double add(T a, T b) {
    System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue()));
    return a.doubleValue() + b.doubleValue();
}

泛型的使用情況

1.泛型類

public class TClass {
    public static void main(String[] args) {
        TClass00<String, Object> tClass = new TClass00<>();
        tClass.setKey("hello");
        tClass.setValue("world");
        System.out.println(tClass.getKey() + " " + tClass.getValue());
        tClass.setValue(0.0);
        System.out.println(tClass.getKey() + " " + tClass.getValue());
    }
}
// 泛型類
class TClass00<K, V> {
    private K key;
    private V value;
    public K getKey() {
        System.out.println(key.getClass());
        return key;
    }
    public void setKey(K key) {
        this.key = key;
    }
    public V getValue() {
        System.out.println(value.getClass());
        return value;
    }
    public void setValue(V value) {
        this.value = value;
    }
}

// 輸出結果
class java.lang.String
class java.lang.String
hello world
class java.lang.String
class java.lang.Double
hello 0.0

2.泛型接口

public class TImpl {
    public static void main(String[] args) {
        TImpl00<Float> tImpl00 = new TClass00<>();
        tImpl00.hello(0.0f);
    }
}
// 定義泛型接口
interface TImpl00<T> {
    T hello(T t);
}
// 定義接口的子類
class TClass00<T> implements TImpl00<T>{
    @Override
    public T hello(T t) {
        System.out.println(t.getClass());
        System.out.println("hello " + t.toString());
        return t;
    }
}

// 輸出結果
class java.lang.Float
hello 0.0

3.泛型方法

public class TMethods {
    public static void main(String[] args) {
        System.out.println("hello".getClass());
        getClass("hello".getClass());
    }    
    /**
     * 定義泛型方法的規則：
     *      1.所有泛型方法聲明都有一個類型參數聲明部分（由尖括號分隔），該類型參數聲明部分在方法返回類型之前
     *      2.每一個類型參數聲明部分包含一個或多個類型參數，參數間用逗號隔開。一個泛型參數，也被稱為一個類型變量，是用于指定一個泛型類型名稱的標識符。
     *      3.類型參數能被用來聲明返回值類型，并且能作為泛型方法得到的實際參數類型的占位符。
     *      4.泛型方法體的聲明和其他方法一樣。注意類型參數只能代表引用型類型，不能是原始類型
     */
    // 泛型方法
    public static <T extends Object> void getClass(T t) {
        System.out.println(t);
        System.out.println(t.getClass());
    }
}

// 輸出結果
class java.lang.String
class java.lang.String
class java.lang.Class

泛型的上下限

為了解決泛型中隱含的轉換問題，Java泛型加入了類型參數的上下邊界機制。

<? extends A>表示該類型參數可以是A(上邊界)或者A的子類類型。編譯時擦除到類型A，即用A類型代替類型參數。

<? super A>表示該類型參數可以是A(下邊界)或者A的父類類型。

public class TClass {
    public static void main(String[] args) {
//        TClass00<String, Object> tClass = new TClass00<>();
//        tClass.setKey("hello");
//        tClass.setValue("world");
//        System.out.println(tClass.getKey() + " " + tClass.getValue());
//        tClass.setValue(0.0);
//        System.out.println(tClass.getKey() + " " + tClass.getValue());
        // 上限
        TClass00<String, Double> hello = new TClass00<>();
        hello.setKey("hello");
        hello.setValue(0.0);
        hello(hello);
        // 下限
        TClass00<String, Object> world = new TClass00<>();
        world.setKey("hello");
        world.setValue("world");
        world(world);
    }
    // 上限
    public static void hello(TClass00<? extends String, ? extends Number> tClass00) {
        System.out.println(tClass00.getKey() + " " + tClass00.getValue());
    }
    // 下限
    public static void world(TClass00<? super String, ? super Integer> tClass00) {
        System.out.println(tClass00.getKey() + " " + tClass00.getValue());
    }
}
// 泛型類
class TClass00<K, V> {
    private K key;
    private V value;
    public K getKey() {
        System.out.println(key.getClass());
        return key;
    }
    public void setKey(K key) {
        this.key = key;
    }
    public V getValue() {
        System.out.println(value.getClass());
        return value;
    }
    public void setValue(V value) {
        this.value = value;
    }
}

// 輸出結果
class java.lang.String
class java.lang.Double
hello 0.0
class java.lang.String
class java.lang.String
hello world

以上就是關于“Java方法：泛型的簡介”，如果大家對此比較感興趣，想了解更多相關知識，不妨來關注一下本站的Java泛型詳解，里面還有更詳細的介紹，相信對大家的學習一定會有所幫助的。