นอกเหนือจากการจำกัดการเข้าถึงแล้ว วิธีการเข้าถึงยังกำหนดวิธีการที่จะเรียกโดยคลาสย่อยหรือคุณสมบัติที่จะเข้าถึงโดยคลาสย่อย ความสัมพันธ์ระหว่างการเรียกฟังก์ชันและฟังก์ชันเอง และความสัมพันธ์ระหว่างการเข้าถึงของสมาชิกและที่อยู่หน่วยความจำตัวแปร เรียกว่าการรวม
ในภาษาคอมพิวเตอร์ มีสองวิธีหลักในการผูกแบบคงที่และการเชื่อมโยงแบบไดนามิกเกิดขึ้นระหว่างโครงสร้างข้อมูลและโครงสร้างข้อมูลก่อนที่โปรแกรมจะถูกดำเนินการในเวลารวบรวมดังนั้นจึงไม่สามารถใช้รันไทม์ใด ๆ ข้อมูล กำหนดเป้าหมายการเรียกใช้ฟังก์ชันและเนื้อความของฟังก์ชันหรือตัวแปรและบล็อกในหน่วยความจำ เนื่องจาก PHP เป็นภาษาไดนามิก จึงไม่ได้ใช้การเชื่อมโยงแบบคงที่ อย่างไรก็ตาม จึงสามารถจำลองการเข้าถึง
เป้าหมายการเชื่อมโยงแบบไดนามิกที่สร้างขึ้นระหว่างรันไทม์ คำขอใช้เฉพาะข้อมูลที่มีอยู่ในรันไทม์เท่านั้น ในโค้ดเชิงวัตถุ การเชื่อมโยงแบบไดนามิกหมายความว่าการตัดสินใจว่าจะเรียกใช้เมธอดใดหรือคุณสมบัติใดที่เข้าถึงจะขึ้นอยู่กับคลาสนั้นเอง และไม่ได้อยู่บนขอบเขตการเข้าถึง
การดำเนินการของสมาชิกแบบสาธารณะและที่ได้รับการป้องกัน คล้ายกับการทำงานของฟังก์ชันใน PHP เวอร์ชันก่อนหน้า โดยใช้การเชื่อมโยงแบบไดนามิก ซึ่งหมายความว่าหากเมธอดเข้าถึงสมาชิกของคลาสที่ถูกแทนที่ในคลาสย่อย และเป็นอินสแตนซ์ของคลาสย่อย สมาชิกคลาสย่อยจะถูกเข้าถึง (แทนที่จะเข้าถึงสมาชิก ในคลาสพาเรนต์)
ดูรูปที่ 1 โค้ดนี้จะแสดงผลว่า "Hey! I am Son" เพราะเมื่อ PHP เรียก getSalutation จะเป็นอินสแตนซ์ของ Son ซึ่งจะเขียนทับคำทักทายในภาษา Father ถ้าเป็นคำทักทายแบบสาธารณะ จะให้ผลลัพธ์เดียวกัน การเอาชนะวิธีการทำงานในลักษณะเดียวกัน ใน Son การเรียกเพื่อระบุถูกผูกไว้กับวิธีการนั้น
แม้ในคลาสย่อย โหมดการเข้าถึงจะลดลงจากการป้องกันสู่สาธารณะ การเชื่อมโยงแบบไดนามิกจะยังคงเกิดขึ้น
หลักการของการใช้วิธีการเข้าถึง เป็นไปไม่ได้
ที่จะเพิ่ม
ข้อจำกัดการเข้าถึงให้กับสมาชิกคลาส ดังนั้น การเปลี่ยนวิธีการเข้าถึงจากสาธารณะเป็นแบบป้องกันจึงเป็นไปไม่ได้
พ่อชั้น
-
protected $salutation = "สวัสดี!"; //สวัสดี ฟัง
ก์ชั่นสาธารณะ getSalutation()
-
print("$this->คำทักทายn");
$นี่->ระบุ();
}
ระบุฟังก์ชันที่ได้รับการป้องกัน ()
-
print("ฉันคือพ่อn");
-
};
คลาส ลูกชาย ขยายพ่อ
-
protected $salutation = "เฮ้!"; //protected $salutation ในคลาสพาเรนต์ถูกเขียนทับ
ฟังก์ชันป้องกัน ระบุ() //protected ระบุ() ในคลาสพาเรนต์ถูกเขียนทับ
-
print("ฉันชื่อลูกชายn");
-
};
$obj = ลูกชายคนใหม่();
$obj->getSalutation(); //เอาท์พุต เฮ้!
?>
//หมายเหตุ: getSalutation() ไม่ได้ถูกแทนที่ในคลาสย่อย แต่จริงๆ แล้วยังมี getSalutation() $salutation และ ident() ในคลาสนี้
//เหมือนกับ getSalutation() ในกรณีของ Son คลาสย่อย วิธีการนี้ถูกผูกไว้แบบไดนามิก ดังนั้นการเรียกเมธอด getSalutation() ของอินสแตนซ์ Son
จะเรียกคำทักทายของสมาชิกและระบุ() ในคลาส Son แทนที่จะเป็นคำทักทายของสมาชิกและระบุ() ในคลาสหลัก
เท่านั้นที่มีสมาชิกส่วนตัว ภายในคลาสที่มันตั้งอยู่ PHP จำลองการเชื่อมโยงแบบคงที่ซึ่งต่างจากสมาชิกสาธารณะและสมาชิกที่ได้รับการคุ้มครอง ดูตัวอย่างในรูปที่ 2 โดยจะแสดงผลลัพธ์ว่า "สวัสดี! ฉันเป็นพ่อ" แม้ว่าคลาสย่อยจะแทนที่ค่าของคำทักทายก็ตาม สคริปต์นี้จะผูกไว้กับคลาส Father
ใน
ปัจจุบัน
พ่อชั้น
-
$salutation ส่วนตัว = "สวัสดี!"
;
-
print("$this->คำทักทายn");
$นี่->ระบุ();
}
ระบุฟังก์ชันส่วนตัว()
-
print("ฉันคือพ่อn");
-
}
คลาส ลูกชายขยายพ่อ
-
$salutation ส่วนตัว = "เฮ้!";
ฟังก์ชั่นส่วนตัวระบุ ()
-
print("ฉันชื่อลูกชายn");
-
}
$obj = ลูกชายคนใหม่();
$obj->getSalutation(); //Output สวัสดี!
?>
ข้อดีของการเชื่อมโยงแบบไดนามิกคืออนุญาตให้คลาสที่สืบทอดมาเปลี่ยนพฤติกรรมของคลาสพาเรนต์ในขณะที่ยังคงรักษาอินเทอร์เฟซและฟังก์ชันของคลาสพาเรนต์ ดูตัวอย่างรูปที่ 3 เนื่องจากการใช้การเชื่อมโยงแบบไดนามิก เวอร์ชันของ isAuthorized จึงถูกเรียก ใน DeleteUser สามารถกำหนดได้ตามประเภทของอ็อบเจ็กต์ หากเป็นผู้ใช้ทั่วไป การเรียก PHP::isAuthorized จะส่งคืน FALSE หากเป็นอินสแตนซ์ของ AuthorizedUser การเรียก PHP AuthorizedUser::isAuthorized จะทำให้ DeleteUser ทำงานได้อย่าง
ราบรื่น haohappy หมายเหตุ: ใช้ เพื่อให้ชัดเจนในประโยคเดียว มันเป็นการเชื่อมโยงประเภทวัตถุ วิธีการ และคุณลักษณะ เมื่อเรียกวิธีการที่มีอยู่ในทั้งคลาสหลักและคลาสย่อย หรือการเข้าถึงแอตทริบิวต์ มันจะกำหนดประเภทของวัตถุก่อน อินสแตนซ์เป็นของแล้วเรียกวิธีการในชั้นเรียนที่สอดคล้องกัน และ
ประโยชน์ของการเชื่อมโยงแบบไดนามิก
＜?php
ผู้ใช้คลาส //ผู้ใช้
-
ฟังก์ชั่นที่ได้รับการป้องกัน isAuthorized() // ไม่ว่าจะเป็นผู้ใช้ที่ได้รับการรับรองความถูกต้องหรือไม่
-
กลับ(เท็จ);
}
ฟังก์ชั่นสาธารณะ getName() //รับชื่อ
-
กลับ($นี่->ชื่อ);
}
ฟังก์ชั่นสาธารณะ DeleteUser($username) //ลบผู้ใช้
-
ถ้า(!$this->ได้รับอนุญาต())
-
print("คุณไม่ได้รับอนุญาต.n");
กลับ(เท็จ);
}
// ลบผู้ใช้
print("ผู้ใช้ถูกลบแล้วn");
-
}
คลาส AuthorizedUser ขยายผู้ใช้ // ผู้ใช้การรับรองความถูกต้อง
-
ฟังก์ชั่นที่ได้รับการป้องกัน isAuthorized() // เขียนทับ isAuthorized()
-
กลับ(จริง);
-
}
$user = ผู้ใช้ใหม่;
$admin = new AuthorizedUser;
//ไม่ได้รับอนุญาต
$user->deleteUser("Zeev");
//ได้รับอนุญาต
$admin->deleteUser("Zeev");
?>
เหตุใดสมาชิกคลาสส่วนตัวจึงจำลองการผูกแบบคงที่ เพื่อตอบคำถามนี้ คุณต้องจำไว้ว่าเหตุใดคุณจึงต้องมีสมาชิกส่วนตัว เมื่อใดจึงสมเหตุสมผลที่จะใช้พวกเขาแทนสมาชิก
ส่วนตัวเท่านั้น หากคุณไม่ต้องการ คลาสย่อยที่จะสืบทอด ใช้เฉพาะเมื่อเปลี่ยนแปลงหรือเชี่ยวชาญพฤติกรรมของคลาสพาเรนต์ นี่เป็นสิ่งที่หายากกว่าที่คุณคิด โดยทั่วไป ลำดับชั้นของวัตถุที่ดีควรอนุญาตให้ฟังก์ชันการทำงานส่วนใหญ่มีความพิเศษ ปรับปรุง หรือเปลี่ยนแปลงโดยคลาสย่อย พื้นฐานของการเขียนโปรแกรมเชิงวัตถุ วิธีการส่วนตัวหรือตัวแปรมีความจำเป็นในบางสถานการณ์ เช่น เมื่อคุณแน่ใจว่าคุณไม่ต้องการอนุญาตให้คลาสย่อยเปลี่ยนส่วนเฉพาะของคลาสพาเรนต์