มีคุณสมบัติสำคัญสามประการของวัตถุที่มุ่งเน้น: การห่อหุ้มมรดกและความหลากหลาย จากมุมมองที่แน่นอนการห่อหุ้มและการสืบทอดเกือบทั้งหมดเตรียมไว้สำหรับ polymorphism นี่คือแนวคิดสุดท้ายของเราและจุดความรู้ที่สำคัญที่สุด
1. คำจำกัดความ:
Polymorphism: หมายถึงการอนุญาตให้วัตถุประเภทต่าง ๆ ตอบสนองต่อข้อความเดียวกัน นั่นคือข้อความเดียวกันสามารถนำพฤติกรรมที่แตกต่างต่างกันไปตามวัตถุต่าง ๆ ที่ส่งมา (การส่งข้อความคือการเรียกใช้ฟังก์ชัน)
2. เทคโนโลยีที่ใช้ polymorphism เรียกว่า: การเชื่อมโยงแบบไดนามิกซึ่งหมายถึงการตัดสินประเภทที่แท้จริงของวัตถุที่อ้างอิงในระหว่างการดำเนินการและเรียกใช้วิธีการที่สอดคล้องกันตามประเภทจริง
3. ฟังก์ชั่น: กำจัดความสัมพันธ์ระหว่างการมีเพศสัมพันธ์ระหว่างประเภท
4. ในความเป็นจริงมีตัวอย่างนับไม่ถ้วนของความหลากหลาย ตัวอย่างเช่นการกดปุ่ม F1 หากเอกสารช่วยเหลือ AS3 ในขณะนี้ปรากฏขึ้นภายใต้อินเทอร์เฟซแฟลช หากคำว่าความช่วยเหลือนั้นเกิดขึ้นในปัจจุบันภายใต้คำว่า หากความช่วยเหลือของ Windows ในขณะนี้โผล่ขึ้นมาภายใต้ความช่วยเหลือและการสนับสนุนของ Windows เหตุการณ์เดียวกันเกิดขึ้นกับวัตถุที่แตกต่างกันและให้ผลลัพธ์ที่แตกต่างกัน
5. ด้านล่างเป็นเงื่อนไขที่จำเป็นสามประการสำหรับการดำรงอยู่ของ polymorphic ซึ่งต้องการให้ทุกคนจดจำมันเมื่อฝัน!
เงื่อนไขที่จำเป็นสามประการสำหรับ polymorphism
1. จะต้องมีมรดก;
2. จะต้องมีการเขียนใหม่
3. การอ้างอิงคลาสหลักชี้ไปที่วัตถุคลาสเด็ก
6. ประโยชน์ของ polymorphism:
1) ความสามารถในการทดแทน: polymorphism มีความสามารถในการแทนกันสำหรับรหัสที่มีอยู่ ตัวอย่างเช่น polymorphism ทำงานบนระดับวงกลมวงกลมและยังทำงานกับเรขาคณิตวงกลมอื่น ๆ เช่นวงกลม
2) Extensibility: polymorphism สามารถขยายได้กับรหัส การเพิ่มคลาสย่อยใหม่ไม่ส่งผลกระทบต่อการทำงานและการทำงานของความหลากหลายของคลาสที่มีอยู่การสืบทอดและลักษณะอื่น ๆ ในความเป็นจริงมันง่ายกว่าที่จะได้รับฟังก์ชั่น polymorphic โดยการเพิ่มคลาสย่อยใหม่ ตัวอย่างเช่นบนพื้นฐานของการตระหนักถึงความหลากหลายของกรวยเซมิโคนและซีกโลกมันเป็นเรื่องง่ายที่จะเพิ่มความหลากหลายของทรงกลม
3) ความสามารถในการเชื่อมต่อ: polymorphism ทำได้โดย superclasses ผ่านลายเซ็นวิธีการให้อินเทอร์เฟซทั่วไปกับคลาสย่อยและคลาสย่อยจะถูกนำไปใช้โดยการปรับปรุงหรือเขียนทับพวกเขา ดังแสดงในรูปที่ 8.3 ในรูปรูปร่างสุดยอดจะระบุวิธีการอินเทอร์เฟซสองวิธีที่ใช้ polymorphism, computearea () และ computeVolume () คลาสย่อยเช่นวงกลมและทรงกลมปรับปรุงหรือแทนที่วิธีการอินเทอร์เฟซทั้งสองนี้เพื่อให้บรรลุความหลากหลาย
4) ความยืดหยุ่น: สะท้อนให้เห็นถึงการดำเนินงานที่ยืดหยุ่นและหลากหลายในแอปพลิเคชันและปรับปรุงประสิทธิภาพการใช้งาน
5) ความเรียบง่าย: polymorphism ลดความซับซ้อนของกระบวนการเขียนรหัสและการปรับเปลี่ยนของซอฟต์แวร์แอปพลิเคชันโดยเฉพาะอย่างยิ่งเมื่อต้องรับมือกับการดำเนินงานและการดำเนินงานของวัตถุจำนวนมากคุณลักษณะนี้มีความโดดเด่นและสำคัญเป็นพิเศษ
รหัสกรณีแมวและสุนัข
สัตว์ชั้น {โมฆะสาธารณะกิน () {system.out.println ("กิน");} การนอนหลับสาธารณะ () {system.out.println ("sleep");}} สุนัขชั้นเรียนขยายสัตว์ {public void eat () {system.out.out.outln ("dog eat meet"); ขยายสัตว์ {โมฆะสาธารณะ Eat () {system.out.println ("แมวกินปลา");} การนอนหลับสาธารณะ () {system.out.println ("แมวนอนหลับอยู่บนท้อง");}} หมูชั้นเรียน {System.out.println ("หมูนอนหลับอยู่ข้าง");}} // คลาสเครื่องมือสำหรับการดำเนินงานสัตว์ชั้น AnimalTool {Private AnimalTool () {}/* // การเรียกใช้ฟังก์ชั่นของแมว C.SLEEP (); } // การเรียกใช้ฟังก์ชั่นของ Dog Public Public Static Void useg (Dog D) {d.eat (); d.sleep (); } // การเรียกใช้ฟังก์ชั่นของหมูเป็นโมฆะคงที่ USEPIG (หมู p) {p.eat (); p.sleep (); } */โมฆะคงที่สาธารณะ useanimal (สัตว์ a) {a.eat (); a.sleep ();} // คลาสความเป็นไปได้ทั้งหมดในสัตว์} คลาส duotaidemo2 {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {// ฉันชอบแมวมาก cat (); c2.eat (); c2.sleep (); // ฉันชอบแมวโดยเฉพาะและมีแมวตัวอื่น c3 = แมวตัวใหม่ (); c3.eat (); c3.sleep (); // ... system.out.println ("-----------------------") เรียกวิธีการนี้คุณไม่คิดว่ามันจะคล้ายกันมากเหรอ? เป็นเพียงว่าชื่อวัตถุนั้นแตกต่างกัน // เรากำลังวางแผนที่จะใช้วิธีการปรับปรุง // เรียกใช้วิธีการปรับปรุงเวอร์ชัน // usecat (c); // usecat (c2); // usecat (c3); // imanttool.usecat (c); // imanttool.usecat (c2); // imanttool.usecat (c2); // imanttool.usecat (c2) C3); Animaltool.useanimal (C2); Animaltool.useanimal (C2); imenttool.useanimal (C3); System.out.println ("--------------------"); // i เหมือนสุนัขสุนัข d = สุนัขใหม่ (); สุนัข d2 = สุนัขตัวใหม่ (); สุนัข d3 = ใหม่ dog (); // imanttool.usedog (d); // imanttool.usedog (d2); // imanttool.usedog (d3); imanttool.useanimal (d); imenttool.useanimal (d2); imenttool.useanimal ( d2); imanttool.useanimal (d3); system.out.println ("-------------------------------------------------------------------------------------------------------------------------------------- - หมู (); // imenttool.usepig (p); // imanttool.usepig (p2); // imanttool.usepig (p3); Animaltool.useanimal (p2); imenttool.useanimal (p2); imenttool.useanimal (p3); Leopard ... // กำหนดคลาสที่สอดคล้องกัน, มรดกสัตว์, ให้วิธีการที่สอดคล้องกัน, และเพิ่มวิธีการโทรไปยังคลาสเครื่องมือ // สองสามคนต้องเขียนฉันไม่มีการคัดค้าน // อย่างไรก็ตามคลาสเครื่องมือเปลี่ยนไปทุกครั้ง โมฆะคงที่ USECAT (CAT C) {C.EAT ();7. วิธีการใช้งานของ polymorphism ใน Java: การใช้งานอินเตอร์เฟส, การสืบทอดคลาสแม่สำหรับวิธีการเขียนใหม่และวิธีการโอเวอร์โหลดในคลาสเดียวกัน
8. การจำแนกประเภทของ polymorphisms ใน Java:
ในชวา polymorphisms สามารถแบ่งออกเป็นประมาณสถานการณ์ต่อไปนี้:
1) บุคคลคือชั้นเรียนหลักและนักเรียนคือชั้นเรียนเด็ก จากนั้น: personp = newstudent ();
2) Fliable เป็นอินเทอร์เฟซและนกเป็นคลาสที่ใช้อินเทอร์เฟซดังนั้น: fliablef = newBird ();
3) Fliable เป็นคลาสที่เป็นนามธรรมนกเป็นคลาสที่สืบทอดมาอย่างมีไหวพริบดังนั้น: fliablef = newbird ();
เมื่อ polymorphism มีความจำเป็นที่จะต้องระบุว่า P ประกาศว่าเป็นการอ้างอิงถึงคลาสหลัก แต่จริงๆแล้วมันเป็นการอ้างอิงถึงชั้นเด็ก แต่เขาสามารถโทรหาวิธีการในชั้นเรียนหลักเท่านั้น หากวิธีการในคลาสย่อยแทนที่เมธอดพาเรนต์คลาสเมธอดพาเรนต์คลาส (การเรียกวิธีการเสมือน) จะถูกเรียก เช่นเดียวกับความหลากหลายของอินเทอร์เฟซ บางทีคุณอาจถามว่าถ้า F ต้องการเรียกวิธีการของตัวเองหรือไม่นั่นจะไม่ทำผิดพลาด? ในความเป็นจริงนี่เป็นวิธีการครอบคลุมวิธีการเนื่องจากคลาสย่อยที่ใช้อินเตอร์เฟสจะใช้วิธีการในอินเทอร์เฟซอย่างแน่นอนดังนั้นในกรณีนี้วิธีการในนกเรียกว่า แต่ถ้านกมีวิธีที่ไม่ได้กำหนดไว้ในอินเทอร์เฟซ F ก็ไม่สามารถเรียกได้ว่า F
9. ผู้ประกอบการระหว่างประเทศ:
กลไก polymorphic ของภาษา Java ทำให้ประเภทการประกาศของตัวแปรอ้างอิงไม่สอดคล้องกับประเภทของวัตถุอ้างอิงจริง เมื่อรวมกับกฎการเรียกใช้วิธีการเสมือนจริงเราสามารถสรุปได้ว่าตัวแปรอ้างอิงสองตัวที่ประกาศว่าเป็นประเภทเดียวกันอาจมีพฤติกรรมที่แตกต่างกันเมื่อเรียกใช้วิธีเดียวกัน ตัวดำเนินการอินสแตนซ์ของมีการแนะนำที่นี่
ดังนั้นถ้าฉันประกาศ personp = newstudent (); ฉันสามารถแปลง P เป็นนักเรียนได้หรือไม่? แน่นอนว่ามันสามารถทำได้ แต่ต้องถูกบังคับ (ลูกชายต้องการเป็นพ่อและเขาจะมาโดยตรง แต่ถ้าพ่อต้องการเป็นลูกชายเขาจะถูกบังคับ)
โดยปกติจะมีการเพิ่มอินสแตนซ์ของการคัดเลือก
if (pinstanceofstudent) {นักเรียน = (นักเรียน) p;}
Polymorphism ไหลผ่านการเรียนรู้ Java ทั้งหมด ตัวอย่างเช่นเมื่อเขียนคำสั่งจับเมื่อจัดการข้อยกเว้นเรากำหนดว่าจะต้องเขียนข้อยกเว้นคลาสย่อยที่จะต้องเขียนข้อยกเว้นด้านหน้าและชั้นพาณิชย์จะต้องเขียนที่ด้านหลัง ทำไม เหตุผลคือความหลากหลาย รูปแบบคำสั่งจับของเรา: catch (excende) เมื่อมีการสร้างข้อยกเว้นโปรแกรม Java จะสร้างวัตถุข้อยกเว้นโดยอัตโนมัติ หากมีการสร้างข้อยกเว้นระดับเด็กก่อนและข้อยกเว้นคลาสแม่ถูกเขียนไว้ข้างหน้าคำสั่งจับนี้จะถูกดำเนินการอย่างแน่นอนตาม polymorphism และมันจะกระโดดออกมาหลังจากดำเนินการคำสั่งจับ
10. ตัวอย่าง:
แม้ว่าฉันจะไม่เข้าใจความหลากหลายของ Java เป็นอย่างดี แต่ตัวอย่างต่อไปนี้ทำให้ฉันเข้าใจบางอย่าง:
Class A {Public String Show (D obj) .. {return ("A และ D");} Public String Show (a obj) .. {return ("A และ A");}} class B ขยาย {public String show (b obj) .. {return ("b และ b"); b {} คลาส E {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {a a1 = ใหม่ a (); a2 = ใหม่ b (); b b = new b (); c c = ใหม่ c (); d d = ใหม่ d (); System.out.println (a1.show (b)); // ①system.out.println (a1.show (c)); // ②system.out.println (a1.show (d)); //③system.out.println(A2.SHOW(B)); ⑥system.out.println (b.show (b)); // ⑦system.out.println (b.show (c)); // ⑧system.out.println (b.show (d)); //}}}}(iii) คำตอบ
① a และ a ② a และ a ③ a และ d ④ b และ a ⑤ b และ a ⑥ a และ d ⑦ b และ b ⑧ b และ b ⑨ a และ d
**** มีคำตอบของคนดี ****
มีสองประเด็นสำคัญสำหรับปัญหานี้:
หนึ่งคือความสัมพันธ์ระหว่างคลาสย่อยและคลาสพาเรนต์และอื่น ๆ คือปัญหาของการเรียกวิธีการมากเกินไป
วัตถุคลาสย่อยสามารถใช้โดยตรงเป็นวัตถุหลัก แต่อย่างอื่นพวกเขาไม่สามารถ ตัวอย่างเช่นผู้คนคือชั้นเรียนหลักและนักเรียนเป็นคลาสย่อยของคนดังนั้นวัตถุนักเรียนจะต้องมีคุณลักษณะของวัตถุมนุษย์ แต่วัตถุของมนุษย์อาจไม่จำเป็นต้องมีลักษณะของวัตถุนักเรียน ดังนั้นวัตถุนักเรียนสามารถใช้เป็นวัตถุของมนุษย์ได้ แต่วัตถุของมนุษย์ไม่สามารถใช้เป็นวัตถุนักเรียนได้ โปรดทราบว่าเมื่อใช้วัตถุ subclass เป็นวัตถุหลักวัตถุ subclass จะสูญเสียคุณสมบัติ subclass ทั้งหมดและเก็บแอตทริบิวต์และวิธีการที่มีชื่อเดียวกันกับคลาสแม่ (วิธีชื่อเดียวกันไม่เพียง แต่ชื่อฟังก์ชันเดียวกัน แต่ยังประเภทพารามิเตอร์จะต้องเหมือนกันมิฉะนั้นจะไม่ถูกเก็บไว้)
หากวิธีการโอเวอร์โหลดถูกกำหนดในคลาสระบบจะเลือกและเรียกใช้วิธีที่เหมาะสมโดยอัตโนมัติตามประเภทของพารามิเตอร์เมื่อเรียกวิธีการ
1) A1.SHOWS (B) ไม่มีวิธีที่มีพารามิเตอร์คลาส B ใน A แต่วิธีการที่มีพารามิเตอร์คลาส A เรียกว่าตามหลักการที่คลาสแม่ของวัตถุ subclass นั้นมีอยู่ดังนั้นจึงมีการเรียกวิธีการ
publicStringshow(Aobj)...{return("AandA");}
2) A1.Show (C), คลาส C เป็นคลาสย่อยของคลาส B และคลาส B เป็นคลาสย่อยของคลาส A ดังนั้นวัตถุคลาส C สามารถใช้เป็นวัตถุคลาส A ผลที่ได้คือเช่นเดียวกับข้างต้น
3) A1.SHOW (D) เรียกวิธีโดยตรงใน A ตามประเภทพารามิเตอร์
publicStringshow(Dobj)...{
return("AandD");}
4) A2.SHOW (B), A2 เดิมเป็นวัตถุ B แต่มันถูกกำหนดให้กับตัวแปรคลาส A ดังนั้น A2 เท่านั้นที่ยังคงคุณสมบัติและวิธีการที่มีชื่อเดียวกันกับคลาสแม่ A. A2.SHOW (B) เรียกวิธีการที่สงวนไว้ในคลาส B ที่มีชื่อเดียวกันกับคลาสแม่และพารามิเตอร์เดียวกัน
public String show(A obj)...{
return ("B and A");
}
5) A2.SHOW (C), วิธีการสงวนของคลาส B ไม่มีวิธีพารามิเตอร์คลาส C แต่มีวิธีการพารามิเตอร์ของคลาสแม่ที่มี C ดังนั้นวิธีที่เรียกว่า
public String show(A obj)...{
return ("B and A");
}
ฉันคิดว่าคำอธิบายนี้มีเหตุผลมากกว่า: A2 เดิมเป็นวัตถุของคลาส B แต่ค่าถูกกำหนดให้กับคลาส A, C เป็นคลาสย่อยของ B และ B เป็นคลาสย่อยของ A ดังนั้น A2 จึงรักษาคุณสมบัติและวิธีการในคลาส B ที่มีชื่อเดียวกันกับ A. A. A. A. A. A. A.
6) a2.show (d) การโทรมาจากคลาส A
public String show(D obj)...{
return ("A and D");
}
7) b.show (b) โทร
public String show(B obj)...{
return ("B and B");
}
8) b.show (c) ไม่มีวิธีการกับพารามิเตอร์ c ในคลาส B แต่มีวิธีการที่มีพารามิเตอร์ B ดังนั้นวิธีการที่เรียกว่า
public String show(B obj)...{
return ("B and B");
}
9) b.show (d) คำอธิบายเหมือนกับ 8
สรุป
ข้างต้นเป็นเนื้อหาทั้งหมดของบทสรุปของบทความนี้เกี่ยวกับความหลากหลายของ Java และฉันหวังว่ามันจะเป็นประโยชน์กับทุกคน หากคุณมีคำถามใด ๆ โปรดฝากข้อความไว้ตลอดเวลาและหวังว่าจะได้รับความคิดเห็นที่มีค่าของคุณ!