使用泛型参数重写泛型方法时发生Java编译错误

Question

import java.util.Collection;

public abstract class A {

    public class R<T> { }

    public abstract <X> R<X> get1();

    public abstract <X> R<X> get2(Collection<String> p);

    public abstract <X> R<X> get3(Collection<Integer> p);

    public class B extends A {

        @Override
        public R<Object> get1() {
            return null;
        }

        @Override
        public R<Object> get2(Collection<String> p) {
            return null;
        }   

        @Override
        public <Object> R<Object> get3(Collection<Integer> p) {
            return null;
        }
    }
}

get1方法工作正常，但get2存在编译错误：

>

类型A.B的方法get2（集合）必须重写或实现超类型方法

只有带有泛型的参数才会出现此错误<代码>get3编译，但当然有一个警告：

>

显然还有其他方法可以解决这个问题，但在我的理解中，这应该是一个法律优先事项，我的问题更多的是为什么会有这个编译错误。提前谢谢！

编辑：

对不起，我的例子不够清楚。因此，这里有一个新的答案来回应你的一些观点。

public abstract class A {

    public abstract class R<T> { }

    public abstract <X> R<X> get();

    public abstract <Y> R<Y> get2(Collection<String> p);

    public abstract <Z> R<Z> get3(Collection<Integer> p);

    public class B extends A {

        @Override
        public R<String> get() {
            return null;
        }

        @Override
        public R<Double> get2(Collection<String> p) {
            return null;
        }   

        @Override
        public <V> R<V> get3(Collection<Integer> p) {
            return null;
        }
    }
}

• 与上述get2相同的编译错误，以及get的明显类型安全警告，我也希望在get2上获得。
• 我希望每个方法都有自己的类型，所以类类型不是解决方案。
• 在这个例子中使用Object是一个错误的决定，但这不是我的观点，旧get3的类型隐藏问题如上所述很清楚。
• 问题就出在签名上，就像lancore说的，所以我要评论一下他的回答。

Answer 1

之所以B.get2（）没有覆盖A.get2（）是因为根据JLS，这两个类型参数不相同。。。

...如果以下两个都为真，则两个方法或构造函数M1和M2具有相同的类型参数：...

>

其中 n _{是n的类型参数，设θ=[B1：=A1，…，Bn：=An]。然后，对于所有<代码>i（1≤ 我≤ n） ，Ai的界与应用于Bi的界的θ的类型相同。}

A. get2（）具有公共摘要

为了使JLS具有合法的覆盖情况，两种方法必须是JLS所称的覆盖等效方法。。。

...两个方法签名M1和M2是覆盖等效的，如果M1是M2的子签名或M2是M1的子签名...

除非两个方法中的一个是另一个的子签名，否则这两个方法不能重写为等价的。。。

...

方法签名是方法签名的子签名，如果存在以下任一情况：。。。

1. M的签名与M的签名相同
2. M的签名与M的签名的擦除（§4.6）相同

...

两个方法不能是彼此的子签名，除非它们具有相同的签名。。。

...如果两个方法具有相同的名称和参数类型，则它们具有相同的签名...

您的两个方法没有相同的签名，因为它们不满足JLS的相同参数类型条件。。。

...

如果以下所有条件都成立，则两个方法或构造函数声明M和N具有相同的参数类型：

1. 它们具有相同数量的形式参数（可能为零）
2. 它们具有相同数量的类型参数（可能为零）
3. 设A1，...， An为M的类型参数，设B1，...， Bn为N的类型参数。将N中的Bi的每次出现重命名为Ai后，对应类型变量的界限相同，M和N的形式参数类型相同。

...

因此，对于编译的B.get2（），以及对于100%类型安全的B.get（），您需要将方法更改为重写等效方法。

最简单的方法是使它们具有与它们覆盖的A中的类型参数相同数量的类型参数...

import java.util.Collection;

public abstract class A {

    public abstract class R<T> {

    public abstract <X> R<X> get();

    public abstract <Y> R<Y> get2(Collection<String> p);

    public abstract <Z> R<Z> get3(Collection<Integer> p);

    public static class B extends A {

        @Override
        public <T> R<T> get() {
            return null;
        }

        @Override
        public <U> R<U> get2(Collection<String> p) {
            return null;
        }

        @Override
        public <V> R<V> get3(Collection<Integer> p) {
            return null;
        }
    }
}

Answer 2

正如Ghost Cat已经提到的，get3中的Object实际上是一个类型变量。有趣的是，您应该使用什么，但名称令人困惑。

要修复内部类，必须为所有3个方法重新声明泛型类型参数：

public class B extends A
{
    @Override
    public <X> R<X> get1() {
        return null;
    }

    @Override
    public <X> R<X> get2(Collection<String> p) {
        return null;
    }

    @Override
    public <X> R<X> get3(Collection<Integer> p) {
        return null;
    }
}

然而，所有这些重复的<代码>

abstract class A<X>
{
    public class R<T> { }

    public abstract R<X> get1();

    public abstract R<X> get2(Collection<String> p);

    public abstract R<X> get3(Collection<Integer> p);

    public class B extends A<X>
    {
        @Override
        public R<X> get1() {
            return null;
        }

        @Override
        public R<X> get2(Collection<String> p) {
            return null;
        }

        @Override
        public R<X> get3(Collection<Integer> p) {
            return null;
        }
    }
}

如果B属于所有Objects（从您的示例中看不清楚），您可以将上面的内部类替换为：

public class B extends A<Object>
{
    @Override
    public R<Object> get1() {
        return null;
    }

    @Override
    public R<Object> get2(Collection<String> p) {
        return null;
    }

    @Override
    public R<Object> get3(Collection<Integer> p) {
        return null;
    }
}

Answer 3

在这里：

public <Object> R<Object> get3(Collection<Integer> p) {

可能不是你的意思。

您正在这里引入另一个类型变量，称为Object。

将其与：

public R<Object> get2(Collection<String> p) {

换句话说：get2（）使用java.lang.对象。get3（）使用一个泛型类型，不幸的是，它被命名为Object。你也可以写

public <NONSENSE> R<NONSENSE> get3(Collection<Integer> p) {

最后：get2（）也不是您要做的。请参阅迈克尔关于该部分的精彩回答。