เหตุใดอาร์เรย์ของโควาเรียนท์ แต่ยาสามัญมีค่าคงที่?

จาก Java ที่มีประสิทธิภาพโดย Joshua Bloch

1. อาร์เรย์แตกต่างจากประเภททั่วไปในสองวิธีที่สำคัญ อาร์เรย์แรกเป็น covariant ยาสามัญมีค่าคงที่

2. Covariant นั้นหมายถึงว่าถ้า X เป็นชนิดย่อยของ Y ดังนั้น X [] ก็จะเป็นประเภทย่อยของ Y [] อาร์เรย์เป็น covariant เนื่องจากสตริงเป็นชนิดย่อยของ Object So

   String[] is subtype of Object[]

   ค่าคงที่นั้นหมายถึงโดยไม่คำนึงว่า X เป็นชนิดย่อยของ Y หรือไม่

    List<X> will not be subType of List<Y>.

คำถามของฉันคือทำไมการตัดสินใจที่จะทำให้อาร์เรย์ covariant ใน Java? มีการโพสต์ SO อื่น ๆ เช่นทำไมอาเรย์คงที่ แต่รายการ covariant? แต่ดูเหมือนว่าพวกเขาจะเพ่งความสนใจไปที่ Scala และฉันไม่สามารถติดตามได้

ผ่านวิกิพีเดีย :

Java เวอร์ชันแรกและ C # ไม่ได้รวม generics (หรือที่รู้จักว่าตัวแปรเชิงตัวแปร)

ในการตั้งค่าดังกล่าวทำให้อาร์เรย์มีค่าคงที่ออกกฎโปรแกรม polymorphic ที่มีประโยชน์ ตัวอย่างเช่นลองเขียนฟังก์ชั่นเพื่อสุ่มอาร์เรย์หรือฟังก์ชั่นที่ทดสอบสองอาร์เรย์เพื่อความเท่าเทียมกันโดยใช้Object.equalsวิธีการในองค์ประกอบ การใช้งานไม่ได้ขึ้นอยู่กับชนิดขององค์ประกอบที่แน่นอนที่เก็บไว้ในอาเรย์ดังนั้นจึงควรจะสามารถเขียนฟังก์ชั่นเดียวที่ใช้งานได้กับอาเรย์ทุกประเภท มันง่ายที่จะใช้ฟังก์ชั่นประเภท

boolean equalArrays (Object[] a1, Object[] a2);
void shuffleArray(Object[] a);

อย่างไรก็ตามถ้าประเภทอาร์เรย์ได้รับการปฏิบัติเหมือนไม่คงที่จะสามารถเรียกฟังก์ชันเหล่านี้ได้ในอาร์เรย์ที่มีชนิดObject[]ทั้งหมดเท่านั้น ตัวอย่างเช่นไม่สามารถสับเปลี่ยนอาร์เรย์ของสตริงได้

ดังนั้นทั้ง Java และ C # จึงจัดการกับประเภทอาเรย์อย่างต่อเนื่อง ยกตัวอย่างเช่นใน C # string[]เป็นชนิดย่อยของobject[]และ Java เป็นชนิดย่อยของString[]Object[]

นี้จะตอบคำถามที่ว่า "ทำไมอาร์เรย์ covariant?" หรืออย่างแม่นยำมากขึ้น "ทำไมมีอาร์เรย์ covariant ทำในเวลานั้น ?"

เมื่อแนะนำยาชื่อสามัญพวกเขาไม่ได้ทำโควาเรียนท์ด้วยเหตุผลที่ชี้ให้เห็นในคำตอบนี้โดย Jon Skeet :

ไม่มีที่ไม่ได้เป็นList<Dog> List<Animal>พิจารณาสิ่งที่คุณสามารถทำได้ด้วยList<Animal>- คุณสามารถเพิ่มสัตว์ใด ๆ ลงไป ... รวมถึงแมว ทีนี้คุณสามารถเพิ่มแมวเข้าไปในลูกสุนัขได้ไหม? ไม่ได้อย่างแน่นอน.

