在Java編程中，泛型不僅是類型安全的保障，更是提升代碼復用性和靈活性的利器。本文將結合8個典型場景，深入剖析高級泛型的應用技巧，幫助開發者突破基礎用法，掌握泛型在復雜業務中的實戰策略。

一、通配符高級應用：靈活處理類型關系

通配符 ? 用于解決類型間的兼容性問題。<? extends T> 表示類型上限，只能獲取元素；<? super T> 表示類型下限，只能插入元素。以集合操作為例：

import java.util.ArrayList;
import java.util.List;class Animal {}
class Dog extends Animal {}public class Main {public static void main(String[] args) {List<Dog> dogs = new ArrayList<>();// 讀取數據，使用? extendsreadElements(dogs); // 寫入數據，使用? superwriteElement(dogs); }// 只能讀取，不能寫入public static void readElements(List<? extends Animal> list) {for (Animal animal : list) {System.out.println(animal);}}// 只能寫入，不能讀取public static void writeElement(List<? super Dog> list) {list.add(new Dog());}
}

上述代碼中，readElements 方法確保讀取的元素至少是 Animal 類型，writeElement 方法保證寫入的 Dog 元素能被正確接收。

二、泛型方法與類型推斷

泛型方法可以獨立于類定義，通過類型推斷簡化代碼。例如，實現一個通用的交換方法：

public class Main {public static <T> void swap(T[] array, int i, int j) {T temp = array[i];array[i] = array[j];array[j] = temp;}public static void main(String[] args) {Integer[] numbers = {1, 2};swap(numbers, 0, 1);for (Integer num : numbers) {System.out.println(num);}}
}

swap 方法的類型參數 T 由調用時傳入的數組類型自動推斷，無需顯式指定。

三、泛型類的嵌套使用

在復雜的數據結構中，泛型類的嵌套能提供強大的表達能力。以多層容器為例：

import java.util.ArrayList;
import java.util.List;class Outer<T> {private T value;private List<Inner<T>> innerList = new ArrayList<>();public Outer(T value) {this.value = value;}public void addInner(Inner<T> inner) {innerList.add(inner);}static class Inner<T> {private T innerValue;public Inner(T innerValue) {this.innerValue = innerValue;}}
}public class Main {public static void main(String[] args) {Outer<String> outer = new Outer<>("Outer");Outer.Inner<String> inner = outer.new Inner<>("Inner");outer.addInner(inner);}
}

通過嵌套泛型類，Outer 類不僅存儲自身類型的數據，還能管理包含相同類型數據的 Inner 類實例。

四、受限泛型與邊界條件

使用 extends 關鍵字限制泛型類型，要求類型必須實現特定接口或繼承某個類。比如，實現一個計算幾何圖形面積的通用方法：

interface Shape {double getArea();
}class Rectangle implements Shape {private double width;private double height;public Rectangle(double width, double height) {this.width = width;this.height = height;}@Overridepublic double getArea() {return width * height;}
}class Circle implements Shape {private double radius;public Circle(double radius) {this.radius = radius;}@Overridepublic double getArea() {return Math.PI * radius * radius;}
}public class Main {public static <T extends Shape> double totalArea(List<T> shapes) {double sum = 0;for (T shape : shapes) {sum += shape.getArea();}return sum;}public static void main(String[] args) {List<Shape> shapeList = new ArrayList<>();shapeList.add(new Rectangle(3, 4));shapeList.add(new Circle(5));System.out.println(totalArea(shapeList));}
}

totalArea 方法限定 T 必須是 Shape 接口的實現類，確保傳入的對象都具備計算面積的能力。

五、泛型與反射結合

利用反射可以在運行時獲取泛型的實際類型。在數據反序列化場景中，這一特性尤為重要：

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;class GenericList<T> {private List<T> list = new ArrayList<>();public void add(T element) {list.add(element);}public Type getActualTypeArgument() {Type genericSuperclass = getClass().getGenericSuperclass();if (genericSuperclass instanceof ParameterizedType) {ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;return parameterizedType.getActualTypeArguments()[0];}return null;}
}public class Main {public static void main(String[] args) {GenericList<String> stringList = new GenericList<>();stringList.add("Hello");Type type = stringList.getActualTypeArgument();System.out.println("實際類型: " + type.getTypeName());}
}

通過反射獲取 ParameterizedType，可解析出泛型類實例化時的具體類型。

六、泛型在函數式接口中的應用

Java 8的函數式接口結合泛型，能實現更靈活的操作。以 Function 接口為例：

import java.util.function.Function;class Person {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public int getAge() {return age;}
}public class Main {public static void main(String[] args) {Function<Person, String> getName = Person::getName;Person person = new Person("Alice", 25);System.out.println(getName.apply(person));}
}

Function 接口的泛型參數定義了輸入和輸出類型，通過方法引用實現類型安全的操作。

七、類型擦除與橋接方法

泛型在編譯后會發生類型擦除，這可能導致一些意想不到的問題。例如，子類覆蓋父類泛型方法時，編譯器會生成橋接方法：

class GenericParent<T> {public void method(T t) {System.out.println("Parent method: " + t);}
}class GenericChild extends GenericParent<String> {@Overridepublic void method(String s) {System.out.println("Child method: " + s);}
}public class Main {public static void main(String[] args) {GenericChild child = new GenericChild();child.method("Hello");}
}

理解類型擦除和橋接方法的原理，有助于處理泛型繼承和覆蓋中的兼容性問題。

八、自定義泛型注解

結合泛型與注解，可以實現更強大的元編程能力。例如，定義一個用于驗證數據類型的注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface ValidateType<T> {Class<T> value();
}class Validator {@ValidateType(String.class)public static void validate(Object obj) {if (!(obj instanceof String)) {throw new IllegalArgumentException("類型不匹配");}System.out.println("驗證通過");}
}public class Main {public static void main(String[] args) {Validator.validate("Test");}
}

自定義泛型注解能在運行時根據具體類型進行動態驗證，提升代碼的健壯性和可維護性。

總結

Java高級泛型通過通配符、受限類型、反射結合等技巧，在提升代碼類型安全、復用性和靈活性方面發揮著關鍵作用。從集合操作時通配符對類型兼容性的把控，到函數式接口與泛型結合實現的靈活操作；從反射獲取泛型實際類型解決反序列化難題，到自定義泛型注解實現動態驗證 ，這些技巧貫穿于數據結構設計、算法實現、框架開發等多個場景。同時，理解類型擦除和橋接方法的原理，能幫助開發者規避泛型使用中的潛在問題。在實際開發中，合理運用這些技巧，不僅能編寫出更簡潔、高效的代碼，還能增強系統的可擴展性與穩定性，讓Java編程更具專業性與規范性。