PHP เชิงวัตถุ

ในการเขียนโปรแกรมเชิงวัตถุ (อังกฤษ: การเขียนโปรแกรมเชิงวัตถุชื่อย่อ: OOP) วัตถุที่เป็นรายละเอียดของข้อมูลและการประมวลผลข้อมูลที่ประกอบด้วยทั้งที่เป็นนามธรรมโลกแห่งความจริง

สิ่งที่เป็นวัตถุในโลกแห่งความจริงที่เราเผชิญเช่นคอมพิวเตอร์, โทรทัศน์, จักรยาน

สามลักษณะที่สำคัญของวัตถุที่:

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

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

เนื้อหาเชิงวัตถุ

• คลาส - กำหนดลักษณะนามธรรมของสิ่งที่การกำหนดระดับมีข้อมูลรูปแบบและการดำเนินการกับข้อมูล

• วัตถุ - เป็นตัวอย่างของการเรียน

• ตัวแปรสมาชิก - ตัวแปรที่กำหนดไว้ในชั้นเรียนค่าภายนอกของตัวแปรจะมองไม่เห็น แต่สามารถเข้าถึงได้โดยฟังก์ชั่นสมาชิกหลังเลิกเรียนจะ instantiated เป็นวัตถุคุณสมบัติของวัตถุที่สามารถเรียกได้ว่าตัวแปร

• ฟังก์ชั่นสมาชิก - กำหนดภายในชั้นเรียนสามารถนำมาใช้สำหรับวัตถุการเข้าถึงข้อมูล

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

• ระดับผู้ปกครอง - คลาสที่สืบทอดโดยชั้นเรียนอื่น ๆ ในชั้นเรียนอาจจะเรียกว่าชั้นผู้ปกครองกลุ่มหรือชั้นเรียนหรือ superclass

• ซับคลาส - คลาสที่สืบทอดระดับที่เรียกว่าประเภทรองอื่นยังสามารถเรียกว่าชั้นมา

• polymorphism - polymorphism หมายถึงการดำเนินการเดียวกันหรือฟังก์ชั่นกระบวนการที่สามารถนำไปใช้กับหลายประเภทของวัตถุและได้รับผลลัพธ์ที่แตกต่างกันวัตถุที่แตกต่างคุณได้รับข้อความเดียวกันอาจให้ผลลัพธ์ที่แตกต่างกันปรากฏการณ์นี้เรียกว่าแตกต่าง

• เกิน - ระยะสั้นจะเป็นฟังก์ชั่นหรือวิธีการที่มีชื่อเดียวกัน แต่รายการพารามิเตอร์ไม่ได้เป็นสถานการณ์เดียวกันเช่นฟังก์ชั่นหรือวิธีการระหว่างพารามิเตอร์ที่แตกต่างกันในชื่อเดียวกันแต่ละฟังก์ชั่นมากเกินไปหรือวิธีการที่เรียกว่า

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

• แพคเกจ - แพคเกจหมายถึงคุณสมบัติและพฤติกรรมของวัตถุในโลกแห่งความจริงที่มีอยู่ในการผูกเข้าด้วยกันและวางไว้ในหน่วยตรรกะ

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

• Destructor - destructor (เตาเผา) และสร้างในทางตรงกันข้ามเมื่อปลายวัตถุของวงจรชีวิตของมัน (ตัวอย่างเช่นที่วัตถุคือการเรียกฟังก์ชันเสร็จสิ้น) ระบบจะทำการ destructor โดยอัตโนมัติdestructors มักจะใช้ในการทำ "ทำความสะอาดผลพวงของ" งาน (ตัวอย่างเช่นเมื่อคุณสร้างวัตถุด้วยใหม่เปิดพื้นที่หน่วยความจำควรใช้ก่อนที่จะออกในเตาเผาลบปล่อย)

รูปต่อไปนี้เราจะสร้างวัตถุสามชั้นรถ: Mercedes, BMW, และออดี้

$mercedes = new Car ();
$bmw = new Car ();
$audi = new Car ();

