เข้าใจการผูกมัดแบบคงที่และไดนามิกใน Java

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

มีสองวิธีที่มีผลผูกพันใน Java หนึ่งคือการผูกมัดแบบคงที่หรือที่เรียกว่าการผูกก่อน อีกประเภทหนึ่งคือการเชื่อมโยงแบบไดนามิกหรือที่เรียกว่าการผูกล่าช้า

แนวคิดของการผูกโปรแกรม:

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

การเชื่อมแบบคงที่ (การผูกคอมไพเลอร์ก่อนกำหนด):

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

การเชื่อมโยงแบบไดนามิก (การผูกล่าช้าในระหว่างการรันไทม์):

การเชื่อมโยงในภายหลัง: ผูกตามประเภทของวัตถุเฉพาะที่รันไทม์

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

กระบวนการเชื่อมโยงแบบไดนามิก:

• ตารางวิธีการแยกประเภทของวัตถุจริงโดยเครื่องเสมือนจริง
• ลายเซ็นวิธีการค้นหาเครื่องเสมือนจริง
• วิธีการโทร

สรุปเกี่ยวกับการผูก:

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

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

ตัวอย่างเช่น: ผู้ปกครอง p = เด็กใหม่ ();

กระบวนการเฉพาะมีดังนี้:

1. คอมไพเลอร์ตรวจสอบประเภทการประกาศและชื่อวิธีของวัตถุ สมมติว่าเราเรียกเมธอด XF (ARGS) และ X ได้รับการประกาศว่าเป็นวัตถุของคลาส C จากนั้นคอมไพเลอร์จะแสดงรายการวิธีทั้งหมดที่ชื่อ F ในคลาส C และวิธีการที่สืบทอดมาจาก superclass ของคลาส C

2. ถัดไปคอมไพเลอร์ตรวจสอบประเภทพารามิเตอร์ที่มีให้ในการโทรวิธี หากพารามิเตอร์ชนิดหนึ่งระหว่างวิธีทั้งหมดที่มีชื่อ F ตรงกับประเภทพารามิเตอร์ที่ได้รับจากการโทรมากที่สุดแล้ววิธีนี้จะเรียกว่า กระบวนการนี้เรียกว่า "การแยกวิเคราะห์เกินพิกัด"

3. เมื่อโปรแกรมทำงานและใช้การเชื่อมโยงแบบไดนามิกกับวิธีการโทรเครื่องเสมือนต้องเรียกเวอร์ชันวิธีการที่ตรงกับประเภทจริงของวัตถุที่ชี้ไปที่ x สมมติว่าประเภทจริงคือ d (subclass ของ c) ถ้าคลาส D กำหนด f (สตริง) จากนั้นวิธีการเรียกมิฉะนั้นวิธี F (สตริง) จะถูกค้นหาใน superclass ของ d และอื่น ๆ

ความคิดคำถาม:

วิธีจัดหาวิธีการให้ผู้ใช้วิธีการให้ผู้ใช้ในการทำงานให้เสร็จสมบูรณ์ หากผู้ใช้มีข้อกำหนดพิเศษเขาหรือเธอจำเป็นต้องปรับแต่งวิธีการของตนเองหรือไม่?

ความรู้ที่เกี่ยวข้อง:

คลาสผู้ปกครองเด็กอินเทอร์เฟซการเปลี่ยนแปลงขึ้นไปการผูกมัดแบบไดนามิก

รหัสเฉพาะ:

 แพ็คเกจ com.chengxuyuanzhilu; อินเทอร์เฟซสาธารณะ myinterfaces {void doting ();} แพ็คเกจ com.chengxuyuanzhilu; เครื่องดื่มระดับสาธารณะใช้ myinterfaces {@Override โมฆะสาธารณะ doting () {system.out.println ( }} แพ็คเกจ com.chengxuyuanzhilu; คลาสสาธารณะ EAT ใช้ myInterfaces {@Override โมฆะสาธารณะ doting () {system.out.println ("ฉันกิน"); }} แพ็คเกจ com.chengxuyuanzhilu; การรันคลาสสาธารณะใช้ myinterfaces {@Override โมฆะสาธารณะ doting () {system.out.println ("ฉันกำลังวิ่ง"); }} แพ็คเกจ com.chengxuyuanzhilu; Public Class TestDynamicBind {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {myInterfaces my = null; my = new Eat (); ผูก (ของฉัน); ฉัน = เครื่องดื่มใหม่ (); ผูก (ของฉัน); my = new run (); ผูก (ของฉัน); } โมฆะคงที่การผูก (myInterfaces my) {my.doting (); -

ข้างต้นเป็นเรื่องเกี่ยวกับบทความนี้ฉันหวังว่ามันจะเป็นประโยชน์กับการเรียนรู้ของทุกคน