如何在Java中使用通配符（？扩展t）的仿制药？

? extends T 表示“未知的 T 子类型”，用于泛型中实现只读操作，允许接受 T 或其任意子类的集合，适用于读取数据但不写入的场景，如 List extends Number> 可接收 List、List，遵循 PECS 原则中的“生产者”角色，确保类型安全。

Generics with wildcards in Java, especially ? extends T, are used to create flexible and type-safe code when working with collections or methods that operate on related types. This wildcard is known as a bounded wildcard and allows you to accept any subtype of a given type T.

What does ? extends T mean?

The expression ? extends T means "an unknown type that is a subclass of T (or T itself)." It's useful when you want to read from a data structure but not write arbitrary elements into it.

Important: You can retrieve elements from such structures and treat them as type T, but you cannot safely add elements (except null) because the actual type is unknown.

When to use ? extends T

Use ? extends T when your method only needs to read elements from a generic collection and work with them as instances of T. This supports polymorphism in generics — for example, passing a List where a List is expected (if Dog extends Animal).

Example: A method that sums numbers

public static double sum(List<? extends Number> list) {
    double total = 0;
    for (Number num : list) {
        total  = num.doubleValue();
    }
    return total;
}

This method accepts:

• List
• List
• List
• Any list of a type that extends Number

You can iterate and call doubleValue() because every element is guaranteed to be a Number or its subtype.

Limitations: Why you can't add elements

Because the exact type is unknown, Java prevents adding non-null objects to maintain type safety.

List<? extends Number> numbers = new ArrayList<Integer>();
numbers.add(42);        // ❌ Compile error
numbers.add(new Float(3.14)); // ❌ Also compile error

The compiler doesn’t know if the list holds Integer, Double, etc., so any addition could break type integrity.

PECS Principle: Producer Extends, Consumer Super

A helpful mnemonic from Effective Java:

• If a parameterized object is a producer of data (you read from it), use ? extends T.
• If it’s a consumer (you write to it), use ? super T.

Example combining both:

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    for (T item : src) {         // reading from source (producer)
        dest.add(item);          // writing to destination (consumer)
    }
}

Here, src produces T values (so uses ? extends T), and dest consumes them (so uses ? super T).

Basically, ? extends T gives flexibility for reading across subtypes while keeping compile-time type safety. Just remember: read-only access when using this wildcard.

以上是如何在Java中使用通配符（？扩展t）的仿制药？的详细内容。更多信息请关注PHP中文网其他相关文章！