// Illegal code - because otherwise life would be Bad
List<Dog> dogs = new List<Dog>();
List<Animal> animals = dogs; // Awooga awooga
animals.add(new Cat());
Dog dog = dogs.get(0); // This should be safe, right?

ทันใดนั้นคุณมีแมวที่สับสนมาก

แรงจูงใจดั้งเดิมสำหรับการทำอาร์เรย์ covariant ที่อธิบายไว้ในบทความ wikipedia ไม่ได้ใช้กับยาสามัญเพราะสัญลักษณ์ตัวแทนทำให้การแสดงออกของความแปรปรวนร่วม (และความแปรปรวน) เป็นไปได้เช่น:

boolean equalLists(List<?> l1, List<?> l2);
void shuffleList(List<?> l);

เหตุผลก็คือทุกอาร์เรย์รู้ประเภทองค์ประกอบในขณะที่การรวบรวมทั่วไปไม่ได้เกิดจากการลบประเภท

ตัวอย่างเช่น:

String[] strings = new String[2];
Object[] objects = strings;  // valid, String[] is Object[]
objects[0] = 12; // error, would cause java.lang.ArrayStoreException: java.lang.Integer during runtime

ถ้าสิ่งนี้ได้รับอนุญาตด้วยคอลเลกชันทั่วไป:

List<String> strings = new ArrayList<String>();
List<Object> objects = strings;  // let's say it is valid
objects.add(12);  // invalid, Integer should not be put into List<String> but there is no information during runtime to catch this

แต่สิ่งนี้จะทำให้เกิดปัญหาในภายหลังเมื่อมีคนพยายามเข้าถึงรายการ:

String first = strings.get(0); // would cause ClassCastException, trying to assign 12 to String

อาจเป็นความช่วยเหลือนี้ : -

ยาสามัญไม่มีความแปรปรวนร่วม

อาร์เรย์ในภาษาจาวาคือ covariant - ซึ่งหมายความว่าถ้าจำนวนเต็มขยายจำนวน (ซึ่งมัน) แล้วไม่เพียง แต่เป็นจำนวนเต็มยังเป็นจำนวน แต่จำนวนเต็ม [] ยังเป็นNumber[]และคุณมีอิสระที่จะผ่านหรือมอบหมายInteger[]ที่Number[]เรียกว่าสำหรับ (เป็นทางการมากขึ้นถ้า Number เป็น supertype ของ Integer ดังนั้นจึงNumber[]เป็น supertype ของInteger[]) คุณอาจคิดว่าเหมือนกันกับประเภททั่วไปเช่นกัน - นั่นList<Number>คือ supertype ของList<Integer>และคุณสามารถผ่านList<Integer>ตำแหน่งที่List<Number>คาดไว้ น่าเสียดายที่มันใช้งานไม่ได้

มันกลับกลายเป็นว่ามีเหตุผลที่ดีที่มันไม่ได้ผล: มันจะทำลายความปลอดภัยทั่วไปที่ควรจะให้ ลองนึกภาพคุณสามารถกำหนดให้เป็นList<Integer> List<Number>จากนั้นรหัสต่อไปนี้จะอนุญาตให้คุณใส่สิ่งที่ไม่ใช่จำนวนเต็มลงในList<Integer>:

List<Integer> li = new ArrayList<Integer>();
List<Number> ln = li; // illegal
ln.add(new Float(3.1415));

เนื่องจาก ln เป็น a List<Number>, การเพิ่ม Float ให้ดูเหมือนอย่างถูกกฎหมาย แต่ถ้า ln ถูกใช้นามแฝงliแล้วมันจะทำลายสัญญาความปลอดภัยประเภทโดยนัยในคำจำกัดความของ li - ว่ามันเป็นรายการของจำนวนเต็มซึ่งเป็นสาเหตุที่ประเภททั่วไปไม่สามารถแปรเปลี่ยนได้

