Обобщения Java - почему «расширяет T» разрешено, но не «реализует T»?

Интересно, есть ли в Java особая причина использовать всегда " extends", а не " implements" для определения границ параметров типа.

Пример:

public interface C {}
public class A<B implements C>{} 

запрещено, но

public class A<B extends C>{} 

правильно. В чем причина этого?

В родовом языке ограничений нет семантической разницы между «реализацией» или «расширением» класса. Возможны следующие ограничения: «расширяет» и «супер» - то есть, может ли этот класс работать с присваиваемым этому другому (расширяется) или этот класс назначается из этого (супер).

Ответ здесь  :

Чтобы объявить параметр ограниченного типа, укажите имя параметра типа, затем extendsключевое слово и верхнюю границу […]. Обратите внимание, что в этом контексте extends используется в общем смысле для обозначения extends(как в классах) или implements(как в интерфейсах).

Итак, у вас это есть, это немного сбивает с толку, и Oracle это знает.

Вероятно, потому что для обеих сторон (B и C) важен только тип, а не реализация. В вашем примере

public class A<B extends C>{}

B также может быть интерфейсом. «extends» используется для определения подинтерфейсов, а также подклассов.

interface IntfSub extends IntfSuper {}
class ClzSub extends ClzSuper {}

Я обычно думаю о «Sub extends Super» как « Sub похож на Super , но с дополнительными возможностями», а «Clz реализует Intf», так как « Clz - реализация Intf ». В вашем примере это будет соответствовать: B похож на C , но с дополнительными возможностями. Здесь важны возможности, а не реализация.

Может случиться так, что базовый тип является универсальным параметром, поэтому фактический тип может быть интерфейсом класса. Рассматривать:

class MyGen<T, U extends T> {

Также с точки зрения клиентского кода интерфейсы практически неотличимы от классов, тогда как для подтипа это важно.

Вот более сложный пример того, где можно использовать extends и, возможно, что вы хотите:

public class A<T1 extends Comparable<T1>>

Это своего рода произвольно, какой из терминов использовать. Это могло быть так или иначе. Возможно, разработчики языка думали, что «расширяет» как самый фундаментальный термин, и «внедряет» как особый случай для интерфейсов.

Но я думаю, что implementsбыло бы немного больше смысла. Я думаю, это больше говорит о том, что типы параметров не должны быть в отношениях наследования, они могут быть в любом виде отношений подтипа.

Глоссарий Java выражает аналогичную точку зрения .

Мы привыкли к

class ClassTypeA implements InterfaceTypeA {}
class ClassTypeB extends ClassTypeA {}

и любое небольшое отклонение от этих правил очень смущает нас.

Синтаксис привязки типа определяется как

TypeBound:
    extends TypeVariable 
    extends ClassOrInterfaceType {AdditionalBound}

^{( JLS 12> 4.4. Типовые переменные>TypeBound )}

Если бы мы изменили это, мы обязательно добавили бы implementsслучай

TypeBound:
    extends TypeVariable 
    extends ClassType {AdditionalBound}
    implements InterfaceType {AdditionalBound}

и в конечном итоге с двумя одинаково обработанными предложениями

ClassOrInterfaceType:
    ClassType 
    InterfaceType

^{( JLS 12> 4.3. Типы ссылок и значения>ClassOrInterfaceType )}

кроме нас также нужно было бы позаботиться о том implements, что еще больше усложнит ситуацию.

Я полагаю, что это главная причина, почему extends ClassOrInterfaceTypeиспользуется вместо extends ClassTypeи implements InterfaceType- чтобы все было просто в рамках сложной концепции. Проблема в том , что мы не имеем право слова , чтобы охватить как extendsи implementsмы определенно не хотим , чтобы ввести одну.

<T is ClassTypeA>
<T is InterfaceTypeA>

Хотя это extendsвносит некоторую путаницу, когда речь идет о интерфейсе, это более широкий термин, и его можно использовать для описания обоих случаев. Попробуйте настроить свой разум на идею расширения типа (не расширения класса , не реализации интерфейса ). Вы ограничиваете параметр типа другим типом, и не имеет значения, что это за тип на самом деле. Имеет значение только то, что это его верхняя граница и его супертип .

Фактически, при использовании универсального интерфейса, ключевое слово также расширяется . Вот пример кода:

Есть 2 класса, которые реализуют интерфейс приветствия:

interface Greeting {
    void sayHello();
}

class Dog implements Greeting {
    @Override
    public void sayHello() {
        System.out.println("Greeting from Dog: Hello ");
    }
}

class Cat implements Greeting {
    @Override
    public void sayHello() {
        System.out.println("Greeting from Cat: Hello ");
    }
}

И тестовый код:

@Test
public void testGeneric() {
    Collection<? extends Greeting> animals;

    List<Dog> dogs = Arrays.asList(new Dog(), new Dog(), new Dog());
    List<Cat> cats = Arrays.asList(new Cat(), new Cat(), new Cat());

    animals = dogs;
    for(Greeting g: animals) g.sayHello();

    animals = cats;
    for(Greeting g: animals) g.sayHello();
}