Genéricos Java - por que "estende T" é permitido, mas não "implementa T"?

Gostaria de saber se existe uma razão especial em Java para usar sempre " extends" em vez de " implements" para definir limites de parâmetros de tipo.

Exemplo:

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

é proibido, mas

public class A<B extends C>{} 

está correto. Qual o motivo disso?

Não há diferença semântica na linguagem de restrição genérica entre se uma classe 'implementa' ou 'estende'. As possibilidades de restrição são 'extends' e 'super' - ou seja, é essa classe para operar com atribuível a essa outra (extends), ou é essa classe atribuível a essa (super).

A resposta está aqui  :

Para declarar um parâmetro do tipo delimitado, liste o nome do parâmetro do tipo, seguido pela extendspalavra - chave, seguida pelo seu limite superior […]. Observe que, nesse contexto, extends é usado em um sentido geral para significar extends(como nas classes) ou implements(como nas interfaces).

Então, aí está, é um pouco confuso, e a Oracle sabe disso.

Provavelmente porque para ambos os lados (B e C) apenas o tipo é relevante, não a implementação. No seu exemplo

public class A<B extends C>{}

B também pode ser uma interface. "extends" é usado para definir subinterfaces e subclasses.

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

Geralmente penso em 'Sub estende Super' como ' Sub é como Super , mas com recursos adicionais', e 'Clz implementa Intf' como ' Clz é uma realização de Intf '. No seu exemplo, isso corresponderia: B é como C , mas com recursos adicionais. Os recursos são relevantes aqui, não a realização.

Pode ser que o tipo base seja um parâmetro genérico, portanto o tipo real pode ser uma interface de uma classe. Considerar:

class MyGen<T, U extends T> {

Também na perspectiva do código do cliente, as interfaces são quase indistinguíveis das classes, enquanto que para o subtipo é importante.

Aqui está um exemplo mais envolvido de onde estender é permitido e, possivelmente, o que você deseja:

public class A<T1 extends Comparable<T1>>

É meio arbitrário qual dos termos usar. Poderia ter sido de qualquer maneira. Talvez os projetistas da linguagem pensassem em "estender" como o termo mais fundamental e "implementarem" como o caso especial de interfaces.

Mas acho implementsque faria um pouco mais de sentido. Eu acho que isso comunica mais que os tipos de parâmetro não precisam estar em um relacionamento de herança, eles podem estar em qualquer tipo de relacionamento de subtipo.

O Java Glossary expressa uma visão semelhante .

Estamos acostumados

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

e qualquer pequeno desvio dessas regras nos confunde muito.

A sintaxe de um tipo ligado é definida como

TypeBound:
    extends TypeVariable 
    extends ClassOrInterfaceType {AdditionalBound}

^{( JLS 12> 4.4. Variáveis ​​de tipo>TypeBound )}

Se mudássemos, certamente adicionaríamos o implementscaso

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

e termine com duas cláusulas processadas de forma idêntica

ClassOrInterfaceType:
    ClassType 
    InterfaceType

^{( JLS 12> 4.3. Tipos e valores de referência>ClassOrInterfaceType )}

exceto que também precisaríamos cuidar implements, o que complicaria ainda mais as coisas.

Eu acredito que é a principal razão pela qual extends ClassOrInterfaceTypeé usado em vez de extends ClassTypee implements InterfaceType- para manter as coisas simples dentro do conceito complicado. O problema é que não temos a palavra certa para cobrir tanto extendse implementse nós definitivamente não queremos introduzir um.

<T is ClassTypeA>
<T is InterfaceTypeA>

Embora extendstraga alguma confusão quando acompanha uma interface, é um termo mais amplo e pode ser usado para descrever os dois casos. Tente ajustar sua mente ao conceito de estender um tipo (não estender uma classe , não implementar uma interface ). Você restringe um parâmetro de tipo por outro tipo e não importa qual seja esse tipo. Só importa que seja seu limite superior e seu supertipo .

De fato, ao usar genérico na interface, a palavra-chave também é estendida . Aqui está o exemplo de código:

Existem 2 classes que implementam a interface Greeting:

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 ");
    }
}

E o código de teste:

@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();
}