泛型通配符作为方法参数的编译疑问：为何put操作受限？

问题代码 #

class Vehicle { }
class Car extends Vehicle { }
class Sedan extends Car { }

class Garage<V> {
    private V v;
    public V get() { return this.v; }
    public void put(V v) { this.v = v; }
}

public class Main {

    private Object object = new Object();
    private Vehicle vehicle = new Vehicle();
    private Car car = new Car();
    private Sedan sedan = new Sedan();

    public void doD(Garage<? extends Car> g) {
        g.put(object);             // (1) 编译失败
        g.put(vehicle);            // (2) 编译失败
        g.put(car);                // (3) 编译失败
        g.put(sedan);              // (4) 编译失败
        object  = g.get();        // (5) 编译成功
        vehicle = g.get();        // (6) 编译成功
        car     = g.get();        // (7) 编译成功
        sedan   = g.get();        // (8) 编译失败
    }
}

核心疑问解答 #

1. 为什么行(3)(4)无法编译？ #

当声明Garage<? extends Car> g时，编译器仅知道g的泛型类型是Car的某个子类（包含Car本身），但具体类型完全未知。

对于put(V v)方法，参数类型V对应这个未知的子类：

• 假设实际传入的g是Garage<Sedan>，put仅接受Sedan类型参数，此时传入Car（行3）不符合要求；
• 假设实际传入的是Garage<Car>，虽然Sedan是Car子类，但编译器无法提前确定g的具体类型。

为保证类型安全，编译器会禁止所有向g中放入具体类型实例的操作（除了null）——这就是上界通配符? extends的核心规则：只允许读取，不允许写入具体类型实例。

2. 为什么赋值语句Garage<? extends Car> garage = new Garage<Car>()能编译？ #

Garage<? extends Car>是“泛型参数为Car或Car子类的Garage实例”的统一父类型，Garage<Car>和Garage<Sedan>都是它的子类型，就像Car是Vehicle的子类型一样，这类赋值完全合法——这正是通配符的作用：统一处理多个泛型类型的实例。

3. 泛型通配符作为方法参数和变量声明的处理是否不同？ #

完全相同。Garage<? extends Car> g作为方法参数时，和作为成员/局部变量声明的语义一致：它代表一个Garage实例，其泛型参数是Car的某个未知子类（包含Car本身）。方法参数场景下，g由外部传入，编译器同样无法确定其具体泛型类型，因此遵循和变量声明一致的类型安全规则。

补充：get方法的编译结果解释 #

• 行(5)(6)(7)编译成功：g.get()返回? extends Car类型，可安全赋值给Object（所有类的父类）、Vehicle（Car的父类）、Car（上界类型），符合向上转型规则；
• 行(8)编译失败：sedan是Car的子类，g.get()返回的未知类型可能是Car本身，而Car不能向下转型为Sedan，编译器禁止该操作。

内容的提问来源于stack exchange，提问作者mirat1618