jls。返回类型可替换。这是什么意思？

Question

我正在阅读 jls 并且遇到以下术语：

return-type-substitutable

来自 jls 的 sn-p

返回类型为 R1 的方法声明 d1 是 返回类型可替代具有返回类型 R2 的另一种方法 d2 如果以下任何一项为真：

如果 R1 无效，则 R2 无效。

如果 R1 是原始类型，则 R2 与 R1 相同。

如果 R1 是引用类型，则以下情况之一为真：

--R1，适应于d2的类型参数（§8.4.4），是一个子类型 R2。

--R1 可以通过未经检查的转换转换为 R2 的子类型 (§5.1.9)。

--d1 与 d2 (§8.4.2) 没有相同的签名，并且 R1 = |R2|。

前两点很清楚。

你能说清楚吗

--R1，适配d2的类型参数（§8.4.4），是R2的子类型。

--R1 可以通过未经检查的转换（第 5.1.9 节）转换为 R2 的子类型。

--d1 与 d2 (§8.4.2) 没有相同的签名，并且 R1 = |R2|。

谢谢

附： 路易吉·门多萨

interface Foo {
        List<String> foo(String arg1, String arg2);
}

class Bar implements Foo {
    @Override
    public ArrayList<String> foo(String arg1, String arg2) {
        //implementation...
        return  null;
    }

    public String foo(String arg1, String arg2, String arg3) {
        //implementation...
        return  null;
    }
}

它是工作变体。

我的问题的原因 - 我想了解 jls 中的以下短语：

如果返回类型为 R1 的方法声明 d1 覆盖或隐藏 用返回类型 R2 声明另一个方法 d2，那么 d1 必须是 d2 的返回类型可替换（第 8.4.5 节）或编译时错误 发生

规则：

If R1 is a reference type then **one of the following** is true:
...
--d1 does not have the same signature as d2 (§8.4.2), and R1 = |R2|.
...

代码：

interface Foo {
        List<String> foo(String arg1, String arg2);
}

class Bar implements Foo {
    @Override
    public List<String> anotherName(String arg1, String arg2,Object obj) {
           return  null;
    }

这是编译错误。

R1==R2 (List<String > == List<String>)

d1!=d2

我在哪里违反了规则？

Answer 1

让我们拥有这个界面

interface Foo {
    List<String> foo(String arg1, String arg2);
}

还有一个实现它的类

class Bar implements Foo {
    @Override
    public List<String> foo(String arg1, String arg2) {
        //implementation...
    }
}

我们有：

• Bar#foo 为 d1
• List<String> 在 d1 中返回类型为 R1。
• Foo#foo 为 d2
• List<String> 在 d2 中返回类型为 R2。

R1，适配d2的类型参数（§8.4.4），是R2的子类型。

这意味着R1可以是R2的子类型，这意味着R1应该通过IS-A测试。所以，我们可以做到以下几点：

class Bar implements Foo {
    @Override
    public ArrayList<String> foo(String arg1, String arg2) {
        //implementation...
    }
}

可以通过未经检查的转换 (§5.1.9) 将 R1 转换为 R2 的子类型。

这与泛型有关。这意味着R1 应该通过 IS-A 测试，即使它针对未经检查的覆盖抛出警告。所以，我们可以做到以下几点：

class Bar implements Foo {
    @Override
    public ArrayList foo(String arg1, String arg2) {
        //implementation...
    }
}

d1 与 d2 (§8.4.2) 没有相同的签名，并且 R1 = |R2|

这意味着重载：

class Bar implements Foo {
    @Override
    public ArrayList<String> foo(String arg1, String arg2) {
        //implementation...
    }

    public ArrayList<String> foo(String arg1, String arg2, String arg3) {
        //implementation...
    }
}

Answer 2

如果返回类型为 R1 的方法声明 d1 覆盖或隐藏了返回类型为 R2 的另一个方法 d2 的声明，则 d1 必须是 d2 的返回类型可替换（第 8.4.5 节），否则会出现编译时错误以 d2 (§8.4.2) 的形式出现，并且 R1 = |R2|。

让我们分解一下：

首先，我们需要一个方法声明d2和一个返回类型R2：

class SomeClass {
    public List<String> d2() {
        return null;
    }
}

现在，我们定义一个扩展 SomeClass 的类，它定义了 d1 并返回 R1。

class AnotherClass extends SomeClass {
    //@Override annotation means it is overriding a method in parent class
    //d2 here is d1
    //Object here is R1
    @Override
    public List<String> d2() {
    }
}

如何编译？因为d1 可以替换d2，这意味着R1 可以替换R2 作为返回类型。这也称为covariant return type，并在Java Tutorials. Returning a Value from a Method 中进行了介绍。另一条规则支持这一点：

如果以下任何一项为真，则返回类型为 R1 的方法声明 d1 可替代返回类型为 R2 的另一个方法 d2：如果 R1 是引用类型，则以下条件之一为真：d1 不与 d2 (§8.4.2) 具有相同的签名，并且 R1 = |R2|。

这意味着所有这些方法都可以有效地覆盖SomeClass#d2：

class AnotherClass extends SomeClass {
    //ArrayList implements List
    @Override
    public ArrayList<String> d2() {
        return null;
    }
}

class AnotherClass extends SomeClass {
    //raw List can be casted to `List<String>` by unchecked conversion
    //means you don't need a explicit cast to convert `List` to `List<String>`
    //due to type erasure
    @Override
    public List d2() {
        return null;
    }
}

class AnotherClass extends SomeClass {
    //combination of both examples above
    @Override
    public ArrayList d2() {
        return null;
    }
}

但这些都是无效的实现：

class AnotherClass extends SomeClass {
    //the signature is not the same
    @Override
    public List<String> d1() {
        return null;
    }
}

class AnotherClass extends SomeClass {
    //Set is not a subtype of List
    @Override
    public Set<String> d2() {
        return null;
    }
}

class AnotherClass extends SomeClass {
    //Collection is not a subtype of List
    @Override
    public Collection<String> d2() {
        return null;
    }
}