Java jenerikleri - “T'yi genişletir” neden “T'yi uygular” a izin verilmiyor?

Java'da daktilometrelerin sınırlarını tanımlamak için her zaman " extends" yerine " " kullanmak için özel bir neden olup olmadığını merak ediyorum implements.

Misal:

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

yasak ama

public class A<B extends C>{} 

doğru. Bunun nedeni nedir?

Bir sınıfın 'uygulama' veya 'genişletme' arasında genel kısıtlama dilinde anlamsal bir fark yoktur. Kısıtlama olasılıkları 'genişletir' ve 'süper' dir - yani, bu sınıf diğerine atanabilir (genişletir), yani bu sınıf ondan (süper) atanabilir.

Cevap burada  :

Sınırlı tür parametresi bildirmek için, tür parametresinin adını, ardından extendsanahtar sözcüğünü ve ardından üst sınırını […] listeleyin . Bu bağlamda, genişletmelerin genel anlamda extends(sınıflarda olduğu gibi) veya implements(arayüzlerde olduğu gibi ) anlamında kullanıldığını unutmayın .

İşte burada, biraz kafa karıştırıcı ve Oracle biliyor.

Muhtemelen her iki taraf için de (B ve C) sadece tür ilgili, uygulama için geçerli değildir. Örneğinizde

public class A<B extends C>{}

B de bir arayüz olabilir. "extends" alt arabirimlerin yanı sıra alt sınıfları tanımlamak için kullanılır.

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

Ben genellikle 'olarak 'Alt Süper uzanır' düşünmek Alt gibidir Super ancak ek yeteneklere sahip' ve 'üç döngü halinde uygular intf' 'olarak üç döngü halinde bir hayata geçirilmesidir intf '. Örneğin, bu eşleşecektir: B , C gibidir , ancak ek yeteneklere sahiptir. Yetenekler burada gerçekleşiyor, gerçekleşme ile değil.

Temel tür genel bir parametre olabilir, bu nedenle gerçek tür bir sınıfın arabirimi olabilir. Düşünmek:

class MyGen<T, U extends T> {

Ayrıca istemci kodu perspektifinden, arayüzler sınıflardan neredeyse ayırt edilemezken, alt tip için önemlidir.

Aşağıda, genişletmelerin nereye izin verildiğine ve muhtemelen ne istediğinize ilişkin daha kapsamlı bir örnek verilmiştir:

public class A<T1 extends Comparable<T1>>

Hangi terimlerin kullanılacağını keyfi bir şekilde. Her iki şekilde de olabilirdi. Belki de dil tasarımcıları en temel terim olarak “uzanır” ve arayüzler için özel bir durum olarak “uygular” diye düşünürler.

Ama bence implementsbiraz daha mantıklı. Parametre türlerinin kalıtım ilişkisinde olması gerekmediğini daha çok ilettiğini, herhangi bir alt tip ilişkide olabileceğini düşünüyorum .

Java Sözlüğü de benzer bir görüş ifade eder .

Biz alışkınız

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

ve bu kurallardan ufak bir sapma bizi çok şaşırtıyor.

Bağlanan türün sözdizimi şu şekilde tanımlanır:

TypeBound:
    extends TypeVariable 
    extends ClassOrInterfaceType {AdditionalBound}

^{( JLS 12> 4.4. Tür Değişkenleri>TypeBound )}

Değiştirecek olsaydık, kesinlikle implementsdavayı eklerdik

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

ve aynı şekilde işlenmiş iki cümle ile sonuçlanır

ClassOrInterfaceType:
    ClassType 
    InterfaceType

^{( JLS 12> 4.3. Referans Tipleri ve Değerleri>ClassOrInterfaceType )}

tek fark etmemiz gerekecek implements, ki bu da işleri daha da zorlaştıracak.

İnanıyorum ki bunun extends ClassOrInterfaceTypeyerine kullanılmasının ana nedeni extends ClassTypeve implements InterfaceType- karmaşık konsept içinde işleri basit tutmak. Sorun biz de kapsayacak şekilde doğru kelime yok olduğunu extendsve implementsve kesinlikle bir tane tanıtmak istemiyorum.

<T is ClassTypeA>
<T is InterfaceTypeA>

Her ne kadar extendsbir arayüz ile birlikte gittiğinde bazı karışıklık getirir, daha geniş bir terimdir ve her iki vakaları tanımlamak için kullanılabilir. Zihninizi bir tür genişletme kavramına ayarlamaya çalışın ( bir sınıfı genişletmemek , bir arabirim uygulamak değil ). Bir tür parametresini başka bir türle kısıtlarsınız ve bu türün gerçekte ne olduğu önemli değildir. Sadece onun üst sınırı ve onun süper tipi olduğu önemlidir .

Aslında, arabirimde jenerik kullanırken, anahtar kelime de genişletilir . Kod örneği:

Selamlama arabirimini uygulayan 2 sınıf vardır:

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

Ve test kodu:

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