为何Java泛型在类与方法间的不变性表现存在差异？

场景1：类声明泛型的情况 #

先看初始的类定义：

public class Handler<S extends Something> {
    
    void registerHandler(Class<S> someClass) {
        // do something    
    }
}

public class Shoe implements Something {
}

当你这样使用时会触发编译错误：

public class Main {
    
    Handler<? extends Something> handler = new Handler<>();

    void doStuff() {
        handler.registerHandler(Shoe.class); // 编译错误：所需类型与提供类型不匹配
    }
    
}

错误提示明确：方法registerHandler()需要的是Class<capture of ? extends Something>类型，但你传入的是Class<Shoe>，两者不匹配。

场景2：方法声明泛型的可行方案 #

把泛型从类移到方法上后，代码就能正常编译：

public class Handler {
    
    <S extends Something> void registerHandler(Class<S> someClass) {
        // do something    
    }
}

对应的调用代码：

public class Main {
   
   Handler handler = new Handler();

   void doStuff() {
       handler.registerHandler(Shoe.class); // 编译通过
   }
   
}

为什么两种写法差异这么大？ #

类级泛型的问题本质 #

当你写Handler<? extends Something> handler时，这个通配符?代表某个具体但未知的Something子类。也就是说，handler实际指向的可能是Handler<Shoe>，也可能是Handler<Hat>（假设Hat也是Something的子类），但编译器完全不知道具体是哪一个。

此时registerHandler方法的参数Class<S>里的S，就是那个未知的子类类型。编译器要求你传入的Class对象必须严格匹配这个未知类型，但你传入的Shoe.class是确定的类型，编译器没法证明Shoe就是那个未知类型，自然会报错。

简单说：类级泛型的S是绑定好的固定未知类型，你不能用另一个确定类型去凑。

方法级泛型的工作逻辑 #

把泛型移到方法上后，<S extends Something>是方法专属的泛型参数，每次调用方法时，编译器会根据你传入的参数自动推导S的具体类型。

比如你传Shoe.class，编译器直接推导S=Shoe，而Shoe确实符合extends Something的约束，所以完全合法，不会有任何问题。

这里的泛型是每次调用动态确定的，不像类级泛型那样被绑定到一个固定的未知类型，所以兼容性更强。

额外补充：类级泛型的其他可行写法 #

如果非要用类级泛型，也能避免错误，比如直接指定具体的泛型类型：

public class Main {
    
    Handler<Shoe> handler = new Handler<>();

    void doStuff() {
        handler.registerHandler(Shoe.class); // 编译正常
    }
    
}

但这样就失去了通配符带来的灵活性，而方法级泛型既保证了类型安全，又能支持任意Something子类的传入。

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