ความแตกต่างระหว่าง <คืออะไร ขยายฐาน> และ <T ขยายฐาน>?

ในตัวอย่างนี้:

import java.util.*;

public class Example {
    static void doesntCompile(Map<Integer, List<? extends Number>> map) {}
    static <T extends Number> void compiles(Map<Integer, List<T>> map) {}

    static void function(List<? extends Number> outer)
    {
        doesntCompile(new HashMap<Integer, List<Integer>>());
        compiles(new HashMap<Integer, List<Integer>>());
    }
}

doesntCompile() ไม่สามารถคอมไพล์ด้วย:

Example.java:9: error: incompatible types: HashMap<Integer,List<Integer>> cannot be converted to Map<Integer,List<? extends Number>>
        doesntCompile(new HashMap<Integer, List<Integer>>());
                      ^

ขณะcompiles()ที่คอมไพเลอร์ยอมรับ

คำตอบนี้อธิบายว่าความแตกต่างเพียงอย่างเดียวคือไม่เหมือน<? ...>กัน<T ...>ให้คุณอ้างอิงประเภทในภายหลังซึ่งดูเหมือนจะไม่เป็นเช่นนั้น

ความแตกต่างระหว่าง<? extends Number>และ<T extends Number>ในกรณีนี้คืออะไรและทำไมไม่รวบรวมครั้งแรก

โดยการกำหนดวิธีการที่มีลายเซ็นต่อไปนี้:

static <T extends Number> void compiles(Map<Integer, List<T>> map) {}

และกล่าวอ้างเหมือน:

compiles(new HashMap<Integer, List<Integer>>());

ใน jls §8.1.2เราพบว่า (ส่วนที่น่าสนใจเป็นตัวหนาโดยฉัน):

ประกาศคลาทั่วไปกำหนดชุดของประเภทแปร (§4.5) หนึ่งสำหรับแต่ละภาวนาเป็นไปได้ของส่วนประเภทพารามิเตอร์โดยข้อโต้แย้งประเภท ประเภทพารามิเตอร์ทั้งหมดเหล่านี้ใช้คลาสเดียวกัน ณ เวลาทำงาน

ในคำอื่น ๆ ชนิดถูกจับคู่กับประเภทของการป้อนข้อมูลและได้รับมอบหมายT ลายเซ็นจะกลายเป็นได้อย่างมีประสิทธิภาพIntegerstatic void compiles(Map<Integer, List<Integer>> map)

เมื่อพูดถึงdoesntCompileวิธีการ jls จะกำหนดกฎของการพิมพ์ย่อย ( §4.5.1 , เป็นตัวหนาโดยฉัน):

อาร์กิวเมนต์ชนิด T1 ถูกกล่าวว่ามีอาร์กิวเมนต์ชนิดอื่น T2 ซึ่งเขียน T2 <= T1 หากชุดของประเภทที่แสดงด้วย T2 นั้นเป็นเซตย่อยของชุดประเภทที่แสดงด้วย T1 ภายใต้การปิดแบบสะท้อนและการสลับของกฎต่อไปนี้ ( โดยที่ <: หมายถึงการพิมพ์ย่อย (§4.10)):

• ? ขยาย T <=? ขยาย S ถ้า T <: S

• ? ขยาย T <=?

• ? Super T <=? super S ถ้า S <: T

• ? Super T <=?

• ? Super T <=? ขยายวัตถุ

• T <= T

• T <=? ยืด T

• T <=? ซุปเปอร์ที

ซึ่งหมายความว่าที่? extends NumberจริงมีIntegerหรือแม้กระทั่งList<? extends Number>มีList<Integer>แต่มันไม่ใช่กรณีและMap<Integer, List<? extends Number>> Map<Integer, List<Integer>>ข้อมูลเพิ่มเติมเกี่ยวกับหัวข้อนั้นสามารถพบได้ในเธรด SOนี้ คุณยังสามารถสร้างเวอร์ชันด้วย?wildcard ได้โดยประกาศว่าคุณคาดว่าจะมีประเภทย่อยของList<? extends Number>:

public class Example {
    // now it compiles
    static void doesntCompile(Map<Integer, ? extends List<? extends Number>> map) {}
    static <T extends Number> void compiles(Map<Integer, List<T>> map) {}

    public static void main(String[] args) {
        doesntCompile(new HashMap<Integer, List<Integer>>());
        compiles(new HashMap<Integer, List<Integer>>());
    }
}

ในการโทร:

compiles(new HashMap<Integer, List<Integer>>());

T Map<Integer,List<Integer>>จะจับคู่กับจำนวนเต็มดังนั้นประเภทของการโต้แย้งเป็น ไม่ใช่กรณีของวิธีการdoesntCompile: ประเภทของการโต้แย้งยังคงอยู่Map<Integer, List<? extends Number>>สิ่งที่อาร์กิวเมนต์ที่เกิดขึ้นจริงในการโทร; และนั่นไม่สามารถกำหนดได้HashMap<Integer, List<Integer>>ได้

