Generics Java - dlaczego „rozszerza T” jest dozwolone, a nie „implementuje T”?

Zastanawiam się, czy jest jakiś szczególny powód w Javie, aby zawsze używać „ extends” zamiast „ implements” do definiowania granic parametrów.

Przykład:

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

jest zabronione, ale

public class A<B extends C>{} 

jest poprawne. Jaki jest tego powód?

Nie ma semantycznej różnicy w ogólnym języku ograniczeń między tym, czy klasa „implementuje”, czy „rozszerza”. Możliwościami ograniczeń są „rozszerzenia” i „super” - to znaczy, czy ta klasa może działać z możliwością przypisania do tej drugiej (rozszerzenie), czy też ta klasa może być przypisana z tej (super).

Odpowiedź znajduje się tutaj  :

Aby zadeklarować parametr typu ograniczonego, należy podać nazwę parametru typu, a następnie extendssłowo kluczowe, a następnie jego górną granicę […]. Zauważ, że w tym kontekście rozszerzenie jest używane w ogólnym znaczeniu, aby oznaczać albo extends(jak w klasach) albo implements(jak w interfejsach).

Więc masz, to trochę mylące i Oracle o tym wie.

Prawdopodobnie dlatego, że dla obu stron (B i C) istotny jest tylko typ, a nie implementacja. W twoim przykładzie

public class A<B extends C>{}

B może być również interfejsem. „extends” służy do definiowania pod-interfejsów oraz podklas.

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

Zwykle myślę o „Sub rozszerza Super”, ponieważ „ Sub jest jak Super , ale z dodatkowymi możliwościami”, a „Clz implementuje Intf”, ponieważ „ Clz jest realizacją Intf ”. W twoim przykładzie byłoby to zgodne: B jest jak C , ale z dodatkowymi możliwościami. Możliwości są tutaj istotne, a nie realizacja.

Może się zdarzyć, że typ podstawowy jest parametrem ogólnym, więc rzeczywisty typ może być interfejsem klasy. Rozważać:

class MyGen<T, U extends T> {

Również z perspektywy kodu klienta interfejsy są prawie nie do odróżnienia od klas, podczas gdy dla podtypu jest to ważne.

Oto bardziej zaangażowany przykład tego, gdzie rozszerzenie jest dozwolone i ewentualnie czego chcesz:

public class A<T1 extends Comparable<T1>>

To rodzaj arbitralnie używanego terminu. Tak mogło być w obu przypadkach. Być może projektanci języków uważali „rozszerzenie” za najbardziej podstawowy termin i „implementuje” jako specjalny przypadek interfejsów.

Ale myślę, że implementsmiałoby to nieco więcej sensu. Myślę, że to przekazuje więcej, że typy parametrów nie muszą być w relacji dziedziczenia, mogą być w jakiejkolwiek relacji podtypu.

Glosariusz Java wyraża podobny pogląd .

Jesteśmy przyzwyczajeni

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

a wszelkie niewielkie odstępstwa od tych zasad bardzo nas dezorientują.

Składnia powiązanego typu jest zdefiniowana jako

TypeBound:
    extends TypeVariable 
    extends ClassOrInterfaceType {AdditionalBound}

^{( JLS 12> 4.4. Zmienne typu>TypeBound )}

Gdybyśmy to zmienili, z pewnością dodalibyśmy tę implementssprawę

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

i kończą się dwiema identycznie przetworzonymi klauzulami

ClassOrInterfaceType:
    ClassType 
    InterfaceType

^{( JLS 12> 4.3. Typy referencyjne i wartości>ClassOrInterfaceType )}

z wyjątkiem tego, że musielibyśmy się również zająć implements, co jeszcze bardziej skomplikowałoby sprawę.

Wierzę, że jest to główny powód, dla którego extends ClassOrInterfaceTypestosuje się zamiast extends ClassTypei implements InterfaceType- aby zachować rzeczy proste w skomplikowanym pojęciem. Problem polega na tym, że nie mamy odpowiedniego słowa, aby opisać jedno extendsi drugie i na implementspewno nie chcemy go przedstawić.

<T is ClassTypeA>
<T is InterfaceTypeA>

Chociaż extendswprowadza pewien bałagan, gdy idzie w parze z interfejsem, jest to szerszy termin i można go użyć do opisania obu przypadków. Spróbuj dostroić umysł do koncepcji rozszerzenia typu (nie rozszerzania klasy , nie implementowania interfejsu ). Ograniczasz parametr typu innym typem i nie ma znaczenia, co to właściwie jest. Liczy się tylko to, że jest to górna granica i jego nadtyp .

W rzeczywistości, gdy używa się ogólnego interfejsu, słowo kluczowe również się rozszerza . Oto przykład kodu:

Istnieją 2 klasy, które implementują interfejs powitania:

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

I kod testowy:

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