Java generics - ทำไม“ ขยาย T” อนุญาต แต่ไม่“ ใช้ T”

ฉันสงสัยว่ามีเหตุผลพิเศษใน Java ที่ใช้เสมอ " extends" มากกว่า " implements" เพื่อกำหนดขอบเขตของพารามิเตอร์

ตัวอย่าง:

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

เป็นสิ่งต้องห้าม แต่

public class A<B extends C>{} 

ถูกต้อง. อะไรคือเหตุผลสำหรับสิ่งนั้น?

ไม่มีความแตกต่างทางความหมายในภาษาข้อ จำกัด ทั่วไประหว่างคลาส 'นำไปใช้' หรือ 'ขยาย' ความเป็นไปได้ของข้อ จำกัด คือ 'ขยาย' และ 'ยอดเยี่ยม' - นั่นคือเป็นคลาสนี้ที่จะทำงานโดยมอบหมายให้กับอีกคนหนึ่ง (ขยาย) หรือเป็นชั้นที่กำหนดได้จากอันนี้ (super)

คำตอบอยู่ที่นี่  :

หากต้องการประกาศพารามิเตอร์ชนิดที่มีขอบเขตให้แสดงรายการชื่อของพารามิเตอร์ประเภทตามด้วยextendsคำหลักตามด้วยขอบเขตด้านบน […] โปรดทราบว่าในบริบทนี้การขยายจะใช้ในความหมายทั่วไปเพื่อหมายถึงextends(เช่นในคลาส) หรือimplements(ในอินเทอร์เฟซ)

คุณก็มีแล้วมันค่อนข้างสับสนและ Oracle ก็รู้

อาจเป็นเพราะทั้งสองด้าน (B และ C) มีเพียงประเภทเท่านั้นที่เกี่ยวข้องไม่ใช่การนำไปใช้ ในตัวอย่างของคุณ

public class A<B extends C>{}

B สามารถเป็นส่วนต่อประสานได้เช่นกัน "extends" ใช้เพื่อกำหนดอินเทอร์เฟซย่อยรวมถึงคลาสย่อย

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

ฉันมักจะคิดว่า 'Sub ขยาย Super' เป็น ' Subเป็นเหมือนSuperแต่มีความสามารถเพิ่มเติม' และ 'Clz ใช้ Intf' เนื่องจาก ' Clzเป็นสำนึกของIntf ' ในตัวอย่างของคุณสิ่งนี้จะจับคู่: Bเป็นเหมือนCแต่มีความสามารถเพิ่มเติม ความสามารถมีความเกี่ยวข้องที่นี่ไม่ใช่การรับรู้

อาจเป็นได้ว่าประเภทฐานเป็นพารามิเตอร์ทั่วไปดังนั้นประเภทจริงอาจเป็นส่วนต่อประสานของคลาส พิจารณา:

class MyGen<T, U extends T> {

นอกจากนี้จากอินเทอร์เฟซมุมมองรหัสลูกค้าเกือบจะแยกไม่ออกจากคลาสในขณะที่สำหรับชนิดย่อยเป็นสิ่งสำคัญ

นี่คือตัวอย่างที่เกี่ยวข้องเพิ่มเติมเกี่ยวกับตำแหน่งที่อนุญาตให้ขยายและอาจเป็นสิ่งที่คุณต้องการ:

public class A<T1 extends Comparable<T1>>

เป็นข้อตกลงและเงื่อนไขที่จะใช้โดยพลการ มันอาจเป็นไปได้ทั้งสองทาง บางทีผู้ออกแบบภาษาอาจคิดว่า "ขยาย" เป็นคำพื้นฐานที่สุดและ "ใช้" เป็นกรณีพิเศษสำหรับอินเทอร์เฟซ

แต่ฉันคิดว่าimplementsมันสมเหตุสมผลกว่าเล็กน้อย ฉันคิดว่าการสื่อสารเพิ่มเติมว่าประเภทพารามิเตอร์ไม่จำเป็นต้องอยู่ในความสัมพันธ์ในการสืบทอดพวกเขาสามารถอยู่ในความสัมพันธ์ประเภทย่อยใด ๆ

ชวาคำศัพท์เป็นการแสดงออกถึงมุมมองที่คล้ายกัน

เราเคยชินกับ

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