Java中含逆变Consumer参数的方法能否协变重写？

问题场景 #

以下代码中，子类Y尝试重写父类X的方法f，但编译器直接报错：

public class A {}
public class B extends A {}

public class X {
    public void f(Consumer<? super A> consumer) {
        consumer.accept(new A());
    }
}

public class Y extends X {
    @Override                                        // 第14行
    public void f(Consumer<? super B> consumer) {    // 第15行
        consumer.accept(new B());
    }
}

public static void main(String[] args) {
    X x = new X();
    Y y = new Y();
    X xy = new Y();

    Consumer<A> ca = (A a) -> {};
    Consumer<B> cb = (B a) -> {};

    x.f(ca);     // (1) Consumer接收A和B，方法内传入A，正常运行
    // x.f(cb);  // (2) Consumer仅接收B，但方法内会传入A，类型错误，编译不通过

    y.f(ca);     // (3) Consumer接收A和B，方法内传入B，正常运行
    y.f(cb);     // (4) Consumer仅接收B，方法内传入B，正常运行

    xy.f(ca);    // (5) Consumer接收A和B，实际调用Y的方法传入B，预期正常运行
    // xy.f(cb); // (6) 虽然运行时不会出错，但xy编译类型是X，X的f方法不接受Consumer<B>，编译不通过
}

编译错误信息 #

Testing.java:15: error: name clash: f(Consumer<? super B>) in Y and f(Consumer<? super A>) in X have the same erasure, yet neither overrides the other
            public void f(Consumer<? super B> consumer) {
                        ^
Testing.java:14: error: method does not override or implement a method from a supertype
            @Override
            ^
2 errors

梳理所有调用场景后，只有(2)和(6)是预期的编译错误，核心需求是保证场景(5)（把Consumer<A>传入声明为X类型的Y实例）能正常运行。

从类型理论上分析：用A >= B表示A是B的父类，因为A >= B且? super是逆变通配符，所以Consumer<? super B>是Consumer<? super A>的父类型；而方法参数遵循逆变规则，理论上f(Consumer<? super B>)应该可以重写f(Consumer<? super A>)，但Java编译器不允许这种写法。

原因说明 #

Java方法重写不支持参数逆变，同时由于泛型类型擦除机制，Consumer<? super A>和Consumer<? super B>擦除后都会变成Consumer，导致两个方法签名在字节码层面完全一致，触发名称冲突；而且Java重写要求子类方法的参数类型必须与父类方法的参数类型完全匹配（或满足泛型方法的特定重写规则，这里不属于这种情况），因此编译器判定这不是合法的重写。

可行的替代方案 #

可以通过新增一个重载方法的方式绕过这个限制，保留父类方法的重写实现，同时提供更具体的参数版本：

public class Y extends X {
    @Override
    public void f(Consumer<? super A> consumer) {
        ff(consumer);
    }

    public void ff(Consumer<? super B> consumer) {
        consumer.accept(new B());
    }
}

调整调用方式后，各个场景的运行情况如下：

x.f(ca);     // (1) 正常运行
    // x.f(cb);  // (2) 类型错误，编译不通过

    y.ff(ca);    // (3) 正常运行
    y.ff(cb);    // (4) 正常运行

    xy.f(ca);    // (5) 正常运行，实际调用Y的f方法，转发到ff执行
    // xy.f(cb); // (6) 编译不通过，符合预期

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