การกำหนดระดับ PHP

ชั้นเอง PHP มักไวยากรณ์เป็นดังนี้:

<?php
class phpClass {
  var $var1;
  var $var2 = "constant string";
  
  function myfunc ($arg1, $arg2) {
     [..]
  }
  [..]
}
?>

ตีความว่าเป็นดังนี้

• หลังเลิกเรียนโดยใช้คำหลักระดับบวกชื่อของคำนิยามชั้นเรียน

• คู่ของวงเล็บหลังชื่อของชั้นเรียนสามารถกำหนดตัวแปรและวิธีการ ({}) ภายใน

• ตัวแปรระดับการใช้var ประกาศตัวแปรยังสามารถเริ่มต้นได้ค่า

• นิยามฟังก์ชัน PHP คล้ายกับคำนิยามของฟังก์ชั่น แต่ฟังก์ชั่นที่สามารถเข้าถึงได้เพียงผ่านการเรียนและวัตถุ instantiated ของมัน

ตัวอย่าง

<?php
class Site {
  /* 成员变量 */
  var $url;
  var $title;
  
  /* 成员函数 */
  function setUrl($par){
     $this->url = $par;
  }
  
  function getUrl(){
     echo $this->url . PHP_EOL;
  }
  
  function setTitle($par){
     $this->title = $par;
  }
  
  function getTitle(){
     echo $this->title . PHP_EOL;
  }
}
?>

$ ตัวแปรนี้แสดงวัตถุของพวกเขา

PHP_EOL ขึ้นบรรทัดใหม่

PHP ในการสร้างวัตถุ

หลังเลิกเรียนจะถูกสร้างขึ้นเราสามารถใช้ประกอบการใหม่ที่จะยกตัวอย่างวัตถุของคลาสนี้:

$w3big = new Site;
$taobao = new Site;
$google = new Site;

รหัสข้างต้นเราจะสร้างวัตถุสามแต่ละสามวัตถุมีความเป็นอิสระแล้วเราดูที่วิธีการในการเข้าถึงวิธีการของสมาชิกและตัวแปรสมาชิก

เรียกวิธีสมาชิก

หลังจากที่วัตถุถูก instantiated เราสามารถใช้วัตถุที่เรียกวิธีการของสมาชิกวิธีการของวัตถุเท่านั้นที่สามารถจะเป็นสมาชิกของตัวแปรสมาชิกในการดำเนินงานของวัตถุ:

// 调用成员函数，设置标题和URL
$w3big->setTitle( "本教程" );
$taobao->setTitle( "淘宝" );
$google->setTitle( "Google 搜索" );

$w3big->setUrl( 'www.w3big.com' );
$taobao->setUrl( 'www.taobao.com' );
$google->setUrl( 'www.google.com' );

// 调用成员函数，获取标题和URL
$w3big->getTitle();
$taobao->getTitle();
$google->getTitle();

$w3big->getUrl();
$taobao->getUrl();
$google->getUrl();

รหัสที่สมบูรณ์จะเป็นดังนี้:

การดำเนินงานของโค้ดข้างต้นผลลัพธ์คือ:

本教程
淘宝
Google 搜索
www.w3big.com
www.taobao.com
www.google.com

PHP สร้าง

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

PHP 5 ช่วยให้นักพัฒนาที่จะกำหนดแถววิธีการในชั้นเรียนเป็นไวยากรณ์คอนสตรัคเป็นดังนี้:

void __construct ([ mixed $args [, $... ]] )

ในตัวอย่างข้างต้นเราสามารถเริ่มต้น $ URL และตัวแปรชื่อ $ ผ่านสร้าง:

function __construct( $par1, $par2 ) {
   $this->url = $par1;
   $this->title = $par2;
}

ตอนนี้เราไม่จำเป็นต้องเรียก setTitle วิธีการและ setUrl:

destructor

