การไม่จำเป็นต้องพิมพ์แคสต์เป็นข้อได้เปรียบที่ใหญ่ที่สุดอย่างหนึ่งของ Java genericsเนื่องจากจะทำการตรวจสอบประเภทในเวลาคอมไพล์ สิ่งนี้จะช่วยลดความเป็นไปได้ของClassCastExceptions ที่สามารถส่งออกไปที่รันไทม์และสามารถนำไปสู่โค้ดที่มีประสิทธิภาพมากขึ้น
แต่ฉันสงสัยว่าคุณรู้ดีอยู่แล้ว
ทุกครั้งที่ฉันดู Generics มันทำให้ฉันปวดหัว ฉันพบว่าส่วนที่ดีที่สุดของ Java คือความเรียบง่ายและไวยากรณ์ขั้นต่ำและทั่วไปนั้นไม่ง่ายและเพิ่มไวยากรณ์ใหม่จำนวนมาก
ตอนแรกฉันไม่เห็นประโยชน์ของยาชื่อสามัญเหมือนกัน ฉันเริ่มเรียนรู้ Java จากไวยากรณ์ 1.4 (แม้ว่า Java 5 จะหมดในเวลานั้น) และเมื่อฉันพบกับ generics ฉันรู้สึกว่ามันต้องเขียนโค้ดมากกว่าและฉันก็ไม่เข้าใจประโยชน์จริงๆ
IDE สมัยใหม่ทำให้การเขียนโค้ดด้วย generics ง่ายขึ้น
IDE ที่ทันสมัยและเหมาะสมส่วนใหญ่ฉลาดพอที่จะช่วยในการเขียนโค้ดด้วย generics โดยเฉพาะอย่างยิ่งการเติมโค้ด
นี่คือตัวอย่างของการสร้างMap<String, Integer>ไฟล์HashMap. รหัสที่ฉันต้องพิมพ์คือ:
Map<String, Integer> m = new HashMap<String, Integer>();
HashMapและแน่นอนว่าเป็นจำนวนมากที่จะพิมพ์เพียงเพื่อให้ใหม่ อย่างไรก็ตามในความเป็นจริงฉันต้องพิมพ์เท่านี้ก่อนที่ Eclipse จะรู้ว่าฉันต้องการอะไร:
Map<String, Integer> m = new Ha Ctrl+Space
จริงอยู่ฉันไม่จำเป็นต้องเลือกHashMapจากรายชื่อผู้สมัคร แต่โดยพื้นฐานแล้ว IDE รู้ว่าจะต้องเพิ่มอะไรบ้างรวมถึงประเภททั่วไปด้วย ด้วยเครื่องมือที่เหมาะสมการใช้ยาชื่อสามัญก็ไม่ได้แย่เกินไป
นอกจากนี้เนื่องจากเป็นที่ทราบประเภทเมื่อเรียกใช้องค์ประกอบจากคอลเล็กชันทั่วไป IDE จะทำหน้าที่ราวกับว่าวัตถุนั้นเป็นวัตถุประเภทที่ประกาศอยู่แล้ว - ไม่จำเป็นต้องส่ง IDE เพื่อให้ทราบว่าวัตถุประเภทใด คือ.
ข้อได้เปรียบที่สำคัญของ generics มาจากวิธีที่เล่นได้ดีกับคุณสมบัติใหม่ของ Java 5 นี่คือตัวอย่างของการโยนจำนวนเต็มเป็น a Setและคำนวณผลรวม:
Set<Integer> set = new HashSet<Integer>();
set.add(10);
set.add(42);
int total = 0;
for (int i : set) {
total += i;
}
ในโค้ดนั้นมีคุณลักษณะใหม่ของ Java 5 อยู่สามประการ:
ประการแรกชื่อสามัญและการทำออโตบ็อกซ์แบบดั้งเดิมอนุญาตให้มีบรรทัดต่อไปนี้:
set.add(10);
set.add(42);
จำนวนเต็ม10จะถูกทำให้เป็นออโต้บ็อกซ์Integerโดยมีค่า10เป็น (และเหมือนกันสำหรับ42) จากนั้นIntegerจะถูกโยนเข้าไปในสิ่งSetที่เรียกว่าถือIntegers การพยายามโยนเข้าไปStringอาจทำให้เกิดข้อผิดพลาดในการคอมไพล์
ถัดไปสำหรับแต่ละลูปจะใช้ทั้งสามอย่าง:
for (int i : set) {
total += i;
}
ครั้งแรกที่SetมีIntegers ที่ใช้ในสำหรับแต่ละวง แต่ละองค์ประกอบมีการประกาศให้เป็นintและที่ได้รับอนุญาตเป็นคือไม่มีกล่องกลับไปดั้งเดิมInteger intและความจริงที่ว่าการแกะกล่องนี้เกิดขึ้นเป็นที่ทราบกันดีเนื่องจากมีการใช้ generics เพื่อระบุว่ามีอยู่Integerในไฟล์Set.
Generics สามารถเป็นกาวที่รวบรวมคุณสมบัติใหม่ที่นำมาใช้ใน Java 5 และทำให้การเขียนโค้ดง่ายขึ้นและปลอดภัยยิ่งขึ้น และส่วนใหญ่แล้ว IDE นั้นฉลาดพอที่จะช่วยคุณให้คำแนะนำที่ดีได้ดังนั้นโดยทั่วไปแล้วการพิมพ์จะไม่มากไปกว่านี้
และตรงไปตรงมาดังที่เห็นได้จากSetตัวอย่างฉันรู้สึกว่าการใช้คุณสมบัติ Java 5 สามารถทำให้โค้ดมีความกระชับและมีประสิทธิภาพมากขึ้น
แก้ไข - ตัวอย่างที่ไม่มีชื่อสามัญ
ต่อไปนี้เป็นภาพประกอบของSetตัวอย่างข้างต้นโดยไม่ต้องใช้ยาชื่อสามัญ เป็นไปได้ แต่ไม่น่าพอใจ:
Set set = new HashSet();
set.add(10);
set.add(42);
int total = 0;
for (Object o : set) {
total += (Integer)o;
}
(หมายเหตุ: โค้ดด้านบนจะสร้างคำเตือนการแปลงที่ไม่ได้ตรวจสอบในเวลาคอมไพล์)
เมื่อมีการใช้คอลเลกชันที่ไม่ใช่ยาชื่อสามัญ, Objectประเภทที่มีการลงนามในคอลเลกชันนี้เป็นวัตถุชนิด ดังนั้นในตัวอย่างนี้ a Objectคือสิ่งที่ถูกaddแก้ไขในชุด
set.add(10);
set.add(42);
ในบรรทัดข้างต้นการทำกล่องอัตโนมัติกำลังอยู่ในระหว่างการเล่นซึ่งเป็นintค่าดั้งเดิม10และ42กำลังถูกใส่กล่องอัตโนมัติลงในIntegerวัตถุซึ่งจะถูกเพิ่มลงในไฟล์Set. อย่างไรก็ตามโปรดทราบว่าIntegerอ็อบเจ็กต์ถูกจัดการในรูปแบบObjects เนื่องจากไม่มีข้อมูลประเภทใดที่จะช่วยให้คอมไพเลอร์ทราบว่าSetควรคาดหวังประเภทใด
for (Object o : set) {
นี่คือส่วนที่มีความสำคัญ เหตุผลที่สำหรับแต่ละลูปทำงานได้เนื่องจากอินเทอร์เฟซSetใช้งานIterableซึ่งส่งคืนข้อมูลที่Iteratorมีชนิดหากมีอยู่ ( Iterator<T>นั่นคือ.)
แต่เนื่องจากไม่มีข้อมูลประเภทที่SetจะกลับIteratorซึ่งจะกลับค่าในSetขณะที่ObjectS, และนั่นคือเหตุผลองค์ประกอบถูกเรียกในสำหรับแต่ละวงจะต้องObjectเป็นชนิด
ตอนนี้เมื่อObjectดึงข้อมูลมาSetแล้วจำเป็นต้องส่งไปยังIntegerด้วยตนเองเพื่อดำเนินการเพิ่มเติม:
total += (Integer)o;
นี่เป็น typecast จะดำเนินการจากไปยังObject Integerในกรณีนี้เรารู้ว่าสิ่งนี้จะใช้งานได้เสมอ แต่การพิมพ์ด้วยตนเองมักทำให้ฉันรู้สึกว่าเป็นรหัสที่เปราะบางซึ่งอาจเสียหายได้หากมีการเปลี่ยนแปลงเล็กน้อยที่อื่น (ฉันรู้สึกว่าทุกคนClassCastExceptionรอคอยที่จะเกิดขึ้น แต่ฉันพูดนอกเรื่อง ... )
Integerจะไม่มีกล่องตอนนี้เป็นintและได้รับอนุญาตให้ดำเนินการนอกจากนี้ลงในตัวแปรinttotal
ฉันหวังว่าฉันจะแสดงให้เห็นว่าคุณสมบัติใหม่ของ Java 5 สามารถใช้กับโค้ดที่ไม่ใช่ทั่วไปได้ แต่มันก็ไม่สะอาดและตรงไปตรงมาเท่ากับการเขียนโค้ดด้วย generics และในความคิดของฉันเพื่อใช้ประโยชน์อย่างเต็มที่จากคุณสมบัติใหม่ใน Java 5 เราควรพิจารณาถึง generics ถ้าอย่างน้อยที่สุดก็อนุญาตให้มีการตรวจสอบเวลาคอมไพล์เพื่อป้องกันไม่ให้ตัวพิมพ์ที่ไม่ถูกต้องโยนข้อยกเว้นในรันไทม์