Java泛型中的通配符和類型擦除可通過PECS原則和類型令牌有效掌握，使用? extends T讀取數(shù)據(jù)、? super T寫入數(shù)據(jù)，遵循Producer-Extends Consumer-Super原則；1. 無界通配符<?>用于僅操作Object方法的場景，不可添加元素；2. 上界通配符<? extends T>允許從多種子類型集合中讀取，但禁止寫入；3. 下界通配符<? super T>支持向集合寫入T類型元素，但讀取時僅能作為Object處理；類型擦除導致運行時泛型信息丟失，List<String>與List<Integer>均變?yōu)長ist，因此無法實例化泛型類型、不能基于泛型重載方法、靜態(tài)字段不能使用泛型；可通過傳遞Class<T>類型令牌實現(xiàn)運行時類型檢查，如TypeSafeList或Gson的TypeToken機制；為確保類型安全，應避免原始類型和強制轉換，設計時依賴編譯期類型檢查，運行時借助反射或類令牌彌補擦除限制，最終將泛型從復雜特性轉化為可靠工具。

Java generics are powerful, but when you dive deeper—especially into wildcards and type erasure—they can feel more like a puzzle than a productivity tool. While basic generics help catch type errors at compile time, advanced use cases involving ?, extends, super, and the limitations imposed by type erasure require a clearer mental model. Let’s break down how to actually use wildcards effectively and work around the quirks of type erasure.

Understanding Wildcards: ?, extends, and super

Wildcards (?) represent unknown types in generics. They’re not just syntactic noise—they’re essential for writing flexible and safe generic code.

1. Unbounded Wildcard (<?>) – “I don’t care what type it is”

Use when you only need methods from Object (like toString(), equals()), or you're doing operations that don’t depend on the generic type.

public void printList(List<?> list) {
    for (Object item : list) {
        System.out.println(item);
    }
}

You can’t add any element (except null) to a List<?>—because the compiler doesn’t know what type is allowed.

2. Upper-Bounded Wildcard (<? extends T>) – “It’s T or a subclass”

Use when you need to read elements and treat them as a common type.

public double sum(List<? extends Number> numbers) {
    return numbers.stream()
                  .mapToDouble(Number::doubleValue)
                  .sum();
}

This works with List<Integer>, List<Double>, etc., because they’re subtypes of Number.

?? But again: you cannot add anything (except null) to a List<? extends T>. The compiler doesn’t know the exact type—maybe it’s List<Integer>, maybe List<Double>.

3. Lower-Bounded Wildcard (<? super T>) – “It’s T or a superclass”

Use when you need to write or add elements of type T.

public void addNumbers(List<? super Integer> list) {
    list.add(42);
    list.add(100);
}

This accepts List<Integer>, List<Number>, or List<Object>.

But when reading, you only know the elements are at least Object, so you get back Object, not Integer.

The PECS Rule: A Mental Shortcut

From Joshua Bloch’s Effective Java: PECS stands for Producer-Extends, Consumer-Super.

• If a parameterized collection produces items (you read from it), use <? extends T>.
• If it consumes items (you write to it), use <? super T>.

Example: Collections.copy()

public static <T> void copy(List<? super T> dest, List<? extends T> src)

• src is a producer → ? extends T
• dest is a consumer → ? super T

Remember PECS, and you’ll rarely guess wrong.

Type Erasure: What Happens at Runtime?

Java generics use type erasure—all generic type information is removed by the compiler. At runtime, List<String> and List<Integer> are both just List.

What’s Erased?

• Generics: List<T> → List
• Type parameters: replaced with their bound (or Object if unbounded)
• Bridge methods are generated to maintain polymorphism

List<String> strings = new ArrayList<>();
List<Integer> ints = new ArrayList<>();

// This compiles to true at runtime
System.out.println(strings.getClass() == ints.getClass()); // true

Consequences of Type Erasure

1. No runtime type checks on generics

   List<String> list = new ArrayList<>();
   ((List) list).add(123); // Compiles and runs, but breaks type safety

   → Throws ClassCastException only when you later read the String.

2. Cannot instantiate generic types

   public class Box<T> {
       private T item;
       public T create() {
           // return new T(); // ? Not allowed
       }
   }

   Workaround: Pass a Class<T>:

   public T create(Class<T> clazz) throws Exception {
       return clazz.newInstance();
   }

3. No method overloading based on generics

   void method(List<String> list) { }
   void method(List<Integer> list) { } // ? Compile error

4. Cannot have static fields with generic type parameters

   public class Box<T> {
       static T item; // ? Not allowed — static shared across all T
   }

Working Around Type Erasure: Reification and Tokens

Sometimes you need to preserve type information at runtime. One common solution is using type tokens with Class<T>.

public class TypeSafeList<T> {
    private Class<T> type;

    public TypeSafeList(Class<T> type) {
        this.type = type;
    }

    public void add(List<Object> rawList, Object item) {
        if (type.isInstance(item)) {
            rawList.add(item);
        } else {
            throw new IllegalArgumentException("Wrong type");
        }
    }
}

Used like:

TypeSafeList<String> stringList = new TypeSafeList<>(String.class);

Gson uses this pattern with TypeToken for deserializing generic types.

Summary: Taming the Beast

• Use wildcards to make APIs flexible: extends for reading, super for writing.
• Remember PECS—it’s your best friend.
• Accept that type erasure limits what you can do at runtime.
• Use class tokens or reflection when you need type info back.
• Avoid casting and raw types—they defeat the purpose of generics.

Generics in Java aren’t perfect, but once you understand the rules behind wildcards and erasure, they become a reliable tool—not a mystery.

Basically: design with types at compile time, work around erasure at runtime, and let PECS guide your wildcard use.

以上が高度なJavaジェネリック：ワイルドカードとタイプの消去を飼いならしますの詳細內容です。詳細については、PHP 中國語 Web サイトの他の関連記事を參照してください。