Destructor (เตาเผา) และสร้างในทางตรงกันข้ามเมื่อปลายวัตถุของวงจรชีวิตของมัน (ตัวอย่างเช่นที่วัตถุคือการเรียกฟังก์ชันเสร็จสิ้น) ระบบอัตโนมัติดำเนิน destructor

PHP 5 แนะนำแนวคิดของเตาเผาซึ่งมีลักษณะคล้ายกับภาษาเชิงวัตถุอื่น ๆ ที่ไวยากรณ์เป็นดังนี้:

void __destruct ( void )

ตัวอย่าง

<?php
class MyDestructableClass {
   function __construct() {
       print "构造函数\n";
       $this->name = "MyDestructableClass";
   }

   function __destruct() {
       print "销毁 " . $this->name . "\n";
   }
}

$obj = new MyDestructableClass();
?>

การดำเนินงานของโค้ดข้างต้นผลลัพธ์คือ:

构造函数
销毁 MyDestructableClass

สืบทอด

PHPขยายคำหลักที่จะสืบทอดชั้น PHP ไม่สนับสนุนการสืบทอดหลายในรูปแบบต่อไปนี้:

class Child extends Parent {
   // 代码部分
}

ตัวอย่าง

ตัวอย่างคลาส Child_Site สืบทอดคลาสเว็บไซต์และขยายการทำงานไปนี้:

<?php 
// 子类扩展站点类别
class Child_Site extends Site {
   var $category;

	function setCate($par){
		$this->category = $par;
	}
  
	function getCate(){
		echo $this->category . PHP_EOL;
	}
}

วิธีการแทนที่

ถ้าคุณไม่สามารถตอบสนองความต้องการของ subclass สืบทอดมาจากวิธีการเรียนผู้ปกครองก็สามารถเขียนเป็นกระบวนการที่เรียกว่าวิธีการซ้อนทับ (แทนที่) ยังเป็นที่รู้จักวิธีการเอาชนะ

ตัวอย่างการเขียน getUrl และ GetTitle วิธีการ:

function getUrl() {
   echo $this->url . PHP_EOL;
   return $this->url;
}
   
function getTitle(){
   echo $this->title . PHP_EOL;
   return $this->title;
}

การควบคุมการเข้าถึง

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

• สาธารณะ (Public): สมาชิกระดับประชาชนสามารถเข้าถึงได้ทุกที่
• การป้องกัน (ป้องกัน): สมาชิกระดับการป้องกันสามารถเข้าถึงได้โดยตัวของมันเองเช่นเดียวกับชั้นย่อยและระดับผู้ปกครอง
• ส่วนตัว (ส่วนตัว): สมาชิกระดับเอกชนเท่านั้นที่สามารถเข้าถึงได้ที่การกำหนดชั้น

คุณลักษณะการควบคุมการเข้าถึง

แอตทริบิวต์ชั้นต้องได้รับการกำหนดให้เป็นสาธารณะป้องกันเอกชนหนึ่ง หากกำหนดด้วย var ก็ถือว่าเป็นสาธารณะ

<?php
/**
 * Define MyClass
 */
class MyClass
{
    public $public = 'Public';
    protected $protected = 'Protected';
    private $private = 'Private';

    function printHello()
    {
        echo $this->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
 */
class MyClass2 extends MyClass
{
    // 可以对 public 和 protected 进行重定义，但 private 而不能
    protected $protected = 'Protected2';

    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}

$obj2 = new MyClass2();
echo $obj2->public; // 这行能被正常执行
echo $obj2->private; // 未定义 private
echo $obj2->protected; // 这行会产生一个致命错误
$obj2->printHello(); // 输出 Public、Protected2 和 Undefined

?>

วิธีการควบคุมการเข้าถึง

วิธีการในชั้นเรียนสามารถกำหนดเป็นภาครัฐภาคเอกชนหรือการป้องกัน หากคุณไม่ได้ตั้งค่าคำหลักเหล่านี้วิธีการเริ่มต้นให้กับประชาชน

<?php
/**
 * Define MyClass
 */
class MyClass
{
    // 声明一个公有的构造函数
    public function __construct() { }

    // 声明一个公有的方法
    public function MyPublic() { }

    // 声明一个受保护的方法
    protected function MyProtected() { }

    // 声明一个私有的方法
    private function MyPrivate() { }

    // 此方法为公有
    function Foo()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate();
    }
}

$myclass = new MyClass;
$myclass->MyPublic(); // 这行能被正常执行
$myclass->MyProtected(); // 这行会产生一个致命错误
$myclass->MyPrivate(); // 这行会产生一个致命错误
$myclass->Foo(); // 公有，受保护，私有都可以执行


/**
 * Define MyClass2
 */
class MyClass2 extends MyClass
{
    // 此方法为公有
    function Foo2()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate(); // 这行会产生一个致命错误
    }
}

