การผูกแบบคงที่ การผูกแบบคงที่และการผูกแบบไดนามิก วัตถุคลาสฐาน

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

การเชื่อมโยงโดยนัย การเชื่อมโยงโดยนัยหรือการเชื่อมโยงเวลาโหลดเป็นวิธีที่ง่ายกว่าในเทคนิคการเชื่อมโยงทั้งสองแบบ ขั้นตอนการดำเนินการกรณี โดยใช้ไมโครซอฟต์ C++ เป็นดังนี้:1. หลังจากรวบรวมฟังก์ชันทั้งหมดที่จำเป็นสำหรับ DLL ใหม่แล้ว

การเชื่อมโยงที่ชัดเจน การเชื่อมโยงอย่างชัดเจนหรือการเชื่อมโยงรันไทม์ ต้องการให้โปรแกรมให้คำแนะนำเฉพาะเกี่ยวกับเวลาที่จะโหลดหรือปล่อย DLL- ต่อไปโปรแกรมจะได้รับที่อยู่ตามที่ร้องขอ

11.9.3 การเชื่อม เซิร์ฟเวอร์ DHCP จะรักษาตารางการแมประหว่างไคลเอนต์และพารามิเตอร์การกำหนดค่า การเชื่อมโยงประกอบด้วยการกำหนดที่อยู่ IP และชุดการกำหนดค่าให้กับลูกค้าแต่ละราย

สถานะแบบคงที่ คำสำคัญแบบคงที่ในการประกาศตัวแปรควรใช้เมื่อคุณต้องการให้ตัวแปรยังคงอยู่ในหน่วยความจำ - เพื่อให้สามารถใช้ค่าได้ - แม้ว่าขั้นตอนจะเสร็จสิ้นการทำงานแล้วก็ตาม ในตัวอย่างต่อไปนี้ ตัวแปร

การเชื่อมโยง ก่อนที่ไคลเอ็นต์จะสามารถเรียกใช้ขั้นตอนระยะไกลได้ จะต้องเชื่อมโยงกับระบบระยะไกลที่มีเซิร์ฟเวอร์ที่จำเป็น ดังนั้นงานผูกจึงแบ่งออกเป็นสอง:? กำลังค้นหาโฮสต์ระยะไกลพร้อมเซิร์ฟเวอร์ที่ต้องการใช่ไหม การค้นหา

9.1.7. Safe Binding A เมื่อใช้งานโอเวอร์โหลด ดูเหมือนว่าโปรแกรมจะมีฟังก์ชันหลายฟังก์ชันในชื่อเดียวกันพร้อมรายการพารามิเตอร์ที่แตกต่างกัน อย่างไรก็ตาม ความสะดวกสบายของคำศัพท์นี้มีเฉพาะในระดับข้อความต้นฉบับเท่านั้น ในส่วนใหญ่

การจัดสรรหน่วยความจำแบบคงที่บนสแต็ก ในพื้นที่ผู้ใช้ การดำเนินการจัดสรรหน่วยความจำจำนวนมาก โดยเฉพาะอย่างยิ่งตัวอย่างบางส่วนที่กล่าวถึงก่อนหน้านี้ สามารถดำเนินการได้โดยใช้สแต็ก เนื่องจากขนาดของพื้นที่หน่วยความจำที่จัดสรรเป็นที่รู้จักในเชิงนิรนัย ใน

ย่อหน้านี้แม้จะสั้น แต่ก็มีความสำคัญมาก - การเขียนโปรแกรมมืออาชีพเกือบทั้งหมดใน Java มีพื้นฐานมาจากการใช้ความหลากหลาย ในขณะเดียวกัน หัวข้อนี้ก็เป็นหนึ่งในหัวข้อที่นักเรียนเข้าใจยากที่สุด ดังนั้นจึงขอแนะนำให้อ่านย่อหน้านี้ซ้ำหลายครั้งอย่างละเอียด

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

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

