ออบเจ็กต์ใน PHP5 ได้รับการปรับอย่างเป็นระบบและครอบคลุมมากขึ้น และรูปลักษณ์ปัจจุบันอาจดูค่อนข้างคล้ายกับ Java ในส่วนนี้จะเน้นไปที่โหมดอ็อบเจ็กต์ใหม่ใน PHP5 และให้ตัวอย่างที่ง่ายกว่านี้มาแสดงให้เห็น ให้ส่วนนี้เป็นจุดเริ่มต้นใหม่สำหรับการเดินทาง PHP5 ของคุณ :)
* ตัวสร้างและตัวทำลาย
* การอ้างอิงวัตถุ
* โคลนของวัตถุ
* โหมดส่วนตัว สาธารณะ และการป้องกันในวัตถุ
* อินเทอร์เฟซ
* คลาสนามธรรม
* __เรียก
* __ตั้งค่า และ __get
* สมาชิกแบบคงที่
ตัวสร้างและตัวทำลาย
ใน PHP4 เมื่อฟังก์ชันมีชื่อเดียวกันกับวัตถุ ฟังก์ชันนี้จะกลายเป็นตัวสร้างของวัตถุ และไม่มีแนวคิดของตัวทำลายใน PHP4
ใน PHP5 ตัวสร้างจะมีชื่อเหมือนกันว่า __construct และมีการแนะนำแนวคิดของ destructor ซึ่งมีชื่อเหมือนกันว่า __destruct
ตัวอย่างที่ 1: ตัวสร้างและตัวทำลาย
คลาสฟู {
var $x;
ฟังก์ชั่น __ สร้าง ($ x) {
$นี่->x = $x;
-
ฟังก์ชั่นแสดง() {
พิมพ์($นี่->x);
-
ฟังก์ชั่น __ ทำลาย () {
print("ลาก่อน");
-
-
$o1 = ใหม่ foo(4);
$o1->จอแสดงผล();
-
ในตัวอย่างด้านบน เมื่อคุณยกเลิกการเรียกไปยังคลาส foo ตัวทำลายล้างจะถูกเรียก และ "ลาก่อน" จะถูกส่งออกในตัวอย่างข้างต้น
object References
ใน PHP4 การส่งตัวแปรไปยังฟังก์ชันหรือเมธอดจะสร้างสำเนาของตัวแปรจริง ๆ ซึ่งหมายความว่าสิ่งที่คุณส่งไปยังฟังก์ชันหรือเมธอดนั้นเป็นสำเนาของตัวแปร เว้นแต่คุณจะใช้การอ้างอิง สัญลักษณ์ "&" ใช้เพื่อประกาศว่าจะทำการอ้างอิง ไม่ใช่การคัดลอก ใน PHP5 วัตถุจะอยู่ในรูปแบบของการอ้างอิงเสมอ และการดำเนินการมอบหมายในวัตถุก็เป็นการดำเนินการอ้างอิงเช่นกัน
ตัวอย่างที่ 2: การอ้างอิงวัตถุ
คลาสฟู {
var $x;
ฟังก์ชั่น setX($x) {
$นี่->x = $x;
-
ฟังก์ชั่น getX() {
กลับ $this->x;
-
-
$o1 = ฟูใหม่;
$o1->setX(4);
$o2 = $o1;
$o1->setX(5);
if($o1->getX() == $o2->getX()) print("โอ้พระเจ้า!");
?>
Clone of Object
ตามที่กล่าวไว้ข้างต้น เมื่อวัตถุถูกเรียกในรูปแบบของการอ้างอิงเสมอ ฉันควรทำอย่างไรหากต้องการรับสำเนาของวัตถุ? PHP5 มีฟังก์ชันใหม่ ซึ่งก็คือการโคลนวัตถุ และไวยากรณ์คือ __clone
ตัวอย่างที่ 3: การโคลนวัตถุ
คลาสฟู {
var $x;
ฟังก์ชั่น setX($x) {
$นี่->x = $x;
-
ฟังก์ชั่น getX() {
กลับ $this->x;
-
-
$o1 = ฟูใหม่;
$o1->setX(4);
$o2 = $o1->__โคลน();
$o1->setX(5); if($o1->getX() != $o2->getX()) print ("สำเนามีความเป็นอิสระ");
-
วิธีการโคลนออบเจ็กต์มีอยู่ในภาษาแอปพลิเคชันอื่นๆ มากมาย ดังนั้นคุณจึงไม่ต้องกังวลเกี่ยวกับความเสถียรของมัน -
โหมดส่วนตัว สาธารณะ และโหมดที่ได้รับการป้องกันในออบเจ็กต์
ใน PHP4 วิธีการและตัวแปรทั้งหมดของออบเจ็กต์เป็นแบบสาธารณะ ซึ่งหมายความว่าคุณสามารถใช้งานตัวแปรและวิธีการใดๆ ภายนอกออบเจ็กต์ได้ PHP5 แนะนำโหมดใหม่สามโหมดสำหรับควบคุมสิทธิ์การเข้าถึงนี้: สาธารณะ ป้องกัน และส่วนตัว
โหมดสาธารณะ (สาธารณะ): อนุญาตให้ควบคุมการทำงานภายนอกวัตถุ
โหมดส่วนตัว (ส่วนตัว): เฉพาะวิธีการภายในวัตถุนี้เท่านั้นที่ได้รับอนุญาตให้ใช้งานและควบคุมได้
โหมดป้องกัน (ป้องกัน): อนุญาตให้วัตถุนี้และวัตถุแม่ทำงานและควบคุมได้
ตัวอย่างที่ 4: โหมดส่วนตัว สาธารณะ และโหมดที่ได้รับการป้องกันในออบเจ็กต์
คลาสฟู {
ส่วนตัว $x;
ฟังก์ชั่นสาธารณะ public_foo() {
print("ฉันเป็นสาธารณะ");
-
ฟังก์ชั่นที่ได้รับการป้องกัน protected_foo() {
$this->private_foo(); //โอเค เพราะเราอยู่คลาสเดียวกัน เราจึงสามารถเรียกเมธอดส่วนตัวได้
print("ฉันได้รับการคุ้มครองแล้ว");
-
ฟังก์ชั่นส่วนตัว private_foo() {
$นี่->x = 3;
print("ฉันส่วนตัว");
-
-
คลาส foo2 ขยาย foo {
จอแสดงผลฟังก์ชั่นสาธารณะ () {
$นี่->protected_foo();
$นี่->public_foo();
// $this->private_foo(); // ไม่ถูกต้อง! ฟังก์ชั่นนี้เป็นส่วนตัวในคลาสพื้นฐาน
-
} $x = ใหม่ foo();
$x->public_foo();
//$x->protected_foo(); //Invalid ไม่สามารถเรียกวิธีการป้องกันนอกคลาสและคลาสที่ได้รับ
//$x->private_foo(); // วิธีการส่วนตัวที่ไม่ถูกต้องสามารถใช้ได้เฉพาะภายในคลาส $x2 = new foo2();
$x2->จอแสดงผล();
-
เคล็ดลับ: ตัวแปรในวัตถุจะมีอยู่ในรูปแบบส่วนตัวเสมอ การดำเนินการกับตัวแปรโดยตรงในวัตถุไม่ใช่พฤติกรรมการเขียนโปรแกรมเชิงวัตถุที่ดี วิธีที่ดีกว่าคือส่งมอบตัวแปรที่คุณต้องการให้กับวิธีการประมวลผลของวัตถุ
อินเทอร์เฟซ
ดังที่เราทราบกันดีว่าออบเจ็กต์ใน PHP4 รองรับการสืบทอด หากต้องการทำให้ออบเจ็กต์เป็นคลาสที่ได้รับจากออบเจ็กต์อื่น คุณต้องใช้โค้ดที่คล้ายกับ "class foo extensions parent" เพื่อควบคุมมัน ใน PHP4 และ PHP5 ออบเจ็กต์สามารถสืบทอดได้เพียงครั้งเดียว และไม่รองรับการสืบทอดหลายรายการ อย่างไรก็ตาม มีคำใหม่เกิดขึ้นใน PHP5: อินเทอร์เฟซ อินเทอร์เฟซเป็นวัตถุพิเศษที่ไม่มีโค้ดประมวลผลเฉพาะเจาะจงเท่านั้น หลังจากนั้น วัตถุจะสามารถใช้งานได้อย่างสะดวกสบายด้วยคีย์เวิร์ด 'นำไปใช้' อินเทอร์เฟซที่จำเป็นจะถูกรวมเข้าด้วยกัน และจากนั้นจะมีการเพิ่มโค้ดการดำเนินการเฉพาะ
ตัวอย่างที่ 5: อินเทอร์เฟซ
อินเทอร์เฟซที่สามารถแสดงได้ {
ฟังก์ชั่นแสดง();
-
อินเทอร์เฟซที่พิมพ์ได้ {
ฟังก์ชั่น doprint();
}
คลาส foo ใช้งานแบบแสดงได้ พิมพ์ได้ {
ฟังก์ชั่นแสดง() {
// รหัส
} ฟังก์ชัน doprint() {
// รหัส
-
-
-
สิ่งนี้มีประโยชน์มากในการปรับปรุงความสามารถในการอ่านและความนิยมของโค้ด จากตัวอย่างข้างต้น เราจะเห็นได้ว่าอ็อบเจ็กต์ foo มีสองอินเทอร์เฟซที่สามารถแสดงได้และพิมพ์ได้ ในเวลานี้ เราสามารถรู้ได้อย่างชัดเจนว่าอ็อบเจ็กต์ foo ต้องมีจอแสดงผล () วิธีการและวิธี print() คุณเพียงแค่ต้องเข้าใจส่วนอินเทอร์เฟซเท่านั้น คุณสามารถใช้งานวัตถุได้อย่างง่ายดายโดยไม่ต้องสนใจว่าวัตถุทำงานภายในอย่างไร
คลาสนามธรรม
ไม่สามารถสร้างอินสแตนซ์คลาสนามธรรมได้
คลาสนามธรรมก็เหมือนกับคลาสอื่นๆ ที่อนุญาตให้กำหนดตัวแปรและวิธีการได้
คลาสนามธรรมยังสามารถกำหนดวิธีนามธรรมได้ วิธีการของคลาสนามธรรมจะไม่ถูกดำเนินการ แต่อาจถูกดำเนินการในคลาสที่ได้รับ
ตัวอย่างที่ 6: คลาสนามธรรม
คลาสนามธรรม foo {
ป้องกัน $x;
ฟังก์ชั่นนามธรรมแสดง ();
ฟังก์ชั่น setX($x) {
$นี่->x = $x;
-
-
คลาส foo2 ขยาย foo {
ฟังก์ชั่นแสดง() {
// รหัส
-
-
?>
__call
วัตถุ PHP5 มีเมธอดเฉพาะใหม่ __call() ซึ่งใช้ในการตรวจสอบวิธีการอื่นในวัตถุ หากคุณพยายามเรียกเมธอดที่ไม่มีอยู่บนออบเจ็กต์ เมธอด __call จะถูกเรียกโดยอัตโนมัติ
ตัวอย่างที่ 7: __ โทร
คลาสฟู {
ฟังก์ชั่น __call($ชื่อ,$อาร์กิวเมนต์) {
print("คุณโทรหาฉันหรือเปล่า? ฉันชื่อ $name!");
-
} $x = ใหม่ foo();
$x->doStuff();
$x->fancy_stuff();
-
วิธีการพิเศษนี้สามารถใช้เพื่อดำเนินการ "โอเวอร์โหลด" เพื่อให้คุณสามารถตรวจสอบพารามิเตอร์และส่งผ่านโดยการเรียกวิธีการส่วนตัว
ตัวอย่างที่ 8: การใช้ __call เพื่อใช้การกระทำ "โอเวอร์โหลด"
คลาสเมจิก {
ฟังก์ชั่น __call($ชื่อ,$อาร์กิวเมนต์) {
ถ้า($ชื่อ=='foo') {
if(is_int($arguments[0])) $this->foo_for_int($arguments[0]);
if(is_string($arguments[0])) $this->foo_for_string($arguments[0]);
-
} ฟังก์ชันส่วนตัว foo_for_int($x) {
print("โอ้ int!");
} ฟังก์ชันส่วนตัว foo_for_string($x) {
print("โอ้ เชือก!");
-
} $x = เมจิกใหม่ ();
$x->ฟู(3);
$x->foo("3");
?>
__set และ __get
นี่เป็นวิธีที่ยอดเยี่ยม สามารถใช้วิธี __set และ __get เพื่อจับตัวแปรและวิธีการที่ไม่มีอยู่ในวัตถุ
ตัวอย่างที่ 9: __set และ __get
คลาสฟู {
ฟังก์ชั่น __set($ชื่อ,$val) {
print("สวัสดี คุณพยายามใส่ $val ใน $name");
-
ฟังก์ชั่น __get($ชื่อ) {
print("เฮ้ คุณขอ $name");
-
-
$x = ใหม่ foo();
$x->บาร์ = 3;
พิมพ์($x->winky_winky);
?>
ตัวบ่งชี้ประเภท
ใน PHP5 คุณสามารถระบุในเมธอดของอ็อบเจ็กต์ได้ว่าพารามิเตอร์ของมันต้องเป็นอินสแตนซ์ของอ็อบเจ็กต์อื่น
ตัวอย่างที่ 10: การระบุประเภท
คลาสฟู {
// รหัส ...
-
แถบคลาส {
ฟังก์ชั่นสาธารณะ process_a_foo (foo $foo) {
//โค้ดบางส่วน
-
-
$b = แถบใหม่();
$f = ใหม่ foo();
$b->process_a_foo($f);
-
อย่างที่เห็น เราสามารถระบุชื่อของออบเจ็กต์ก่อนพารามิเตอร์ได้อย่างชัดเจน และ PHP5 จะรับรู้ว่าพารามิเตอร์นั้นจะเป็นอินสแตนซ์ของออบเจ็กต์
สมาชิกแบบคงที่
สมาชิกแบบคงที่และวิธีการแบบคงที่เรียกว่า "วิธีวัตถุ (วิธีคลาส)" และ "ตัวแปรวัตถุ (ตัวแปรคลาส)" ในคำศัพท์การเขียนโปรแกรมเชิงวัตถุ
"วิธีการของวัตถุ" ได้รับอนุญาตให้เรียกก่อนที่จะสร้างอินสแตนซ์ของวัตถุ ในทำนองเดียวกัน "ตัวแปรวัตถุ" สามารถควบคุมได้อย่างอิสระก่อนที่จะสร้างอินสแตนซ์ของวัตถุ (โดยไม่ต้องใช้วิธีของวัตถุในการควบคุมมัน)
ตัวอย่างที่ 11: วิธีการวัตถุและตัวแปรวัตถุ
เครื่องคิดเลขในชั้นเรียน {
สาธารณะคงที่ $pi = 3.14151692;
เพิ่มฟังก์ชันสาธารณะแบบคงที่ ($x,$y) {
กลับ $x + $y;
-
-
$s = เครื่องคิดเลข::$pi;
$result = เครื่องคิดเลข::เพิ่ม(3,7);
พิมพ์("$ผลลัพธ์");
?>
จัดการข้อยกเว้น
ได้รับการยอมรับว่าเป็นวิธีการที่เหมาะสมที่สุดสำหรับการจัดการข้อผิดพลาดของโปรแกรม แนวคิดนี้มีให้ใช้งานใน Java และ C++ คุณสามารถลองใช้ "ลอง" และ "จับ" เพื่อควบคุมข้อผิดพลาดของโปรแกรม
ตัวอย่างที่ 12: การจัดการข้อยกเว้น
คลาสฟู {
ฟังก์ชันหาร($x,$y) {
if($y==0) โยน new Exception("ไม่สามารถหารด้วยศูนย์");
ส่งคืน $x/$y;
-
-
$x = ใหม่ foo();
พยายาม {
$x->หาร(3,0);
} จับ (ยกเว้น $e) {
เสียงสะท้อน $e->getMessage();
เสียงสะท้อน "น
เอ็น";
// มาตรการภัยพิบัติบางประการที่นี่
-
-
ในตัวอย่างข้างต้น เราใช้ "try" เพื่อดำเนินการคำสั่งในวงเล็บปีกกา เมื่อเกิดข้อผิดพลาด โค้ดจะส่งข้อผิดพลาดไปยังส่วนคำสั่ง "catch" เพื่อดำเนินการ ในส่วนคำสั่ง "catch" คุณต้องระบุ การจัดการข้อผิดพลาดกับออบเจ็กต์สามารถทำให้โครงสร้างโค้ดดูชัดเจนขึ้น เนื่องจากตอนนี้เราสามารถส่งข้อมูลข้อผิดพลาดทั้งหมดไปยังออบเจ็กต์เพื่อจัดการได้
การจัดการข้อผิดพลาดแบบกำหนดเอง
คุณสามารถควบคุมอุบัติเหตุในโปรแกรมของคุณได้อย่างง่ายดายด้วยรหัสการจัดการข้อผิดพลาดแบบกำหนดเอง คุณเพียงแค่ต้องได้รับคลาสการควบคุมข้อผิดพลาดของคุณเองจากคลาสข้อยกเว้น ในคลาสการควบคุมข้อผิดพลาดของคุณเอง คุณจำเป็นต้องมี Constructor และเมธอด getMessage ต่อไปนี้เป็นตัวอย่าง
ตัวอย่างที่ 13: การจัดการข้อผิดพลาดแบบกำหนดเอง
คลาส WeirdProblem ขยายข้อยกเว้น {
$ ข้อมูลส่วนตัว;
ฟังก์ชั่น WeirdProblem($data) {
ผู้ปกครอง::ข้อยกเว้น ();
$นี่->ข้อมูล = $ข้อมูล;
-
ฟังก์ชั่น getMessage() {
return $this->data . " ทำให้เกิดข้อยกเว้นแปลกๆ!";
-
-
-
ตอนนี้เราสามารถใช้ "throw new WeirdProblem($foo)" เพื่อโยนตัวจัดการข้อผิดพลาด หากข้อผิดพลาดเกิดขึ้นในบล็อกโค้ด "ลอง" PHP5 จะส่งข้อผิดพลาดไปยังส่วน "catch" โดยอัตโนมัติเพื่อการประมวลผล
เนมสเปซ
เนมสเปซมีประโยชน์สำหรับการจัดกลุ่มคลาสหรือการจัดกลุ่มฟังก์ชัน สามารถจัดกลุ่มคลาสหรือฟังก์ชันที่เกี่ยวข้องเข้าด้วยกันเพื่อให้สามารถโทรได้ง่ายในภายหลัง
ตัวอย่างที่ 14: เนมสเปซ
เนมสเปซคณิตศาสตร์ {
คลาสคอมเพล็กซ์ {
//...รหัส...
ฟังก์ชั่น __ สร้าง () {
พิมพ์("เฮ้");
-
-
} $m = ใหม่ คณิตศาสตร์::Complex();
-
ให้ความสนใจกับสถานการณ์ที่คุณต้องใช้เนมสเปซในการใช้งานจริง คุณอาจต้องประกาศออบเจ็กต์สองรายการขึ้นไปด้วยชื่อเดียวกันเพื่อทำสิ่งต่าง ๆ จากนั้นคุณสามารถใส่มันไว้ในเนมสเปซที่ต่างกันได้ (แต่อินเทอร์เฟซจะต้องเป็น) เหมือนกัน)