$myclass2 = new MyClass2;
$myclass2->MyPublic(); // 这行能被正常执行
$myclass2->Foo2(); // 公有的和受保护的都可执行，但私有的不行

class Bar 
{
    public function test() {
        $this->testPrivate();
        $this->testPublic();
    }

    public function testPublic() {
        echo "Bar::testPublic\n";
    }
    
    private function testPrivate() {
        echo "Bar::testPrivate\n";
    }
}

class Foo extends Bar 
{
    public function testPublic() {
        echo "Foo::testPublic\n";
    }
    
    private function testPrivate() {
        echo "Foo::testPrivate\n";
    }
}

$myFoo = new foo();
$myFoo->test(); // Bar::testPrivate 
                // Foo::testPublic
?>

อินเตอร์เฟซ

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

อินเตอร์เฟซที่ถูกกำหนดโดยคำหลักอินเตอร์เฟซเช่นความหมายของระดับมาตรฐาน แต่ซึ่งได้กำหนดวิธีการทั้งหมดที่มีที่ว่างเปล่า

วิธีการทั้งหมดที่กำหนดไว้ในอินเตอร์เฟซจะต้องเป็นของประชาชนซึ่งเป็นลักษณะของอินเตอร์เฟซ

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

<?php

// 声明一个'iTemplate'接口
interface iTemplate
{
    public function setVariable($name, $var);
    public function getHtml($template);
}


// 实现接口
class Template implements iTemplate
{
    private $vars = array();
  
    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }
  
    public function getHtml($template)
    {
        foreach($this->vars as $name => $value) {
            $template = str_replace('{' . $name . '}', $value, $template);
        }
 
        return $template;
    }
}

คงที่

คุณสามารถวางไว้ในระดับที่ยังคงค่าเดียวกันกำหนดเป็นค่าคงที่ ในความหมายและการใช้เวลาที่คงที่ไม่จำเป็นต้องใช้สัญลักษณ์ $

ค่าของคงต้องเป็นค่าคงที่ไม่ตัวแปรคุณลักษณะระดับผลทางคณิตศาสตร์หรือการเรียกใช้ฟังก์ชัน

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

ตัวอย่าง

<?php
class MyClass
{
    const constant = '常量值';

    function showConstant() {
        echo  self::constant . PHP_EOL;
    }
}

echo MyClass::constant . PHP_EOL;

$classname = "MyClass";
echo $classname::constant . PHP_EOL; // 自 5.3.0 起

$class = new MyClass();
$class->showConstant();

echo $class::constant . PHP_EOL; // 自 PHP 5.3.0 起
?>

ระดับนามธรรม

ชั้นใดถ้ามันมีอย่างน้อยหนึ่งวิธีที่ถูกประกาศเป็นนามธรรมแล้วชั้นนี้จะต้องได้รับการประกาศให้เป็นนามธรรม

ถูกกำหนดให้เป็นระดับนามธรรมไม่สามารถ instantiated

ถูกกำหนดให้เป็นวิธีนามธรรมเพียงประกาศการภาวนามัน (พารามิเตอร์), คุณไม่สามารถกำหนดดำเนินงานฟังก์ชั่นที่เฉพาะเจาะจง

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