UPDATE

ในdoesntCompileวิธีการไม่มีสิ่งใดป้องกันคุณให้ทำสิ่งนี้:

static void doesntCompile(Map<Integer, List<? extends Number>> map) {
    map.put(1, new ArrayList<Double>());
}

เห็นได้ชัดว่ามันไม่สามารถยอมรับHashMap<Integer, List<Integer>>ว่าเป็นข้อโต้แย้ง

ตัวอย่างที่เรียบง่ายของการสาธิต ตัวอย่างเดียวกันสามารถเห็นภาพเหมือนด้านล่าง

static void demo(List<Pair<? extends Number>> lst) {} // doesn't work
static void demo(List<? extends Pair<? extends Number>> lst) {} // works
demo(new ArrayList<Pair<Integer>()); // works
demo(new ArrayList<SubPair<Integer>()); // works for subtype too

public static class Pair<T> {}
public static class SubPair<T> extends Pair<T> {}

List<Pair<? extends Number>>เป็นสัญลักษณ์แทนหลายระดับในขณะที่List<? extends Number>เป็นสัญลักษณ์แทนมาตรฐาน

การสร้างอินสแตนซ์ที่ถูกต้องที่เป็นรูปธรรมของประเภท wild card List<? extends Number>รวมถึงNumberและชนิดย่อยใด ๆ ของNumberในกรณีList<Pair<? extends Number>>ที่เป็นอาร์กิวเมนต์ประเภทของการโต้แย้งประเภทและตัวเองมีการสร้างอินสแตนซ์ที่เป็นรูปธรรมของประเภททั่วไป

Generics มีค่าคงที่ดังนั้นชนิดป่าการ์ดสามารถยอมรับได้Pair<? extends Number> Pair<? extends Number>>ประเภท Inner ? extends Numberเป็น covariant แล้ว คุณต้องสร้างประเภทการปิดล้อมเป็น covariant เพื่อให้ความแปรปรวนร่วม

ฉันขอแนะนำให้คุณดูในเอกสารของสัญลักษณ์ตัวแทนทั่วไปโดยเฉพาะแนวทางสำหรับการใช้สัญลักษณ์แทน

พูดวิธีการของคุณอย่างตรงไปตรงมา #doesntCompile

static void doesntCompile(Map<Integer, List<? extends Number>> map) {}

และโทรเช่น

doesntCompile(new HashMap<Integer, List<Integer>>());

พื้นฐานไม่ถูกต้อง

เพิ่มการบังคับใช้ทางกฎหมาย :

    static void doesntCompile(Map<Integer, List<? extends Number>> map) {
        List<Double> list = new ArrayList<>();
        list.add(0.);
        map.put(0, list);
    }

เป็นเรื่องที่ดีจริงๆเพราะ Double ขยาย Number ดังนั้นการวางList<Double>จึงดีอย่างแน่นอนList<Integer>ใช่มั้ย

อย่างไรก็ตามคุณยังคงถือว่าถูกกฎหมายที่จะส่งผ่านnew HashMap<Integer, List<Integer>>()จากตัวอย่างของคุณที่นี่หรือไม่

คอมไพเลอร์ไม่คิดอย่างนั้นและพยายามอย่างที่สุดที่จะหลีกเลี่ยงสถานการณ์เช่นนี้

ลองทำสิ่งเดียวกันกับเมธอด #compile และคอมไพเลอร์จะเห็นได้ชัดว่าไม่อนุญาตให้คุณใส่รายการคู่ในแผนที่

    static <T extends Number> void compiles(Map<Integer, List<T>> map) {
        List<Double> list = new ArrayList<>();
        list.add(10.);
        map.put(10, list); // does not compile
    }

โดยทั่วไปคุณสามารถใส่อะไร แต่List<T>ที่ว่าทำไมมันปลอดภัยที่จะเรียกวิธีการนั้นด้วยnew HashMap<Integer, List<Integer>>()หรือnew HashMap<Integer, List<Double>>()หรือหรือnew HashMap<Integer, List<Long>>()new HashMap<Integer, List<Number>>()

โดยสังเขปคุณกำลังพยายามที่จะโกงคอมไพเลอร์และมันก็ป้องกันการโกงอย่างเป็นธรรม

NB: คำตอบที่โพสต์โดยMaurice Perryถูกต้องอย่างแน่นอน ฉันไม่แน่ใจว่าชัดเจนเพียงพอลอง (หวังว่าฉันจะจัดการได้) เพื่อเพิ่มโพสต์ที่ครอบคลุมมากขึ้น