อาร์เรย์มี covariant อย่างน้อยสองเหตุผล:

• มันมีประโยชน์สำหรับคอลเลกชันที่เก็บข้อมูลซึ่งจะไม่เปลี่ยนเป็น covariant สำหรับคอลเลกชันของ T เป็น covariant ที่เก็บสำรองของมันจะต้องเป็น covariant ด้วย ในขณะที่ใครสามารถออกแบบTคอลเลกชันที่ไม่เปลี่ยนรูปซึ่งไม่ได้ใช้เป็นT[]ที่เก็บสำรอง (เช่นใช้ต้นไม้หรือรายการที่เชื่อมโยง) คอลเลกชันดังกล่าวจะไม่น่าจะดำเนินการเช่นเดียวกับที่ได้รับการสนับสนุนโดยอาร์เรย์ บางคนอาจโต้แย้งว่าวิธีที่ดีกว่าในการจัดหาคอลเลกชันที่ไม่เปลี่ยนรูปแบบของโควาเรียนต์จะต้องกำหนดประเภท "อาร์เรย์ที่ไม่เปลี่ยนรูปแบบโควาเรียต์" ที่พวกเขาสามารถใช้ร้านค้าสำรองได้

• อาร์เรย์มักจะถูกทำให้กลายพันธุ์ด้วยโค้ดซึ่งไม่รู้ว่าจะเป็นประเภทใดในนั้น แต่จะไม่ใส่อาร์เรย์ใด ๆ ที่ไม่ได้อ่านจากอาร์เรย์เดียวกัน ตัวอย่างที่สำคัญของเรื่องนี้คือการเรียงลำดับรหัส แนวคิดอาจเป็นไปได้สำหรับประเภทอาเรย์ที่จะรวมวิธีการแลกเปลี่ยนหรือเปลี่ยนแปลงองค์ประกอบ (วิธีการดังกล่าวสามารถใช้ได้กับประเภทอาเรย์ใด ๆ อย่างเท่าเทียมกัน) หรือกำหนดวัตถุ ที่ได้รับการอ่านจากมันและอาจรวมถึงวิธีการจัดเก็บรายการที่อ่านก่อนหน้านี้ในอาเรย์ที่มา หากอาร์เรย์ไม่แปรปรวนรหัสผู้ใช้จะไม่สามารถกำหนดประเภทดังกล่าวได้ แต่รันไทม์อาจรวมวิธีการพิเศษบางอย่าง

ความจริงที่ว่าอาร์เรย์นั้นมีความแปรปรวนร่วมอาจถูกมองว่าเป็นการแฮกที่น่าเกลียด แต่ในกรณีส่วนใหญ่มันจะช่วยในการสร้างรหัสการทำงาน

คุณลักษณะที่สำคัญของประเภทตัวแปรคือความสามารถในการเขียนขั้นตอนวิธีการ polymorphic Arrays.sort()ขั้นตอนวิธีการเช่นที่ทำงานบนโครงสร้างข้อมูลโดยไม่คำนึงถึงค่าพารามิเตอร์เช่น

ด้วยยาชื่อสามัญที่ทำกับตัวแทนประเภท:

<E extends Comparable<E>> void sort(E[]);

เพื่อให้มีประโยชน์อย่างแท้จริงประเภทไวด์การ์ดจำเป็นต้องใช้การจับภาพไวด์การ์ดและต้องใช้ความคิดของพารามิเตอร์ชนิด ไม่มีสิ่งใดที่พร้อมใช้งานในอาร์เรย์เวลาถูกเพิ่มไปยัง Java และอาร์เรย์ของประเภทอ้างอิง covariant อนุญาตวิธีที่ง่ายกว่าในการอนุญาตอัลกอริทึม polymorphic:

void sort(Comparable[]);