<?php
abstract class AbstractClass
{
 // 强制要求子类定义这些方法
    abstract protected function getValue();
    abstract protected function prefixValue($prefix);

    // 普通方法（非抽象方法）
    public function printOut() {
        print $this->getValue() . PHP_EOL;
    }
}

class ConcreteClass1 extends AbstractClass
{
    protected function getValue() {
        return "ConcreteClass1";
    }

    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass1";
    }
}

class ConcreteClass2 extends AbstractClass
{
    public function getValue() {
        return "ConcreteClass2";
    }

    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass2";
    }
}

$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') . PHP_EOL;

$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') . PHP_EOL;
?>

การดำเนินงานของโค้ดข้างต้นผลลัพธ์คือ:

ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2

คำสำคัญแบบคงที่

ประกาศคุณสมบัติระดับหรือวิธีการเป็นแบบคงที่ (คงที่) คุณจะไม่สามารถยกตัวอย่างชั้นเรียนและการเข้าถึงโดยตรง

คงคุณสมบัติผ่านชั้นเรียนไม่สามารถ instantiated วัตถุในการเข้าถึง ( แต่วิธีการคงสามารถ)

เพราะวิธีการคงไม่จำเป็นต้องโทรผ่านวัตถุที่ $ หลอกตัวแปรนี้ไม่สามารถใช้ได้ในวิธีการคง

ในการเข้าถึงผู้ประกอบการ> - คงทรัพย์สินโดยไม่ได้เรื่อง

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

<?php
class Foo {
  public static $my_static = 'foo';
  
  public function staticValue() {
     return self::$my_static;
  }
}

print Foo::$my_static . PHP_EOL;
$foo = new Foo();

print $foo->staticValue() . PHP_EOL;
?>	

โปรแกรมข้างต้นผลลัพธ์คือ:

foo
foo

คำสำคัญรอบชิงชนะเลิศ

PHP 5 เพิ่มคำหลักสุดท้าย หากวิธีการเรียนของผู้ปกครองมีการประกาศครั้งสุดท้าย subclass ไม่สามารถแทนที่วิธีนี้ ถ้าชั้นจะมีการประกาศขั้นสุดท้ายแล้วก็ไม่สามารถจะได้รับมรดก

ข้อผิดพลาดการเรียกใช้รหัสต่อไปนี้:

<?php
class BaseClass {
   public function test() {
       echo "BaseClass::test() called" . PHP_EOL;
   }
   
   final public function moreTesting() {
       echo "BaseClass::moreTesting() called"  . PHP_EOL;
   }
}

class ChildClass extends BaseClass {
   public function moreTesting() {
       echo "ChildClass::moreTesting() called"  . PHP_EOL;
   }
}
// 报错信息 Fatal error: Cannot override final method BaseClass::moreTesting()
?>

โทรนวกรรมิกระดับผู้ปกครอง

PHP ไม่ได้โดยอัตโนมัติเรียก constructor ของคอนสตรัคชั้นผู้ปกครองในประเภทรองเพื่อดำเนินการสร้างคลาสพ่อแม่เราจะต้องเรียกผู้ปกครองในการสร้างของประเภทรอง :: __ สร้าง ()

<?php
class BaseClass {
   function __construct() {
       print "BaseClass 类中构造方法" . PHP_EOL;
   }
}
class SubClass extends BaseClass {
   function __construct() {
       parent::__construct();  // 子类构造方法不能自动调用父类的构造方法
       print "SubClass 类中构造方法" . PHP_EOL;
   }
}
class OtherSubClass extends BaseClass {
    // 继承 BaseClass 的构造方法
}

// 调用 BaseClass 构造方法
$obj = new BaseClass();

// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();

// 调用 BaseClass 构造方法
$obj = new OtherSubClass();
?>

โปรแกรมข้างต้นผลลัพธ์คือ:

BaseClass 类中构造方法
BaseClass 类中构造方法
SubClass 类中构造方法
BaseClass 类中构造方法