สิ่งที่ฉันขาดหายไปในคำตอบอื่น ๆ คือการอ้างอิงว่าสิ่งนี้เกี่ยวข้องกับ co- และ contravariance และ sub- และ supertypes (นั่นคือ polymorphism) โดยทั่วไปและโดยเฉพาะกับ Java โดยเฉพาะ สิ่งนี้อาจเป็นที่เข้าใจกันดีโดย OP แต่ในกรณีนี้มันจะไป:
แปรปรวน
หากคุณมีคลาสAutomobileแล้วCarและTruckเป็นประเภทย่อยของพวกเขา รถยนต์ใด ๆ สามารถกำหนดให้กับตัวแปรประเภทรถยนต์ซึ่งเป็นที่รู้จักกันดีใน OO และเรียกว่าความหลากหลาย ความแปรปรวนร่วมหมายถึงการใช้หลักการเดียวกันนี้ในสถานการณ์ที่มีบุคคลทั่วไปหรือผู้รับมอบสิทธิ์ Java ไม่มีผู้รับมอบสิทธิ์ (ยัง) ดังนั้นคำนี้ใช้กับ generics เท่านั้น
ฉันมักจะคิดว่าความแปรปรวนร่วมเป็นความหลากหลายมาตรฐานสิ่งที่คุณคาดหวังว่าจะได้ผลโดยไม่ต้องคิดเพราะ:
List<Car> cars;
List<Automobile> automobiles = cars;
// You'd expect this to work because Car is-a Automobile, but
// throws inconvertible types compile error.
อย่างไรก็ตามเหตุผลของข้อผิดพลาดคือถูกต้อง: List<Car> ไม่ได้รับมรดกจากList<Automobile>และไม่สามารถกำหนดให้กันและกันได้ เฉพาะพารามิเตอร์ประเภททั่วไปเท่านั้นที่มีความสัมพันธ์แบบสืบทอด อาจมีคนคิดว่าคอมไพเลอร์ Java ไม่ฉลาดพอที่จะเข้าใจสถานการณ์ของคุณที่นั่นอย่างถูกต้อง อย่างไรก็ตามคุณสามารถช่วยคอมไพเลอร์ได้โดยให้คำแนะนำแก่เขา:
List<Car> cars;
List<? extends Automobile> automobiles = cars; // no error
contravariance
การกลับกันของความแปรปรวนร่วมเป็นสิ่งที่ตรงกันข้าม ในกรณีที่ความแปรปรวนร่วมประเภทพารามิเตอร์ต้องมีความสัมพันธ์ประเภทย่อยในทางตรงกันข้ามพวกเขาต้องมีความสัมพันธ์แบบซุปเปอร์ไทป์ สิ่งนี้ถือได้ว่าเป็นการสืบทอดขอบเขตบน: อนุญาตให้ใช้ซุปเปอร์ชนิดใดก็ได้และรวมถึงประเภทที่ระบุด้วย:
class AutoColorComparer implements Comparator<Automobile>
public int compare(Automobile a, Automobile b) {
// Return comparison of colors
}
สามารถใช้กับCollections.sort :
public static <T> void sort(List<T> list, Comparator<? super T> c)
// Which you can call like this, without errors:
List<Car> cars = getListFromSomewhere();
Collections.sort(cars, new AutoColorComparer());
คุณสามารถเรียกมันด้วยตัวเปรียบเทียบที่เปรียบเทียบวัตถุและใช้กับประเภทใดก็ได้
เมื่อใดควรใช้การตรงกันข้ามหรือความแปรปรวนร่วม?
บางทีคุณอาจจะไม่ได้ถาม แต่มันช่วยให้เข้าใจในการตอบคำถามของคุณ โดยทั่วไปเมื่อคุณได้รับบางสิ่งบางอย่างให้ใช้ความแปรปรวนร่วมและเมื่อคุณใส่อะไรลงไปให้ใช้ความแตกต่าง สิ่งนี้อธิบายได้ดีที่สุดในคำตอบสำหรับคำถาม Stack Overflow จะใช้ความแตกต่างใน Java generics ได้อย่างไร? .
แล้วมันคืออะไร List<? extends Map<String, String>>
คุณสามารถใช้extendsเพื่อให้กฎระเบียบสำหรับการแปรปรวนมีผลบังคับใช้ ที่นี่คุณมีรายการแผนที่และแต่ละรายการที่คุณจัดเก็บในรายการจะต้องเป็นMap<string, string>หรือได้มาจากแผนที่นั้น คำสั่งList<Map<String, String>>ไม่ได้มาจากMapแต่ต้องเป็นไฟล์ Map .
ดังนั้นสิ่งต่อไปนี้จะใช้งานได้เนื่องจากTreeMapสืบทอดมาจากMap:
List<Map<String, String>> mapList = new ArrayList<Map<String, String>>();
mapList.add(new TreeMap<String, String>());
แต่สิ่งนี้จะไม่:
List<? extends Map<String, String>> mapList = new ArrayList<? extends Map<String, String>>();
mapList.add(new TreeMap<String, String>());
และสิ่งนี้จะไม่ได้ผลเช่นกันเนื่องจากไม่เป็นไปตามข้อ จำกัด ของความแปรปรวนร่วม:
List<? extends Map<String, String>> mapList = new ArrayList<? extends Map<String, String>>();
mapList.add(new ArrayList<String>()); // This is NOT allowed, List does not implement Map
อะไรอีก?
สิ่งนี้อาจชัดเจน แต่คุณอาจสังเกตแล้วว่าการใช้extendsคีย์เวิร์ดจะใช้กับพารามิเตอร์นั้นเท่านั้นไม่ใช่กับพารามิเตอร์ที่เหลือ กล่าวคือสิ่งต่อไปนี้จะไม่รวบรวม:
List<? extends Map<String, String>> mapList = new List<? extends Map<String, String>>();
mapList.add(new TreeMap<String, Element>()) // This is NOT allowed
สมมติว่าคุณต้องการอนุญาตประเภทใดก็ได้ในแผนที่โดยใช้คีย์เป็นสตริงคุณสามารถใช้extendกับพารามิเตอร์แต่ละประเภทได้ กล่าวคือสมมติว่าคุณประมวลผล XML และต้องการจัดเก็บ AttrNode, Element และอื่น ๆ ในแผนที่คุณสามารถทำสิ่งต่างๆเช่น:
List<? extends Map<String, ? extends Node>> listOfMapsOfNodes = new...;
// Now you can do:
listOfMapsOfNodes.add(new TreeMap<Sting, Element>());
listOfMapsOfNodes.add(new TreeMap<Sting, CDATASection>());