รหัสโปรแกรมตามการเรียกวิธีไดนามิกมีคุณสมบัติ ความหลากหลาย– รหัสเดียวกันทำงานแตกต่างกันขึ้นอยู่กับประเภทของวัตถุที่เรียกมัน แต่ทำสิ่งเดียวกันในระดับนามธรรมที่เกี่ยวข้องกับซอร์สโค้ดของวิธีการ

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

โมฆะสาธารณะ moveTo(int x, int y)(

นอกจากนี้ กรณีนี้ไม่ได้ใช้ประโยชน์จากความหลากหลาย ดังนั้นเราจะไม่ทำอย่างนั้น

มักเป็นเรื่องที่น่าสงสัยว่าทำไมการนำวิธีนี้ไปใช้จึงควรเขียนในคลาส Abstract Figure ท้ายที่สุดแล้วการเรียกไปยังวิธีการซ่อนและแสดงที่ใช้ในนั้นเมื่อมองแวบแรกควรเป็นการเรียกไปยังวิธีนามธรรม - นั่นคือดูเหมือนว่าพวกมันจะไม่ทำงานเลย!

แต่วิธีการซ่อนและแสดงนั้นเป็นแบบไดนามิก ซึ่งดังที่เราทราบอยู่แล้ว หมายความว่าการเชื่อมโยงชื่อวิธีการและโค้ดที่ปฏิบัติการได้นั้นเสร็จสิ้นในขั้นตอนการทำงานของโปรแกรม ดังนั้นความจริงที่ว่าวิธีการเหล่านี้ถูกระบุในบริบทของคลาส Figure ไม่ได้หมายความว่าจะถูกเรียกจากคลาส Figure! ยิ่งไปกว่านั้น คุณสามารถรับประกันได้ว่าวิธีการซ่อนและแสดงจะไม่ถูกเรียกจากคลาสนี้ ให้เรามีตัวแปร dot1 ประเภท Dot และ Circle1 ประเภท Circle และได้รับการกำหนดการอ้างอิงไปยังวัตถุประเภทที่สอดคล้องกัน มาดูกันว่าการโทร dot1.moveTo(x1,y1) และ Circle1.moveTo(x2,y2) มีพฤติกรรมอย่างไร

เมื่อเรียก dot1.moveTo(x1,y1) เมธอด moveTo จะถูกเรียกจากคลาส Figure อันที่จริง วิธีการนี้ในคลาส Dot ไม่ได้ถูกแทนที่ ซึ่งหมายความว่ามันสืบทอดมาจาก Figure ในเมธอด moveTo คำสั่งแรกคือการเรียกเมธอดไดนามิกซ่อน การใช้งานเมธอดนี้นำมาจากคลาสที่อ็อบเจ็กต์ dot1 เป็นอินสแตนซ์ กำลังเรียก วิธีนี้- นั่นคือจากคลาส Dot ประเด็นนี้จึงถูกซ่อนไว้ จากนั้นพิกัดของวัตถุจะเปลี่ยนไปหลังจากนั้นจึงเรียกวิธีการแสดงแบบไดนามิก การใช้งานเมธอดนี้นำมาจากคลาสที่อ็อบเจ็กต์ dot1 ที่เรียกใช้เมธอดนี้เป็นอินสแตนซ์ นั่นคือจากคลาส Dot ดังนั้นจะมีการแสดงจุดในตำแหน่งใหม่

สำหรับการเรียก Circle1.moveTo(x2,y2) ทุกอย่างจะคล้ายกันอย่างยิ่ง - วิธีการแบบไดนามิกซ่อนและแสดงจะถูกเรียกจากคลาสที่วัตถุ Circle1 เป็นอินสแตนซ์ นั่นคือจากคลาส Circle จึงเป็นวงกลมที่ซ่อนอยู่ในที่เก่าและปรากฏอยู่ในที่ใหม่

กล่าวคือ ถ้าวัตถุเป็นจุด จุดนั้นจะเคลื่อนที่ และถ้าวัตถุเป็นวงกลม วงกลมก็จะเคลื่อนที่ ยิ่งไปกว่านั้น หากสักวันหนึ่งมีคนเขียน เช่น คลาส Ellipse ที่สืบทอดมาจาก Circle และสร้างวัตถุ Ellipse ellipse=new Ellipse(...) จากนั้นการเรียก ellipse.moveTo(...) จะย้ายวงรีไปที่ ตำแหน่งใหม่ และสิ่งนี้จะเกิดขึ้นตามวิธีการใช้งานวิธีการซ่อนและแสดงในคลาส Ellipse โปรดทราบว่าโค้ด polymorphic ของคลาส Figure ที่คอมไพล์เมื่อนานมาแล้วจะใช้งานได้ ความหลากหลายนั้นมั่นใจได้จากข้อเท็จจริงที่ว่าการอ้างอิงถึงวิธีการเหล่านี้ไม่ได้ถูกวางไว้ในโค้ดของวิธี moveTo ณ เวลาคอมไพล์ - จะถูกกำหนดค่าให้เป็นวิธีการที่มีชื่อดังกล่าวจากคลาสของอ็อบเจ็กต์ที่เรียกทันทีในเวลาที่เรียกใช้เมธอด moveTo

ในภาษาการเขียนโปรแกรมเชิงวัตถุ วิธีการไดนามิกสองประเภทจะแตกต่างกัน - ไดนามิกจริงและ เสมือน- ตามหลักการทำงานจะคล้ายกันโดยสิ้นเชิงและแตกต่างกันเฉพาะในคุณสมบัติการใช้งานเท่านั้น การเรียกวิธีการเสมือนนั้นเร็วกว่า การเรียกไดนามิกจะช้ากว่า แต่ Dynamic Methods Table (DMT) ใช้หน่วยความจำน้อยกว่า Virtual Methods Table (VMT) เล็กน้อย

อาจดูเหมือนว่าการเรียกเมธอดไดนามิกนั้นไม่มีประสิทธิภาพด้านเวลาเนื่องจากต้องใช้เวลานานในการค้นหาชื่อ ในความเป็นจริง ไม่มีการค้นหาชื่อในระหว่างการโทร แต่มีการใช้กลไกที่เร็วกว่ามากโดยใช้ตารางวิธีการเสมือน (ไดนามิก) ที่กล่าวถึง แต่เราจะไม่เน้นเฉพาะการใช้งานตารางเหล่านี้เนื่องจาก Java ไม่ได้แยกความแตกต่างระหว่างวิธีการประเภทนี้

วัตถุคลาสฐาน

คลาส Object เป็นคลาสพื้นฐานสำหรับคลาส Java ทั้งหมด ดังนั้นฟิลด์และวิธีการทั้งหมดจึงสืบทอดและมีอยู่ในทุกคลาส คลาส Object มีวิธีการดังต่อไปนี้:

บูลีนสาธารณะเท่ากับ (Object obj)– คืนค่าเป็นจริงในกรณีที่ค่าของวัตถุที่เรียกใช้เมธอดและวัตถุที่ส่งผ่านการอ้างอิง obj ในรายการพารามิเตอร์เท่ากัน หากวัตถุไม่เท่ากัน จะส่งกลับค่าเท็จ ในคลาส Object ความเท่าเทียมกันจะถือเป็นความเท่าเทียมกันในการอ้างอิง และเทียบเท่ากับตัวดำเนินการเปรียบเทียบ “==” แต่ในผู้สืบทอด วิธีการนี้สามารถแทนที่ได้ และสามารถเปรียบเทียบวัตถุตามเนื้อหาได้ ตัวอย่างเช่น สิ่งนี้เกิดขึ้นกับอ็อบเจ็กต์ของคลาสตัวเลขของเชลล์ สามารถตรวจสอบได้ง่ายๆ ด้วยโค้ดดังนี้:

สองเท่า d1=1.0,d2=1.0;

System.out.println("d1==d2 ="+(d1==d2));

System.out.println("d1.equals(d2) ="+(d1.equals(d2)));

บรรทัดแรกของเอาต์พุตจะให้ d1==d2 =false และบรรทัดที่สอง d1.equals(d2) =true

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

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

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

คลาสสุดท้ายสาธารณะ getClass()– ส่งคืนการอ้างอิงไปยัง metaobject ของคลาสประเภท ด้วยความช่วยเหลือของมัน คุณสามารถรับข้อมูลเกี่ยวกับคลาสที่วัตถุอยู่และเรียกเมธอดคลาสและฟิลด์คลาสได้

โมฆะที่ได้รับการป้องกัน จบ () พ่น Throwable– ถูกเรียกก่อนที่วัตถุจะถูกทำลาย จะต้องถูกแทนที่ในลูกหลานของ Object ซึ่งจำเป็นต้องดำเนินการเสริมบางอย่างก่อนที่จะทำลายวัตถุ (ปิดไฟล์ แสดงข้อความ วาดบางอย่างบนหน้าจอ ฯลฯ ) วิธีการนี้จะอธิบายรายละเอียดเพิ่มเติมในย่อหน้าที่เกี่ยวข้อง

สตริงสาธารณะ toString()– ส่งคืนการแสดงสตริงของวัตถุ (อย่างเพียงพอที่สุด) ในคลาส Object เมธอดนี้สร้างสตริงของชื่อแบบเต็มของออบเจ็กต์ (พร้อมชื่อแพ็คเกจ) ตามด้วยอักขระ '@' จากนั้นตามด้วยรหัสแฮชเลขฐานสิบหกของออบเจ็กต์ คลาสมาตรฐานส่วนใหญ่จะแทนที่วิธีนี้ สำหรับคลาสตัวเลข การแสดงสตริงของตัวเลขจะถูกส่งกลับ สำหรับคลาสสตริง – เนื้อหาของสตริง สำหรับคลาสอักขระ – ตัวอักขระเอง (และไม่ใช่การแสดงสตริงของโค้ด!) ตัวอย่างเช่น ข้อมูลโค้ดต่อไปนี้

วัตถุ obj=วัตถุใหม่();

System.out.println(" obj.toString() ให้ "+obj.toString());

ดับเบิ้ล d=ดับเบิ้ลใหม่ (1.0);

System.out.println(" d.toString() ให้ "+d.toString());

อักขระ c="A";

System.out.println("c.toString() ให้ "+c.toString());

จะให้ข้อสรุป

obj.toString() ให้ java.lang.Object@fa9cf

d.toString() ให้ 1.0

c.toString() ให้ A

นอกจากนี้ยังมีวิธีการต่างๆ แจ้ง(), แจ้งทั้งหมด()และวิธีที่หลากหลายมากเกินไป รอออกแบบมาเพื่อทำงานกับเธรด สิ่งเหล่านี้จะกล่าวถึงในส่วนสตรีม

ข้อมูลที่เกี่ยวข้อง.

23 มี.ค. 2553 ธันวาคม 5e

PHP 5.3 นำเสนอฟีเจอร์ที่น่าสนใจที่เรียกว่า late staticbinding สิ่งต่อไปนี้คือการแปลคำอธิบายจากคู่มืออย่างเป็นทางการฟรีเล็กน้อย

ตั้งแต่ PHP 5.3.0 ภาษาได้เปิดตัวคุณลักษณะที่เรียกว่า late staticbinding ซึ่งสามารถใช้เพื่ออ้างอิงคลาสที่เรียกได้ในบริบทของการสืบทอดแบบคงที่

คุณลักษณะนี้เรียกว่า "การเชื่อมโยงแบบคงที่ล่าช้า" "การเชื่อมโยงล่าช้า" หมายความว่า static:: จะไม่ได้รับการแก้ไขโดยสัมพันธ์กับคลาสที่มีการกำหนดวิธีการไว้ แต่จะได้รับการประเมินที่รันไทม์ "การรวมแบบคงที่" หมายความว่าสามารถใช้ในการเรียกเมธอดแบบคงที่ได้ (แต่ไม่จำกัดเพียงวิธีเหล่านี้)

ข้อจำกัดของตัวเอง::

ตัวอย่างที่ 1: การใช้ self::

ตัวอย่างจะแสดงผล:

การใช้การผูกแบบคงที่ตอนปลาย

การเชื่อมโยงแบบคงที่ในภายหลังพยายามแก้ไขข้อจำกัดนี้โดยการแนะนำคำหลักที่อ้างอิงถึงคลาสที่เดิมเรียกว่าตอนรันไทม์ นั่นคือคีย์เวิร์ดที่จะอนุญาตให้อ้างอิง B จาก test() ในตัวอย่างก่อนหน้านี้ มีการตัดสินใจว่าจะไม่แนะนำคำใหม่ แต่ให้ใช้ static ที่สงวนไว้แล้ว

ตัวอย่าง #2: การใช้ static:: อย่างง่าย

ตัวอย่างจะแสดงผล:

หมายเหตุ: static:: ใช้งานไม่ได้เหมือน $this สำหรับวิธีการคงที่! $this-> เป็นไปตามกฎการสืบทอด แต่ static:: ไม่ทำอย่างนั้น ความแตกต่างนี้ได้รับการชี้แจงด้านล่าง

ตัวอย่าง #3: การใช้ static:: ในบริบทที่ไม่คงที่

ทดสอบ(); -

ตัวอย่างจะแสดงผล:

หมายเหตุ: การผูกแบบคงที่ล่าช้าจะหยุดกระบวนการแก้ไขปัญหาการโทร การโทรแบบคงที่โดยใช้ คำหลัก parent:: หรือ self:: ส่งต่อข้อมูลการโทร

ตัวอย่าง #4: การโอนสายและไม่โอนสาย

ตัวอย่างจะออกมา

เคสขอบ

มีมากมาย ในรูปแบบต่างๆเรียกเมธอดใน PHP เช่น callbacks หรือเมธอดเมจิก เนื่องจากการผูกแบบคงที่ล่าช้าได้รับการแก้ไขที่รันไทม์ ซึ่งอาจนำไปสู่ผลลัพธ์ที่ไม่คาดคิดในกรณีที่เรียกว่า Edge

ตัวอย่างที่ 5 การผูกแบบคงที่ล่าช้าในวิธีเวทย์มนตร์

ฟู; -

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

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

การผูกช่วงต้นและปลายใน Java

ตัวอย่างการเชื่อมโยงแบบคงที่และไดนามิกใน Java

ระบบ. ออก. println("หมวดหมู่:" + หมวดหมู่);

1. การเชื่อมโยงแบบคงที่เกิดขึ้นในเวลาคอมไพล์ ในขณะที่การเชื่อมโยงแบบไดนามิกเกิดขึ้น ณ รันไทม์


2. เนื่องจากการลิงก์แบบสแตติกเกิดขึ้นในช่วงแรกของวงจรชีวิตของโปรแกรม จึงเรียกว่าการรวมล่วงหน้า ในทำนองเดียวกัน การผูกแบบไดนามิกเรียกอีกอย่างว่าการผูกล่าช้า เนื่องจากจะเกิดขึ้นในภายหลังในการทำงานของโปรแกรม


3. การเชื่อมโยงแบบคงที่ใช้ในภาษา Java เพื่อแก้ไขวิธีการโอเวอร์โหลด ในขณะที่การเชื่อมโยงแบบไดนามิกใช้ในภาษา Java เพื่อแก้ไขวิธีการที่ถูกแทนที่


4. ในทำนองเดียวกัน วิธีการส่วนตัว คงที่ และเทอร์มินัลได้รับการแก้ไขโดยใช้การเชื่อมโยงแบบคงที่ เนื่องจากไม่สามารถเขียนทับได้ ในขณะที่วิธีการเสมือนทั้งหมดได้รับการแก้ไขโดยใช้การเชื่อมโยงแบบไดนามิก


5. ในกรณีของการเชื่อมโยงแบบคงที่ ไม่ใช่วัตถุที่เป็นรูปธรรมที่ใช้ แต่เป็นข้อมูลประเภท นั่นคือ ประเภทของตัวแปรอ้างอิงที่ใช้เพื่อค้นหาวิธีการที่ต้องการ ในทางกลับกัน การเชื่อมโยงแบบไดนามิกใช้วัตถุเฉพาะเพื่อค้นหาวิธีการที่ต้องการใน Java