อย่างไรก็ตามความเรียบง่ายนั้นเปิดช่องโหว่ในระบบสแตติกชนิด:

String[] strings = {"hello"};
Object[] objects = strings;
objects[0] = 1; // throws ArrayStoreException

ต้องการการตรวจสอบรันไทม์ของการเข้าถึงเพื่อเขียนทุกประเภทอาเรย์

สรุปวิธีการที่ใหม่กว่าเป็นตัวเป็นตนโดย generics ทำให้ระบบประเภทที่ซับซ้อนมากขึ้น แต่ยังพิมพ์ปลอดภัยแบบคงที่ในขณะที่วิธีเก่าที่เรียบง่ายและปลอดภัยน้อยลงแบบคงที่ ผู้ออกแบบภาษาเลือกใช้วิธีที่ง่ายกว่าโดยมีสิ่งสำคัญมากกว่าการปิดช่องโหว่เล็ก ๆ ในระบบพิมพ์ที่ไม่ค่อยทำให้เกิดปัญหา ต่อมาเมื่อ Java ถูกสร้างขึ้นและความต้องการเร่งด่วนได้รับการดูแลพวกเขามีทรัพยากรที่จะทำสิ่งที่ถูกต้องสำหรับ generics (แต่การเปลี่ยนมันสำหรับอาร์เรย์จะทำให้โปรแกรม Java ที่มีอยู่เสียหาย)

ยาชื่อสามัญไม่เปลี่ยนแปลง : จากJSL 4.10 :

... การพิมพ์ย่อยไม่ขยายผ่านประเภททั่วไป: T <: U ไม่ได้หมายความว่าC<T><: C<U>...

และอีกไม่กี่บรรทัด JLS ก็อธิบายว่า
อาร์เรย์เป็นตัวแปรร่วม (กระสุนแรก):

4.10.3 การพิมพ์ย่อยระหว่างประเภทอาเรย์

ฉันคิดว่าพวกเขาตัดสินใจผิดตั้งแต่แรกที่สร้างอาร์เรย์ covariant มันแบ่งความปลอดภัยประเภทตามที่อธิบายไว้ที่นี่และพวกเขาติดอยู่กับที่เนื่องจากความเข้ากันได้ย้อนหลังและหลังจากนั้นพวกเขาพยายามที่จะไม่ทำผิดพลาดเหมือนกันสำหรับทั่วไป และนั่นเป็นหนึ่งในเหตุผลที่Joshua Blochชอบที่จะแสดง arra ys ในข้อ 25 ของหนังสือ "Effective Java (edition ที่สอง)"

สิ่งที่ฉันต้องทำ: เมื่อโค้ดคาดหวังว่าอาร์เรย์ A [] และคุณให้ B [] โดยที่ B เป็นคลาสย่อยของ A มีสองสิ่งที่ต้องกังวลเกี่ยวกับ: เกิดอะไรขึ้นเมื่อคุณอ่านองค์ประกอบอาร์เรย์และสิ่งที่เกิดขึ้นถ้าคุณเขียน มัน. ดังนั้นจึงไม่ยากที่จะเขียนกฎภาษาเพื่อให้แน่ใจว่าความปลอดภัยของประเภทนั้นได้รับการเก็บรักษาไว้ในทุกกรณี (กฎหลักคือการที่ArrayStoreExceptionอาจถูกโยนทิ้งได้หากคุณพยายามที่จะใส่ A ลงใน B []) อย่างไรก็ตามสำหรับคนทั่วไปเมื่อคุณประกาศชั้นเรียนSomeClass<T>มีหลายวิธีที่Tใช้ในเนื้อหาของชั้นเรียนและฉันเดาว่ามันซับซ้อนเกินไปที่จะหาชุดค่าผสมที่เป็นไปได้ทั้งหมดเพื่อเขียนกฎเกี่ยวกับเมื่อใด สิ่งที่ได้รับอนุญาตและเมื่อพวกเขาไม่