1. แนวคิดพื้นฐานของยาสามัญ
เช่นเดียวกับ C#, Java มีแนวคิดของยาสามัญและการกำหนดพารามิเตอร์ของประเภท ยาสามัญใน Java ปรากฏขึ้นหลังจาก JDK5.0 แต่ยาสามัญใน Java นั้นแตกต่างจากยาชื่อสามัญใน C# ก่อนอื่นจากมุมมองของประเภทการรวบรวม ArrayList <Integer> และ ArrayList <String> ใน Java เป็นประเภทเดียวกัน การลบประเภทจะดำเนินการในระหว่างการรวบรวมและประเภทใน Java เป็น pseudogenerics Pseudogenerics จะได้รับการแนะนำในภายหลัง ประการที่สองเมื่อเพิ่มประเภทข้อมูลพื้นฐานลงในคอลเลกชันเช่น int, int จะถูกแปลงเป็นวัตถุจำนวนเต็มก่อนซึ่งเป็นสิ่งที่เรามักจะเรียกว่าการดำเนินการมวย เมื่อนำองค์ประกอบออกมาวัตถุ Interger จะต้องถูกแปลงเป็นประเภทค่า int นั่นคือการดำเนินการ Unboxing ใน C#, รายการ <int> และรายการ <String> เป็นประเภทที่แตกต่างกัน พารามิเตอร์ทั่วไปจะเป็นตัวยึดหลังจากการรวบรวมและจะไม่ถูกลบ พวกเขาได้รับมอบหมายประเภทจริงที่รันไทม์ พวกเขาถูกสร้างขึ้นในระหว่างการรันไทม์ของระบบและมีตารางวิธีการเสมือนจริงของตัวเองและพิมพ์ข้อมูล การใช้งานนี้เรียกว่าประเภทเงินเฟ้อ (สำหรับประเภทเงินเฟ้อประเภทคอมไพเลอร์ทันทีได้ทำงานเพิ่มประสิทธิภาพจำนวนมากเพื่อแก้ปัญหานี้) นี่คือยาชื่อสามัญที่เรียกว่าจริง ในเวลาเดียวกันเมื่อเพิ่มองค์ประกอบพื้นฐานเช่น int ลงในคอลเลกชันไม่จำเป็นต้องใส่กล่องและไม่จำเป็นต้องไม่ต้องใช้กล่องเมื่อนำองค์ประกอบออกมา ดังนั้นประสิทธิภาพจึงดีกว่า Java Collection ทั่วไป
การแนะนำของยาสามัญใน Java ส่วนใหญ่จะแก้ปัญหาสองปัญหา: 1. ข้อยกเว้นการเปลี่ยนประเภทเกิดขึ้นในระหว่างการรันไทม์ขององค์ประกอบประเภทการรวบรวมและการตรวจสอบประเภทจะถูกเพิ่มในระหว่างประเภทการรวบรวมเวลา 2. การเขียนรหัสซ้ำระหว่างการแก้ปัญหาและอัลกอริทึมสามารถนำกลับมาใช้ใหม่ได้ ต่อไปนี้เป็นตัวอย่างเพื่อแสดงการตรวจสอบประเภทของคอมไพเลอร์
ก่อนอื่นมาดูตัวอย่างที่ไม่ได้ใช้ยาชื่อสามัญ:
arraylist al = new ArrayList (); al.add ("ABC"); al.add ("124"); al.add ("32L");เราสามารถเพิ่มข้อมูลทุกประเภทในคอลเลกชัน AL เมื่อเราต้องการแปลงประเภทเมื่อดึงข้อมูลเช่น:
สตริง s = (สตริง) al.get (0); สตริง s1 = (สตริง) al.get (1); // ในช่วงเวลาการรันจะมีการรายงานข้อผิดพลาดและข้อผิดพลาดการแปลงประเภทจะยาว l = (ยาว) al.get (2);
จากนี้เราจะเห็นได้ว่าเมื่อไม่มีการตรวจสอบประเภทจะลดลงระหว่างการรวบรวม เมื่อนำองค์ประกอบออกมาโปรแกรมเมอร์จำเป็นต้องทราบประเภทของแต่ละองค์ประกอบมิฉะนั้นข้อยกเว้นของการแปลงประเภทอาจเกิดขึ้นในเวลารันไทม์
ดังนั้นมาดูผลประโยชน์ที่นำมาให้เราผ่านคอลเลกชันทั่วไป
ArrayList <String> al1 = new ArrayList <String> (); al1.add ("ABC"); al1.add (1); // เกิดข้อผิดพลาดระหว่างการรวบรวมเมื่อเรายกตัวอย่าง AL1 ด้วยประเภทพารามิเตอร์สตริงเราไม่สามารถเพิ่มองค์ประกอบ int ไม่เช่นนั้นคอมไพเลอร์จะรายงานข้อผิดพลาด โดยปกติจะมีเครื่องหมายข้อผิดพลาดในตัวแก้ไข IDE เช่น eclipse ในเวลาเดียวกันไม่จำเป็นต้องพิมพ์การแปลงเมื่อแยกองค์ประกอบ
ค่าสตริง = al1.get (0); // ไม่จำเป็นต้องมีการแปลงประเภท
นี่คือประโยชน์ของยาสามัญ
จากนั้นมัลติเพล็กซ์ของอัลกอริทึมส่วนใหญ่จะสะท้อนให้เห็นในการมัลติเพล็กซ์ของวิธีการเช่นวิธีเพิ่มของ ArrayList ซึ่งสามารถใช้กับทุกประเภทหรือประเภทที่ จำกัด
2. การใช้ยาชื่อสามัญ
ยาสามัญใน Java ส่วนใหญ่จะใช้ในชั้นเรียนวิธีการและอินเทอร์เฟซ ก่อนอื่นมาดูการใช้ชั้นเรียนสั้น ๆ :
โรงงานคลาส <t> {ค่า T ส่วนตัว; สาธารณะ t getValue () {ค่าคืน; } โมฆะสาธารณะ setValue (t v) {this.value = v; -เพิ่มวิธีการทดสอบ:
โรงงาน <String> f = โรงงานใหม่ <String> (); f.setValue ("โรงงานที่ใช้งาน"); System.out.println (f.getValue ());การใช้อินเทอร์เฟซทั่วไป:
อินเตอร์เฟส myInterface <t, u> {void show (t t, u u); } คลาส showtest ใช้ myInterface <string, integer> {@Override โมฆะสาธารณะแสดง (สตริง t, จำนวนเต็ม u) {system.out.println (t); System.out.println (u); -เมื่อพารามิเตอร์ประเภททั่วไปทำหน้าที่ในชั้นเรียนส่วนใหญ่จะ จำกัด ข้อ จำกัด ประเภทระหว่างหลายฟิลด์และลายเซ็นวิธี เมื่อทำตามวิธีการข้อ จำกัด หลักจะทำบนพารามิเตอร์หลายตัวของวิธีการ ที่นี่พารามิเตอร์ประเภททั่วไปของวิธีการจะไม่ได้รับตัวอย่างอีกต่อไป ให้เราแนะนำข้อ จำกัด ของพารามิเตอร์ประเภทด้านล่างเป็นหลัก
3. ประเภทพารามิเตอร์ข้อ จำกัด
ลองดูตัวอย่างเล็ก ๆ ดังที่แสดงในรหัสต่อไปนี้:
สาธารณะคงที่ <t> t get (t t1, t t2) {ถ้า (t1.compareto (t2)> = 0); // ข้อผิดพลาดการรวบรวม, วิธีการเปรียบเทียบ (t) ไม่ได้กำหนดไว้สำหรับประเภท T. return t1; -คุณสามารถดูข้อความแสดงข้อผิดพลาดของคอมไพเลอร์ วิธีการเปรียบเทียบไม่ได้ถูกกำหนดไว้สำหรับประเภท T หากจำเป็นต้องเปรียบเทียบประเภทใน Java อินเตอร์เฟสที่เปรียบเทียบได้จะต้องใช้งานเพื่อให้วิธีการถูกแทนที่ จากนั้นเราทำการปรับเปลี่ยนต่อไปนี้:
สาธารณะคงที่ <t ขยายการเปรียบเทียบ> t get (t t1, t t2) {// เพิ่มข้อ จำกัด ประเภทถ้า (t1.compareto (t2)> = 0); กลับ T1; -โดยการคัดเลือก T ขยายเปรียบเทียบได้มันแสดงให้เห็นว่า t คือประเภทของอินเทอร์เฟซที่ใช้เปรียบเทียบได้ดังนั้นจึงใช้วิธีการเปรียบเทียบดังนั้นจึงไม่มีข้อผิดพลาดในการรวบรวมเวลา
เมื่อเราใช้ & เพื่อแบ่งส่วนข้อ จำกัด หลายประเภทเราสามารถใช้ & เพื่อแบ่งส่วนคำหลักที่ จำกัด และสามารถขยายได้เท่านั้น ในเวลาเดียวกันเมื่อทั้งอินเทอร์เฟซและประเภทมีอยู่คลาสสามารถวางได้ก่อนและสามารถมีได้เพียงหนึ่งดังที่แสดงด้านล่าง:
<t ขยายวัตถุ & เปรียบเทียบและ serializable>
บทความข้างต้นกล่าวถึงบทบาทและแนวคิดพื้นฐานของ Java Generics โดยสังเขปเป็นเนื้อหาทั้งหมดที่ฉันแบ่งปันกับคุณ ฉันหวังว่าคุณจะให้ข้อมูลอ้างอิงและฉันหวังว่าคุณจะสนับสนุน wulin.com มากขึ้น