jls. заменяемый возвращаемый тип. Что это означает?

Давайте иметь этот интерфейс

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 as d1
• List<String> тип возврата в d1 как R1.
• Foo#foo as 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...
    }
}

R1 можно преобразовать в подтип R2 путем непроверенного преобразования (§5.1.9).

Это больше относится к дженерикам. Это означает, что 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...
    }
}

Если объявление метода d1 с типом возвращаемого значения R1 переопределяет или скрывает объявление другого метода d2 с типом возвращаемого значения R2, ​​то d1 должен быть заменяемым по типу возвращаемого значения (§8.4.5) для d2, или ошибка времени компиляции возникает как 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 в качестве типа возвращаемого значения. Это также называется ковариантным типом возврата и рассматривается в Учебники по Java. Возврат значения из метода. Это подтверждается другим правилом:

Объявление метода d1 с типом возвращаемого значения R1 может быть заменено по типу возвращаемого значения другим методом d2 с типом возвращаемого значения R2, ​​если выполняется любое из следующих условий: Если R1 является ссылочным типом, то выполняется одно из следующих условий: подпись как 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;
    }
}