ในการเขียนโปรแกรมเชิงวัตถุ (อังกฤษ: การเขียนโปรแกรมเชิงวัตถุ ตัวย่อ: OOP) อ็อบเจ็กต์ประกอบด้วยข้อมูลทั้งหมดและคำอธิบายวิธีการประมวลผลข้อมูล และถือเป็นนามธรรมของโลกแห่งความเป็นจริง
ในโลกแห่งความเป็นจริง สิ่งที่เราเผชิญคือสิ่งของต่างๆ เช่น คอมพิวเตอร์ โทรทัศน์ จักรยาน เป็นต้น
ลักษณะสำคัญของวัตถุมีสามประการ:
พฤติกรรมของวัตถุ การดำเนินการใดที่สามารถนำไปใช้กับวัตถุได้ การเปิดไฟ และการปิดไฟ นั้นเป็นพฤติกรรม
รูปร่างของวัตถุ: วัตถุตอบสนองอย่างไรเมื่อใช้วิธีการเหล่านั้น สี ขนาด และรูปลักษณ์
การแสดงวัตถุ: การแสดงวัตถุเทียบเท่ากับบัตรประจำตัว โดยเฉพาะการแยกความแตกต่างในลักษณะการทำงานและสถานะเดียวกัน
ตัวอย่างเช่น Animal เป็นคลาสนามธรรม เราสามารถระบุสุนัขและแกะได้ และสุนัขและแกะเป็นวัตถุที่เป็นรูปธรรม พวกมันมีคุณลักษณะของสี สามารถเขียนได้ วิ่งได้ และสถานะพฤติกรรมอื่นๆ
คลาส - กำหนดลักษณะนามธรรมของสิ่งใดสิ่งหนึ่ง คำจำกัดความของคลาสรวมถึงรูปแบบของข้อมูลและการดำเนินการกับข้อมูล
วัตถุ - เป็นตัวอย่างหนึ่งของชั้นเรียน
ตัวแปรสมาชิก - ตัวแปรที่กำหนดไว้ภายในชั้นเรียน ค่าของตัวแปรนี้ไม่ปรากฏแก่โลกภายนอก แต่สามารถเข้าถึงได้ผ่านฟังก์ชันสมาชิก หลังจากที่คลาสถูกสร้างอินสแตนซ์เป็นอ็อบเจ็กต์แล้ว ตัวแปรสามารถถูกเรียกว่าแอ็ตทริบิวต์ของอ็อบเจ็กต์ได้
ฟังก์ชั่นสมาชิก - ถูกกำหนดไว้ภายในชั้นเรียนและสามารถใช้เพื่อเข้าถึงข้อมูลของวัตถุ
การสืบทอด - การสืบทอดเป็นกลไกที่คลาสย่อยแบ่งปันโครงสร้างข้อมูลและวิธีการของคลาสแม่โดยอัตโนมัติ นี่คือความสัมพันธ์ระหว่างคลาส เมื่อกำหนดและใช้งานคลาส คุณสามารถทำได้บนพื้นฐานของคลาสที่มีอยู่ นำเนื้อหาที่กำหนดโดยคลาสที่มีอยู่เป็นเนื้อหาของคุณเอง และเพิ่มเนื้อหาใหม่
คลาสพาเรนต์ - คลาสที่สืบทอดมาจากคลาสอื่นสามารถเรียกว่าคลาสพาเรนต์ คลาสพื้นฐาน หรือคลาสซุปเปอร์
คลาสย่อย - คลาสที่สืบทอดมาจากคลาสอื่นเรียกว่าคลาสย่อยหรืออาจเรียกว่าคลาสที่ได้รับมาก็ได้
Polymorphism - Polymorphism หมายความว่าฟังก์ชันหรือวิธีการเดียวกันสามารถทำงานกับวัตถุหลายประเภทและได้ผลลัพธ์ที่แตกต่างกัน วัตถุที่แตกต่างกันสามารถสร้างผลลัพธ์ที่แตกต่างกันเมื่อได้รับข้อความเดียวกัน ปรากฏการณ์นี้เรียกว่าความหลากหลาย
Overloading - พูดง่ายๆ ก็คือสถานการณ์ที่ฟังก์ชันหรือเมธอดมีชื่อเดียวกันแต่มีรายการพารามิเตอร์ต่างกัน ฟังก์ชันหรือเมธอดดังกล่าวที่มีชื่อเดียวกันและพารามิเตอร์ต่างกันเรียกว่าฟังก์ชันหรือเมธอดที่โอเวอร์โหลด
Abstraction - Abstraction หมายถึงวัตถุนามธรรมที่มีโครงสร้างข้อมูล (คุณสมบัติ) และพฤติกรรม (การดำเนินการ) ที่สอดคล้องกันในชั้นเรียน คลาสคือสิ่งที่เป็นนามธรรมซึ่งสะท้อนถึงคุณสมบัติที่สำคัญที่เกี่ยวข้องกับแอปพลิเคชัน โดยไม่สนใจเนื้อหาอื่นๆ ที่ไม่เกี่ยวข้อง การแบ่งชั้นเรียนใดๆ เป็นเรื่องส่วนตัว แต่ต้องเกี่ยวข้องกับการใช้งานเฉพาะ
การห่อหุ้ม - การห่อหุ้มหมายถึงการเชื่อมโยงคุณสมบัติและพฤติกรรมของวัตถุที่มีอยู่ในโลกแห่งความเป็นจริงเข้าด้วยกันและวางไว้ภายในหน่วยลอจิคัล
ตัวสร้าง - ส่วนใหญ่จะใช้เพื่อเริ่มต้นวัตถุเมื่อสร้างวัตถุนั่นคือการกำหนดค่าเริ่มต้นให้กับตัวแปรสมาชิกของวัตถุ มันจะใช้ร่วมกับตัวดำเนินการใหม่ในคำสั่งเสมอเพื่อสร้างวัตถุ
Destructor - Destructor (destructor) ตรงกันข้ามกับ Constructor เมื่อวัตถุสิ้นสุดวงจรชีวิต (เช่น ฟังก์ชั่นที่วัตถุนั้นถูกเรียก) ระบบจะดำเนินการ destructor โดยอัตโนมัติ Destructors มักใช้เพื่อ "ล้างข้อมูล" (เช่น เมื่อสร้างอ็อบเจ็กต์ ให้ใช้ new เพื่อเปิดพื้นที่หน่วยความจำ ซึ่งควรจะปล่อยออกมาพร้อมกับ Delete ใน destructor ก่อนออก)
ในรูปด้านล่าง เราได้สร้างวัตถุสามชิ้นผ่านคลาสรถยนต์: Mercedes, BMW และ Audi
$mercedes = รถใหม่ ();$bmw = รถใหม่ ();$audi = รถใหม่ ();
รูปแบบไวยากรณ์ปกติสำหรับการกำหนดคลาสใน PHP จะเป็นดังนี้:
<?phpclass phpClass { var $var1; var $var2 = "สตริงคงที่"; function myfunc ($arg1, $arg2) { [..] } [..]}?>การวิเคราะห์มีดังนี้:
คลาสถูกกำหนดโดยใช้คีย์เวิร์ด class ตามด้วยชื่อคลาส
ตัวแปรและวิธีการสามารถกำหนดได้ภายในวงเล็บปีกกา ({}) หลังชื่อคลาส
ตัวแปรคลาสถูกประกาศโดยใช้ var และตัวแปรยังสามารถเริ่มต้นด้วยค่าได้อีกด้วย
คำจำกัดความของฟังก์ชันจะคล้ายกับคำจำกัดความของฟังก์ชัน PHP แต่ฟังก์ชันต่างๆ สามารถเข้าถึงได้ผ่านคลาสและอ็อบเจ็กต์ที่สร้างอินสแตนซ์เท่านั้น
<?phpclass Site { /* ตัวแปรสมาชิก*/ var $url; /* ฟังก์ชั่นสมาชิก*/ function setUrl($par){ $this->url = $par; } function getUrl(){ echo $this ->url . PHP_EOL; } ฟังก์ชั่น setTitle($par){ $this->title = $par; } ฟังก์ชั่น getTitle(){ echo $this->title . -ตัวแปร $this แสดงถึงอ็อบเจ็กต์ของตัวเอง
PHP_EOL เป็นอักขระขึ้นบรรทัดใหม่
หลังจากสร้างคลาสแล้ว เราสามารถใช้ตัวดำเนินการ ใหม่ เพื่อสร้างอินสแตนซ์อ็อบเจ็กต์ของคลาสนั้นได้:
$codercto = ไซต์ใหม่;$taobao = ไซต์ใหม่;$google = ไซต์ใหม่;
ในโค้ดข้างต้น เราได้สร้างอ็อบเจ็กต์ขึ้นมาสามอ็อบเจ็กต์ แต่ละอ็อบเจ็กต์นั้นมีความเป็นอิสระ ต่อไป เรามาดูวิธีการเข้าถึงเมธอดสมาชิกและตัวแปรสมาชิกกัน
หลังจากสร้างอินสแตนซ์ของวัตถุแล้ว เราสามารถใช้วัตถุเพื่อเรียกเมธอดสมาชิกของออบเจ็กต์ได้เฉพาะกับตัวแปรสมาชิกของออบเจ็กต์เท่านั้น:
// เรียกใช้ฟังก์ชันสมาชิกเพื่อตั้งชื่อและ URL $codercto->setTitle( "Coder Tutorial" );$taobao->setTitle( "Taobao" );$google->setTitle( "Google Search" );$codercto- > setUrl( 'www.codercto.com' );$taobao->setUrl( 'www.taobao.com' );$google->setUrl( 'www.google.com' );// เรียกใช้ฟังก์ชันสมาชิกเพื่อรับชื่อและ URL $codercto->getTitle();$taobao->getTitle();$google->getTitle();$codercto->getUrl();$taobao-> getUrl( );$google->getUrl();
รหัสที่สมบูรณ์มีดังนี้:
<?php class Site { /* ตัวแปร สมาชิก */ var $url ; /* ฟังก์ชั่นสมาชิก */ function setUrl ( $par ) { $this -> url = $par } function getUrl (){ echo $ นี้ -> url . PHP_EOL ; } ฟังก์ชั่น setTitle ( $par ){ $this - > title = $par ; } ฟังก์ชั่น getTitle (){ echo $this - > title ; }} $codercto = ไซต์ ใหม่ ; $taobao = ไซต์ ใหม่ ; $google = ไซต์ ใหม่ ; // เรียกฟังก์ชันสมาชิก ตั้งชื่อและ URL $ codercto - > setTitle ( " Coder Tutorial" ); " ); $google -> setTitle ( "ค้นหาโดย Google" ); $codercto -> setUrl ( 'www.codercto.com' ); $taobao -> setUrl ( 'www.taobao.com' ); $google -> setUrl ( ' www.google.com ' ); // เรียกใช้ฟังก์ชันสมาชิกเพื่อรับชื่อและ URL $ codercto -> getTitle ( ) ; ); $google -> getTitle ( ) ; $codercto -> getUrl (); $ taobao - > getUrl ( ) ;เมื่อรันโค้ดข้างต้น ผลลัพธ์ที่ได้คือ:
กวดวิชาเกษตรกรรหัส ค้นหาใน Google Taobao www.codercto.comwww.taobao.comwww.google.com
Constructor เป็นวิธีการพิเศษ ส่วนใหญ่จะใช้เพื่อเริ่มต้นวัตถุเมื่อสร้างวัตถุนั่นคือการกำหนดค่าเริ่มต้นให้กับตัวแปรสมาชิกของวัตถุและใช้กับตัวดำเนินการ new ในคำสั่งเพื่อสร้างวัตถุ
PHP 5 ช่วยให้นักพัฒนาสามารถกำหนดวิธีการเป็นตัวสร้างในคลาสได้ โดยมีไวยากรณ์ดังต่อไปนี้:
เป็นโมฆะ __ สร้าง ([ ผสม $args [, $... ]] )
ในตัวอย่างข้างต้น เราสามารถเริ่มต้นตัวแปร $url และ $title ผ่านทาง Constructor:
ฟังก์ชั่น __construct( $par1, $par2 ) { $this->url = $par1; $this->title = $par2;}ตอนนี้เราไม่จำเป็นต้องเรียกใช้เมธอด setTitle และ setUrl อีกต่อไป:
$codercto = ไซต์ใหม่('www.codercto.com', 'บทช่วยสอนการเขียนโค้ด');$taobao = ไซต์ใหม่('www.taobao.com', 'Taobao');$google = ไซต์ใหม่('www.google . com', 'ค้นหาโดย Google');// เรียกใช้ฟังก์ชันสมาชิกเพื่อรับชื่อและ URL $codercto->getTitle();$taobao->getTitle();$google->getTitle();$codercto->getUrl();$taobao->getUrl(); $google ->getUrl();Destructor (destructor) ตรงกันข้ามกับ Constructor เมื่ออ็อบเจ็กต์สิ้นสุดวงจรชีวิตของมัน (เช่น ฟังก์ชันที่อ็อบเจ็กต์นั้นถูกเรียกใช้) ระบบจะดำเนินการกับ destructor โดยอัตโนมัติ
PHP 5 แนะนำแนวคิดของ destructors ซึ่งคล้ายกับภาษาเชิงวัตถุอื่นๆ ไวยากรณ์ของมันคือดังนี้:
เป็นโมฆะ __ ทำลาย ( เป็นโมฆะ )
<?phpclass MyDestructableClass { function __construct() { print "constructorn"; $this->name = "MyDestructableClass"; } ฟังก์ชัน __destruct() { พิมพ์ "destroy" . }$obj = MyDestructableClass();?> ใหม่เมื่อรันโค้ดข้างต้น ผลลัพธ์ที่ได้คือ:
ตัวสร้างทำลาย MyDestructableClass
PHP ใช้คำสำคัญ ขยาย เพื่อสืบทอดคลาส PHP ไม่รองรับการสืบทอดหลายรูปแบบ:
class Child ขยายผู้ปกครอง { // ส่วนรหัส}ในตัวอย่าง คลาส Child_Site สืบทอดคลาส Site และขยายฟังก์ชัน:
<?php // Child_Site ขยายไซต์ { var $category; function setCate($par){ $this->category = $par; } function getCate(){ echo $this->category }}หากวิธีการที่สืบทอดมาจากคลาสหลักไม่สามารถตอบสนองความต้องการของคลาสย่อยได้ กระบวนการนี้เรียกว่าการแทนที่เมธอด หรือที่เรียกว่าการเขียนเมธอดใหม่
วิธีการ getUrl และ getTitle ถูกแทนที่ในตัวอย่าง:
ฟังก์ชั่น getUrl() { echo $this->url . return $this->title;}การควบคุมการเข้าถึงคุณสมบัติหรือวิธีการของ PHP ทำได้โดยการเพิ่มคำหลักสาธารณะ ป้องกัน หรือส่วนตัวไว้ข้างหน้า
สาธารณะ: สมาชิกคลาสสาธารณะสามารถเข้าถึงได้จากทุกที่
protected: สมาชิกคลาสที่ได้รับการป้องกันสามารถเข้าถึงได้ด้วยตัวเองและคลาสย่อยและคลาสพาเรนต์
ส่วนตัว: สมาชิกคลาสส่วนตัวสามารถเข้าถึงได้โดยคลาสที่กำหนดเท่านั้น
แอ็ตทริบิวต์คลาสต้องถูกกำหนดให้เป็นหนึ่งในแอ็ตทริบิวต์สาธารณะ มีการป้องกัน หรือส่วนตัว หากกำหนดด้วย var จะถือเป็นสาธารณะ
<?php/** * กำหนด MyClass */class MyClass{ public $public = 'Public'; echo $this->protected; echo $this->private; }}$obj = new MyClass();echo $obj->public; // บรรทัดนี้สามารถดำเนินการได้ตามปกติ echo $obj->protected; // บรรทัดนี้จะสร้างข้อผิดพลาดร้ายแรง echo $obj->private; // บรรทัดนี้จะสร้างข้อผิดพลาดร้ายแรง $obj->printHello(); // เอาท์พุต Public, Protected และ Private/** * Define MyClass2 */ คลาส MyClass2 ขยาย MyClass{ // สาธารณะและการป้องกันสามารถกำหนดใหม่ได้ แต่ส่วนตัว แต่ไม่ได้ป้องกัน $protected = 'Protected2'; ฟังก์ชัน printHello() { echo $this->public; $this->protected; echo $this->private; }}$obj2 = new MyClass2();echo $obj2->public; // บรรทัดนี้สามารถดำเนินการได้ตามปกติ echo $obj2->private; กำหนด $obj2->protected; // บรรทัดนี้จะสร้างข้อผิดพลาดร้ายแรง $obj2->printHello(); // เอาต์พุตสาธารณะ, Protected2 และไม่ได้กำหนด?>วิธีการในชั้นเรียนสามารถกำหนดเป็นสาธารณะ ส่วนตัว หรือได้รับการคุ้มครอง หากไม่ได้ตั้งค่าคำสำคัญเหล่านี้ วิธีการจะมีค่าเริ่มต้นเป็นสาธารณะ
<?php/** * Define MyClass */class MyClass{ // ประกาศฟังก์ชั่นสาธารณะของคอนสตรัคเตอร์สาธารณะ __construct() { } // ประกาศวิธีการสาธารณะ ฟังก์ชั่นสาธารณะ MyPublic() { } // ประกาศวิธีการที่ได้รับการป้องกัน ฟังก์ชั่นที่ได้รับการป้องกัน MyProtected( ) { } // ประกาศวิธีการส่วนตัว ฟังก์ชั่นส่วนตัว MyPrivate() { } // วิธีนี้เป็นฟังก์ชั่นสาธารณะ Foo() { $this->MyPublic(); $this->MyProtected(); $this->MyPrivate(); }}$myclass = new MyClass;$myclass->MyPublic(); // บรรทัดนี้สามารถดำเนินการได้ตามปกติ $myclass->MyProtected(); บรรทัดนี้จะสร้างข้อผิดพลาดร้ายแรง $myclass->MyPrivate(); // บรรทัดนี้จะสร้างข้อผิดพลาดร้ายแรง $myclass->Foo(); // สาธารณะ, ได้รับการป้องกันและส่วนตัวสามารถดำเนินการได้ทั้งหมด/** * กำหนด MyClass2 */class MyClass2 ขยาย MyClass{ // วิธีนี้เป็นฟังก์ชันสาธารณะ Foo2() { $this->MyPublic(); $this->MyProtected(); $this->MyPrivate(); create A fatal error}}$myclass2 = new MyClass2;$myclass2->MyPublic(); // บรรทัดนี้สามารถดำเนินการได้ตามปกติ $myclass2->Foo2(); สามารถดำเนินการได้ทั้งแบบสาธารณะและแบบป้องกัน แต่แบบส่วนตัวไม่สามารถทำได้ class Bar { public function test() { $this->testPrivate(); $this->testPublic() } public function testPublic() { echo "Bar: :testPublicn"; } ฟังก์ชั่นส่วนตัว testPrivate() { echo "Bar::testPrivaten"; }}คลาส Foo ขยาย Bar { ฟังก์ชั่นสาธารณะ testPublic() { echo "Foo::testPublicn"; } ฟังก์ชั่นส่วนตัว testPrivate() { echo "Foo::testPrivaten"; }}$myFoo = new foo();$myFoo->test(); // ฟู::testPublic?>เมื่อใช้อินเทอร์เฟซ คุณสามารถระบุวิธีการที่คลาสต้องใช้ แต่คุณไม่จำเป็นต้องกำหนดเนื้อหาเฉพาะของวิธีการเหล่านี้
อินเทอร์เฟซถูกกำหนดผ่านคีย์เวิร์ด ของอินเทอร์เฟซ เช่นเดียวกับการกำหนดคลาสมาตรฐาน แต่วิธีการทั้งหมดที่กำหนดไว้ในนั้นจะว่างเปล่า
วิธีการทั้งหมดที่กำหนดไว้ในอินเทอร์เฟซจะต้องเป็นแบบสาธารณะ นี่เป็นลักษณะของอินเทอร์เฟซ
หากต้องการใช้อินเทอร์เฟซ ให้ใช้ตัวดำเนินการ Implements คลาสจะต้องใช้วิธีการทั้งหมดที่กำหนดไว้ในอินเทอร์เฟซ มิฉะนั้นข้อผิดพลาดร้ายแรงจะถูกรายงาน คลาสสามารถใช้หลายอินเทอร์เฟซได้ ใช้เครื่องหมายจุลภาคเพื่อแยกชื่อของหลายอินเทอร์เฟซ
<?php// ประกาศอินเทอร์เฟซ 'iTemplate' อินเทอร์เฟซ iTemplate{ ฟังก์ชั่นสาธารณะ setVariable($name, $var); ฟังก์ชั่นสาธารณะ getHtml($template);}// ใช้งานคลาสอินเทอร์เฟซ เทมเพลตใช้ iTemplate{ ส่วนตัว $vars = array( ) ; ฟังก์ชั่นสาธารณะ setVariable($name, $var) { $this->vars[$name] = $var; } ฟังก์ชั่นสาธารณะ getHtml($template) { foreach($this->vars as $name => $value) { $template = str_replace('{' . $name . '}', $value, $template);ค่าที่ยังคงไม่เปลี่ยนแปลงตลอดทั้งคลาสสามารถกำหนดค่าเป็นค่าคงที่ได้ ไม่จำเป็นต้องใช้สัญลักษณ์ $ เมื่อกำหนดและใช้ค่าคงที่
ค่าของค่าคงที่ต้องเป็นค่าคงที่และไม่สามารถเป็นตัวแปร คุณลักษณะของคลาส ผลลัพธ์ของการดำเนินการทางคณิตศาสตร์ หรือการเรียกใช้ฟังก์ชัน
ตั้งแต่ PHP 5.3.0 คลาสสามารถเรียกแบบไดนามิกได้โดยใช้ตัวแปร แต่ค่าของตัวแปรนี้ไม่สามารถเป็นคำหลักได้ (เช่น self, parent หรือ static)
<?phpclass MyClass{ const Constant = 'ค่าคงที่'; function showConstant() { echo self::constant . PHP_EOL; }}echo MyClass::constant . PHP_EOL; // ตั้งแต่ 5.3.0 $class = new MyClass();$class->showConstant();echo $class::constantคลาสใดๆ จะต้องได้รับการประกาศให้เป็นนามธรรม หากมีอย่างน้อยหนึ่งวิธีในนั้นที่ถูกประกาศให้เป็นนามธรรม
คลาสที่กำหนดให้เป็นนามธรรมไม่สามารถสร้างอินสแตนซ์ได้
วิธีการที่กำหนดเป็นนามธรรมจะประกาศวิธีการเรียกเท่านั้น (พารามิเตอร์) และไม่สามารถกำหนดการใช้งานฟังก์ชันเฉพาะได้
เมื่อสืบทอดคลาสนามธรรม คลาสย่อยจะต้องกำหนดวิธีนามธรรมทั้งหมดในคลาสพาเรนต์ นอกจากนี้ การควบคุมการเข้าถึงของเมธอดเหล่านี้จะต้องเหมือนกัน (หรือผ่อนคลายกว่า) เช่นเดียวกับในคลาสพาเรนต์ ตัวอย่างเช่น หากวิธีนามธรรมถูกประกาศเป็นการป้องกัน วิธีการที่ใช้ในคลาสย่อยควรได้รับการประกาศเป็นการป้องกันหรือสาธารณะ และไม่สามารถกำหนดเป็นแบบส่วนตัวได้
<?phpabstract class AbstractClass{ // บังคับสำหรับคลาสย่อยเพื่อกำหนดวิธีการเหล่านี้ ฟังก์ชัน abstract protected function getValue() { print $this - >getValue() . PHP_EOL; }}คลาส ConcreteClass1 ขยาย AbstractClass{ ฟังก์ชันที่ได้รับการป้องกัน getValue() { กลับ "ConcreteClass1"; prefixValue($prefix) { return "{$prefix}ConcreteClass1"; }}คลาส ConcreteClass2 ขยาย AbstractClass{ public function getValue() { return "ConcreteClass2"; } public function prefixValue($prefix) { return "{$prefix}ConcreteClass2" ; }}$class1 = ใหม่ ConcreteClass1;$class1->printOut();echo $class1->prefixValue('FOO_') . PHP_EOL;$class2 = new ConcreteClass2;$class2->printOut();echo $class2->prefixValue('FOO_')เมื่อรันโค้ดข้างต้น ผลลัพธ์ที่ได้คือ:
คอนกรีตคลาส1FOO_คอนกรีตคลาส1คอนกรีตคลาส2FOO_คอนกรีตคลาส2
นอกจากนี้ เมธอดคลาสลูกสามารถมีพารามิเตอร์ทางเลือกที่ไม่มีอยู่ในเมธอดนามธรรมคลาสพาเรนต์
ตัวอย่างเช่น หากคลาสย่อยกำหนดพารามิเตอร์ทางเลือกที่ไม่รวมอยู่ในการประกาศเมธอด abstract ของคลาสพาเรนต์ คลาสย่อยก็ยังสามารถรันได้ตามปกติ
<?phpabstract class AbstractClass{ // วิธีการนามธรรมของเราเพียงต้องการกำหนดพารามิเตอร์ที่จำเป็น ฟังก์ชันการป้องกันนามธรรม prefixName($name);}คลาส ConcreteClass ขยาย AbstractClass{ // คลาสย่อยของเราสามารถกำหนดตัวเลือกเสริมที่ไม่มีอยู่ในลายเซ็นคลาสหลัก พารามิเตอร์ ฟังก์ชั่นสาธารณะ prefixName($name, $separator = ".") { if ($name == "Pacman") { $prefix = "Mr"; } elseif ($name == "Pacwoman") { $prefix = "Mrs"; } else { $prefix = ""; } return "{$prefix}{$separator} {$name}"; }}$class = new ConcreteClass;echo $class->prefixName("Pacman "), "n";echo $class->prefixName("Pacwoman"), "n";?>ผลลัพธ์คือ:
นายแพ็กแมน นางแพ็กวูแมน
การประกาศแอตทริบิวต์หรือวิธีการของคลาสเป็นแบบคงที่ช่วยให้คุณสามารถเข้าถึงได้โดยตรงโดยไม่ต้องสร้างอินสแตนซ์ของคลาส
ไม่สามารถเข้าถึงคุณสมบัติแบบคงที่ผ่านวัตถุของคลาสที่ได้รับการสร้างอินสแตนซ์ (แต่วิธีการแบบคงที่สามารถทำได้)
เนื่องจากวิธีการแบบคงที่ไม่จำเป็นต้องมีการเรียกวัตถุ ตัวแปรหลอก $this จึงไม่สามารถใช้ได้ในวิธีการแบบคงที่
อ็อบเจ็กต์ไม่สามารถเข้าถึงคุณสมบัติคงที่ผ่านตัวดำเนินการ ->
ตั้งแต่ PHP 5.3.0 คลาสสามารถเรียกแบบไดนามิกได้โดยใช้ตัวแปร แต่ค่าของตัวแปรนี้ไม่สามารถเป็นคีย์เวิร์ด self, parent หรือ static
<?phpclass Foo { public static $my_static = 'foo'; public function staticValue() { return self::$my_static; }} พิมพ์ Foo::$my_static . >staticValue() .PHP_EOL;?>เมื่อรันโปรแกรมข้างต้น ผลลัพธ์ที่ได้คือ:
ฟูฟู
PHP 5 เพิ่มคำหลักสุดท้ายใหม่ ถ้าเมธอดในคลาสพาเรนต์ถูกประกาศขั้นสุดท้าย คลาสย่อยจะไม่สามารถแทนที่เมธอดได้ หากมีการประกาศคลาสเป็นที่สิ้นสุด จะไม่สามารถสืบทอดได้
ข้อผิดพลาดจะถูกรายงานเมื่อรันโค้ดต่อไปนี้:
<?phpclass BaseClass { การทดสอบฟังก์ชันสาธารณะ () { echo "BaseClass::test() เรียกว่า" } } คลาส ChildClass ขยาย BaseClass { ฟังก์ชั่นสาธารณะ moreTesting() { echo "ChildClass::moreTesting() เรียกว่า" }}// ข้อความแสดงข้อผิดพลาด ข้อผิดพลาดร้ายแรง: ไม่สามารถแทนที่วิธีสุดท้าย BaseClass::moreTesting()?>PHP จะไม่เรียก Constructor ของคลาสแม่โดยอัตโนมัติในตัว Constructor ของคลาสลูก ในการรันคอนสตรัคเตอร์ของคลาสพาเรนต์ คุณต้องเรียก parent::__construct() ในคอนสตรัคเตอร์ของคลาสลูก
<?phpclass BaseClass { function __construct() { print "Constructor method in BaseClass class" . PHP_EOL; }}คลาสย่อยขยาย BaseClass { function __construct() { parent::__construct(); // ตัวสร้างคลาสย่อยไม่สามารถเรียกพาเรนต์ได้โดยอัตโนมัติ วิธีการสร้างคลาสพิมพ์ "วิธีการสร้างในคลาส SubClass" }}คลาส OtherSubClass ขยาย BaseClass { // สืบทอดวิธีการสร้างของ BaseClass}// เรียกตัวสร้าง BaseClass $obj = new BaseClass(); // เรียกตัวสร้าง BaseClass และ SubClass $obj = new SubClass(); // เรียกตัวสร้าง BaseClass $obj = new OtherSubClass();?>เมื่อรันโปรแกรมข้างต้น ผลลัพธ์ที่ได้คือ:
วิธีตัวสร้างในคลาส BaseClass วิธีตัวสร้างในคลาส SubClass วิธีตัวสร้างในคลาส BaseClass