PHP berorientasikan objek
Dalam pengaturcaraan berorientasikan objek (Bahasa Inggeris: Pengaturcaraan berorientasikan objek, singkatan: OOP), objek ialah keseluruhan yang terdiri daripada maklumat dan penerangan tentang cara memproses maklumat dan merupakan abstraksi daripada dunia sebenar. OOP mencapai tiga matlamat kejuruteraan perisian: kebolehgunaan semula, fleksibiliti dan kebolehlanjutan.
PHP telah meningkatkan sokongannya untuk OOP selepas versi 4.0. Untuk aplikasi kecil, mungkin lebih mudah dan lebih cekap untuk menggunakan pengaturcaraan prosedur tradisional. Walau bagaimanapun, untuk aplikasi yang besar dan kompleks, OOP adalah pilihan yang mesti dipertimbangkan.
Kelas
Kelas ialah koleksi objek dengan sifat dan perkhidmatan yang sama. Ia menyediakan penerangan abstrak bersatu untuk semua objek kepunyaan kelas ini, yang merangkumi dua bahagian utama: sifat dan perkhidmatan. Dalam bahasa pengaturcaraan berorientasikan objek, kelas ialah unit program bebas Ia harus mempunyai nama kelas dan termasuk dua bahagian utama: perihalan atribut dan penerangan perkhidmatan.
Objek
Objek ialah entiti yang digunakan untuk menerangkan perkara objektif dalam sistem Ia adalah unit asas yang membentuk sistem. Objek terdiri daripada satu set sifat dan satu set perkhidmatan yang beroperasi pada set sifat.
Di dunia nyata, perkara yang kita hadapi adalah objek, seperti komputer, televisyen, basikal, dll.
Tiga ciri utama objek:
Gelagat objek: apakah operasi yang boleh digunakan pada objek, menghidupkan lampu dan mematikan lampu adalah tingkah laku.
Bentuk objek: cara objek bertindak balas apabila kaedah tersebut digunakan, warna, saiz, rupa.
Perwakilan objek: Perwakilan objek adalah bersamaan dengan kad ID, khususnya membezakan perbezaan dalam kelakuan dan status yang sama.
Hubungan antara kelas dan objek
Hubungan antara kelas dan objek adalah seperti hubungan antara acuan dan tuangan Hasil instantiasi kelas ialah objek, dan abstraksi jenis objek ialah kelas.
Sebagai contoh, Haiwan ialah kelas abstrak Kita boleh menentukan anjing dan biri-biri, dan anjing dan biri-biri adalah objek konkrit, boleh ditulis, boleh berlari dan keadaan tingkah laku yang lain.
Kandungan berorientasikan objek
Kelas − mentakrifkan ciri abstrak sesuatu perkara. Takrif kelas termasuk bentuk data dan operasi pada data.
Objek − ialah contoh kelas.
Pembolehubah ahli − pembolehubah ditakrifkan di dalam kelas. Nilai pembolehubah ini tidak dapat dilihat oleh dunia luar, tetapi boleh diakses melalui fungsi ahli Selepas kelas dijadikan sebagai objek, pembolehubah boleh dipanggil atribut objek.
Fungsi ahli − ditakrifkan di dalam kelas dan boleh digunakan untuk mengakses data objek.
Warisan − Warisan ialah mekanisme untuk subkelas berkongsi struktur data dan kaedah kelas induk secara automatik. Ini adalah hubungan antara kelas. Apabila mentakrifkan dan melaksanakan kelas, anda boleh melakukannya berdasarkan kelas sedia ada, mengambil kandungan yang ditakrifkan oleh kelas sedia ada sebagai kandungan anda sendiri dan menambah beberapa kandungan baharu.
Kelas Induk − Kelas diwarisi oleh kelas lain. Kelas ini boleh dipanggil kelas induk, kelas asas atau kelas super.
Subkelas − Kelas yang mewarisi kelas lain dipanggil subkelas, atau kelas terbitan.
Polimorfisme − Polimorfisme bermaksud operasi, fungsi atau proses yang sama boleh digunakan pada berbilang jenis objek dan memperoleh hasil yang berbeza. Objek yang berbeza boleh menghasilkan hasil yang berbeza apabila menerima mesej yang sama Fenomena ini dipanggil polimorfisme.
Lebih muatan − Ringkasnya, ia adalah situasi di mana fungsi atau kaedah mempunyai nama yang sama tetapi senarai parameter yang berbeza dengan nama yang sama dan parameter yang berbeza dipanggil fungsi atau kaedah terlampau.
Abstraksi − Abstraksi merujuk kepada mengabstraksi objek dengan struktur data (atribut) dan gelagat (operasi) yang konsisten ke dalam kelas. Kelas ialah abstraksi yang mencerminkan sifat penting yang berkaitan dengan aplikasi sambil mengabaikan kandungan lain yang tidak berkaitan. Pembahagian mana-mana kelas adalah subjektif, tetapi mesti berkaitan dengan aplikasi tertentu.
Encapsulation − Enkapsulasi merujuk kepada mengikat bersama sifat dan tingkah laku objek yang wujud dalam dunia nyata dan meletakkannya dalam unit logik.
Pembina − Digunakan terutamanya untuk memulakan objek semasa mencipta objek, iaitu, memberikan nilai awal kepada pembolehubah ahli objek Ia sentiasa digunakan bersama-sama dengan operator baharu dalam pernyataan untuk mencipta objek.
Pemusnah − Pemusnah (pemusnah) Bertentangan dengan pembina, apabila objek menamatkan kitaran hayatnya (contohnya, fungsi di mana objek terletak telah dipanggil), sistem secara automatik melaksanakan pemusnah. Pemusnah selalunya digunakan untuk melakukan kerja "pembersihan" (contohnya, semasa mencipta objek, gunakan baharu untuk membuka ruang ingatan, yang harus dikeluarkan dengan pemadaman dalam pemusnah sebelum keluar).
Dalam rajah di bawah, kami telah mencipta tiga objek melalui kelas Kereta: Mercedes, Bmw dan Audi.
$mercedes = Kereta baharu ();
$bmw = Kereta baharu ();
$audi = Kereta baharu (); >
Sintaks:
kelas_nama_kelas{
......}
Kelas mengandungi atribut dan kaedah.
Dengan menggunakan kata kunci var dalam definisi kelas untuk mengisytiharkan pembolehubah, anda mencipta atribut kelas, juga dipanggil atribut ahli kelas.
class_name{
var $var_name;}
Dengan mengisytiharkan fungsi dalam kelas definition , iaitu kaedah kelas dicipta.
Sintaks:
nama_kelas kelas{
nama_fungsi fungsi(arg1,arg2,...)
{
Kod fungsi
}
}
Kelas dengan atribut dan kaedah yang ditentukan ialah kelas yang lengkap, dan logik pemprosesan yang lengkap boleh dimasukkan ke dalam kelas. Gunakan kata kunci baharu untuk membuat instantiate objek untuk menggunakan logik dalam kelas. Pelbagai objek boleh dibuat secara serentak.
Sintaks:
objek = new class_name();
Selepas membuat seketika objek, gunakan operator -> objek Sifat dan kaedah.
Sintaks:
objek->var_name;
objek->function_name;
Jika anda ingin mengakses ahli dalam yang ditentukan class Untuk atribut atau kaedah, anda boleh menggunakan pembolehubah pseudo $this. $ini digunakan untuk mewakili objek semasa atau objek itu sendiri.
<?php
class Person {
//人的成员属性
var $name; //人的名字
var $age; //人的年龄
//人的成员 say() 方法
function say() {
echo "我的名字叫：".$this->name." <br >";
echo "我的年龄是：".$this->age;
}
} //类定义结束
//实例化一个对象
$p1 = new Person();
//给 $p1 对象属性赋值
$p1->name = "张三";
$p1->age = 20;
//调用对象中的 say()方法
$p1->say();
?>Jalankan contoh ini, keluaran:
Nama saya: Zhang San
Umur saya: 20
Contoh
<?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 = new Site;
$taobao = new Site;
$google = new Site;
// 调用成员函数，设置标题和URL
$php->setTitle( "php中文网" );
$taobao->setTitle( "淘宝" );
$google->setTitle( "Google 搜索" );
$php->setUrl( 'www.php.cn' );
$taobao->setUrl( 'www.taobao.com' );
$google->setUrl( 'www.google.com' );
// 调用成员函数，获取标题和URL
$php->getTitle();
$taobao->getTitle();
$google->getTitle();
$php->getUrl();
$taobao->getUrl();
$google->getUrl();
?>Jalankan instance»
Laksanakan kod di atas, hasil output ialah:
tapak web php Cina
Taobao
Carian Google
www.php.cn
www.taobao.com
www.google.com
Pembina PHP
Pembina ialah kaedah khas. Ia digunakan terutamanya untuk memulakan objek apabila mencipta objek, iaitu, untuk menetapkan nilai awal kepada pembolehubah ahli objek Ia sentiasa digunakan bersama-sama dengan operator baru dalam pernyataan untuk mencipta objek. Apabila menggunakan operator baharu untuk mencipta contoh kelas, pembina akan dipanggil secara automatik, dan namanya mestilah __construct()
Hanya satu pembina boleh diisytiharkan dalam kelas, dan hanya apabila objek itu dicipta setiap kali Kaedah pembina akan dipanggil sekali setiap kali Kaedah ini tidak boleh dipanggil secara aktif, jadi ia biasanya digunakan untuk melaksanakan beberapa tugas permulaan yang berguna. Kaedah ini tidak mempunyai nilai pulangan.
Sintaks:
fungsi __construct(arg1,arg2,...)
{
...
}
Dalam contoh di atas kita boleh memulakan pembolehubah $url dan $title melalui kaedah pembina:
<?php
fungsi __construct( $ par1, $par2 ) {
$ini->url = $par1;
$ini->tajuk = $par2;
}
?>
Kini kita tidak perlu lagi memanggil kaedah setTitle dan setUrl:
Instance
<?php
$php = new Site('www.php.cn', 'php中文网');
$taobao = new Site('www.taobao.com', '淘宝');
$google = new Site('www.google.com', 'Google 搜索');
// 调用成员函数，获取标题和URL
$php->getTitle();
$taobao->getTitle();
$google->getTitle();
$php->getUrl();
$taobao->getUrl();
$google->getUrl();
?>Jalankan instance»
Destructor
Sepadan dengan kaedah pembina ialah kaedah pemusnah Kaedah pemusnah membolehkan anda melakukan beberapa operasi atau menyelesaikan beberapa fungsi sebelum memusnahkan kelas, seperti menutup fail, mengeluarkan set hasil, dsb. Pemusnah tidak boleh mengambil sebarang parameter dan namanya mestilah __destruct() .
PHP 5 memperkenalkan konsep destructor, yang serupa dengan bahasa berorientasikan objek lain format sintaksnya adalah seperti berikut:
function __destruct()
{ <🎜. > ......
}
<?php
class MyDestructableClass {
function __construct() {
print "构造函数\n";
$this->name = "MyDestructableClass";
}
function __destruct() {
print "销毁 " . $this->name . "\n";
}
}
$obj = new MyDestructableClass();
?>Laksanakan kod di atas, hasil output ialah:Constructor
Destroy MyDestructableClass
Constructor dan destructor digunakan secara serentak
<?php
class Person {
var $name;
var $age;
//定义一个构造方法初始化赋值
function __construct($name,$age) {
$this->name=$name;
$this->age=$age;
}
function say() {
echo "我的名字叫：".$this->name." <br >";
echo "我的年龄是：".$this->age." <br >";;
}
function __destruct()
{
echo "再见".$this->name;
}
}
$p1=new Person("张三", 20);
$p1->say();
?>untuk melaksanakan kod di atas, hasil output ialah:
Nama saya: Zhang San
Umur saya: 20
Selamat tinggal Zhang San
Diwarisi
Pewarisan kelas PHP merujuk untuk mencipta kelas terbitan baharu yang mewarisi data dan kaedah daripada satu atau lebih kelas yang ditakrifkan sebelum ini, dan boleh mentakrifkan semula atau menambah data dan kaedah baharu, sekali gus mewujudkan hierarki atau hierarki kelas.
Kami memanggil kelas sedia ada yang digunakan untuk memperoleh kelas baharu sebagai kelas induk, dan kelas baharu yang diperoleh daripada kelas sedia ada dipanggil subkelas. Warisan adalah salah satu daripada tiga ciri utama berorientasikan objek.
Melalui mekanisme pewarisan, jenis data sedia ada boleh digunakan untuk menentukan jenis data baharu. Jenis data baharu yang ditakrifkan bukan sahaja mempunyai ahli yang baru ditakrifkan, tetapi juga mempunyai ahli lama.
Nota: Tidak seperti bahasa seperti Java, dalam PHP, kelas hanya boleh terus mewarisi data daripada satu kelas, iaitu warisan tunggal.
Gunakan kata kunci extends untuk mentakrifkan warisan kelas:
subclass kelas melanjutkan kelas induk {
}
Instance
Kelas Child_Site dalam instance mewarisi kelas Site dan memanjangkan fungsi:
<?php
// 子类扩展站点类别
class Child_Site extends Site {
var $category;
function setCate($par){
$this->category = $par;
}
function getCate(){
echo $this->category . PHP_EOL;
}
}
?>Kaedah penulisan semula
Jika kaedah yang diwarisi daripada kelas induk tidak dapat memenuhi keperluan subkelas Ia boleh ditulis semula mengikut keperluan Proses ini dipanggil kaedah override, juga dikenali sebagai kaedah penulisan semula.
Kaedah getUrl dan getTitle ditulis semula dalam contoh:
fungsi getUrl() {
gema $this->url - >url;
}
fungsi getTitle(){
gema $this->title >
Kawalan akses dan enkapsulasi
Ini dicapai dalam PHP dengan menambahkan pengubah suai akses awam, dilindungi atau peribadi di hadapan Kawalan akses untuk sifat atau kaedah. Pengubah suai akses jenis
membenarkan pembangun mengawal akses kepada ahli kelas, yang merupakan ciri bahasa OOP.
PHP menyokong tiga pengubah akses berikut:
awam (awam): ahli dalam kelas tidak akan mempunyai sekatan akses dan semua ahli luar boleh mengakses (membaca dan menulis) kelas ini Ahli ( termasuk harta ahli dan kaedah ahli). Jika ahli kelas tidak menyatakan pengubah akses ahli, ia akan dianggap sebagai awam.
dilindungi: Ahli yang ditakrifkan sebagai dilindungi tidak boleh diakses oleh kod di luar kelas, tetapi subkelas kelas mempunyai hak akses.
peribadi (peribadi): Ahli yang ditakrifkan sebagai peribadi membenarkan akses kepada semua ahli dalam kelas yang sama, tetapi akses kepada kod luaran dan subkelas kelas tidak dibenarkan.
Jadual perbandingan kebenaran akses pengubah suai:
luar 🎜>Petua: Apabila subkelas mengatasi kaedah kelas induk, hak akses kaedah dalam subkelas tidak boleh lebih rendah daripada hak akses kaedah ganti kelas induk.
Kawalan akses ke atas atribut
Atribut kelas mesti ditakrifkan sebagai salah satu daripada awam, dilindungi dan peribadi. Jika ditakrifkan dengan var, ia dianggap awam. <?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
?>Kawalan Akses untuk Kaedah
<?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
?>EncapsulationEncapsulation adalah untuk menggabungkan sifat dan perkhidmatan kelas (objek) ke dalam unit bebas, dan menyembunyikan butiran dalaman sebanyak mungkin, mengekalkan hanya antara muka yang diperlukan untuk berkomunikasi dengan bahagian luar. Ciri enkapsulasi ini dengan berkesan memastikan kebebasan objek, membolehkan penyetempatan ralat perisian, dan mengurangkan kesukaran menyemak ralat dan menyelesaikan masalah. Gunakan kata kunci peribadi untuk merangkum sifat dan kaedah: <?php
class Person {
//将成员属性定义为 private
private $name;
private $age;
//定义一个构造方法初始化赋值
function __construct($name, $age) {
$this->name=$name;
$this->age=$age;
}
function say() {
echo "我的名字叫：".$this->name." <br >";
echo "我的年龄是：".$this->age;
}
}
$p1=new Person("张三", 20);
$p1->say();
?>Antaramuka
Kelas PHP adalah warisan tunggal, iaitu, bukan Sokongan warisan berbilang. Apabila kelas memerlukan fungsi berbilang kelas, warisan tidak berkuasa Atas sebab ini, PHP memperkenalkan teknologi antara muka kelas.
Jika semua kaedah dalam kelas abstrak adalah kaedah abstrak dan tiada pembolehubah diisytiharkan, dan semua ahli dalam antara muka mempunyai kebenaran awam, maka kelas abstrak khas ini dipanggil antara muka.
Menggunakan antara muka, anda boleh menentukan kaedah yang mesti dilaksanakan oleh kelas, tetapi anda tidak perlu menentukan kandungan khusus kaedah ini.
Antara muka ditakrifkan melalui kata kunci antara muka, sama seperti mentakrifkan kelas standard, tetapi semua kaedah yang ditakrifkan di dalamnya adalah kosong.
Semua kaedah yang ditakrifkan dalam antara muka mestilah awam. Ini adalah ciri antara muka. Untuk melaksanakan antara muka, gunakan operator implements. Kelas mesti melaksanakan semua kaedah yang ditakrifkan dalam antara muka, jika tidak ralat maut akan dilaporkan.
<?php
//定义接口
interface User{
function getDiscount();
function getUserType();
}
//VIP用户 接口实现
class VipUser implements User{
// VIP 用户折扣系数
private $discount = 0.8;
function getDiscount() {
return $this->discount;
}
function getUserType() {
return "VIP用户";
}
}
class Goods{
var $price = 100;
var $vc;
//定义 User 接口类型参数，这时并不知道是什么用户
function run(User $vc){
$this->vc = $vc;
$discount = $this->vc->getDiscount();
$usertype = $this->vc->getUserType();
echo $usertype."商品价格：".$this->price*$discount;
}
}
$display = new Goods();
$display ->run(new VipUser);//可以是更多其他用户类型
?>Hasil:Harga produk pengguna VIP: 80 yuanPHP juga boleh melaksanakan berbilang antara muka pada masa yang sama apabila mewarisi kelas:
subkelas kelas melanjutkan antara muka implementmtns kelas induk 1, antara muka 2, ...
{
......
}
Perbezaan antara kelas abstrak dan antara muka
Antara muka ialah kelas abstrak khas dan juga boleh dianggap sebagai spesifikasi model. Perbezaan umum antara antara muka dan kelas abstrak adalah seperti berikut:
Jika subkelas melaksanakan antara muka, ia mesti melaksanakan semua kaedah dalam antara muka (sama ada diperlukan atau tidak jika ia mewarisi kelas abstrak, ia). hanya perlu melaksanakan kaedah yang diperlukan.
Jika nama kaedah yang ditakrifkan dalam antara muka berubah, maka semua subkelas yang melaksanakan antara muka ini perlu mengemas kini nama kaedah secara serentak dan jika nama kaedah dalam kelas abstrak berubah, nama kaedah yang sepadan bagi subkelasnya akan tidak terjejas. Kesannya cuma ia menjadi kaedah baharu (dilaksanakan berbanding kaedah lama).
Kelas abstrak hanya boleh diwarisi secara tunggal Apabila subkelas perlu melaksanakan fungsi yang perlu diwarisi daripada berbilang kelas induk, antara muka mesti digunakan.
Malar
Tentukan pemalar dalam kelas menggunakan kata kunci const dan bukannya fungsi define() biasa.
Anda boleh mentakrifkan nilai yang kekal tidak berubah dalam kelas sebagai pemalar. Tidak perlu menggunakan simbol $ apabila mentakrifkan dan menggunakan pemalar.
Nilai pemalar mestilah nilai tetap dan tidak boleh pembolehubah, atribut kelas, hasil operasi matematik atau panggilan fungsi.
Sejak PHP 5.3.0, anda boleh menggunakan pembolehubah untuk memanggil kelas secara dinamik. Tetapi nilai pembolehubah ini tidak boleh menjadi kata kunci (seperti diri, ibu bapa atau statik).
Syntax
const constant = "value";
Contoh:
<?php
Class Person{
// 定义常量
const country = "中国";
public function myCountry() {
//内部访问常量
echo "我是".self::country."人 <br >";
}
}
// 输出常量
echo Person::country." <br >";
// 访问方法
$p1 = new Person();
$p1 -> myCountry();
?>Jalankan output:
China
Saya Bahasa Cina
Kelas Abstrak
Mana-mana kelas, jika sekurang-kurangnya satu kaedah di dalamnya diisytiharkan sebagai abstrak, maka kelas ini mesti diisytiharkan sebagai abstrak.
Kelas yang ditakrifkan sebagai abstrak tidak boleh dibuat seketika.
Kaedah yang ditakrifkan sebagai abstrak hanya mengisytiharkan kaedah panggilannya (parameter) dan tidak boleh menentukan pelaksanaan fungsi khususnya.
Apabila mewarisi kelas abstrak, subkelas mesti mentakrifkan semua kaedah abstrak dalam kelas induk selain itu, kawalan akses kaedah ini mestilah sama (atau lebih santai) seperti dalam kelas induk. Sebagai contoh, jika kaedah abstrak diisytiharkan sebagai dilindungi, maka kaedah yang dilaksanakan dalam subkelas hendaklah diisytiharkan sebagai dilindungi atau awam, dan tidak boleh ditakrifkan sebagai peribadi. Di samping itu, kaedah panggilan kaedah mesti sepadan, iaitu jenis dan bilangan parameter yang diperlukan mestilah konsisten. Sebagai contoh, jika subkelas mentakrifkan parameter pilihan yang tidak disertakan dalam pengisytiharan kaedah abstrak kelas induk, tiada konflik antara kedua-dua pengisytiharan itu.
<?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;
?>melaksanakan kod di atas, dan hasil keluarannya ialah:
ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2
Sejak PHP 5.3.0, anda boleh menggunakan pembolehubah untuk memanggil kelas secara dinamik. Tetapi nilai pembolehubah ini tidak boleh menjadi kata kunci sendiri, induk atau statik.
<?php
Class Person{
// 定义静态成员属性
public static $country = "中国";
// 定义静态成员方法
public static function myCountry() {
// 内部访问静态成员属性
echo "我是".self::$country."人<br >";
}
}
class Student extends Person {
function study() {
echo "我是". parent::$country."人<br >";
}
}
// 输出成员属性值
echo Person::$country."<br >";// 输出：中国
$p1 = new Person();
//echo $p1->country;// 错误写法
// 访问静态成员方法
Person::myCountry();// 输出：我是中国人
// 静态方法也可通过对象访问：
$p1->myCountry();
// 子类中输出成员属性值
echo Student::$country."<br >";// 输出：中国
$t1 = new Student();
$t1->study();// 输出：我是中国人
?>Jalankan output:
China
Saya orang Cina
Saya orang Cina
China
Saya orang Cina
Kata kunci akhir
PHP 5 menambah kata kunci akhir baharu. Jika kaedah dalam kelas induk diisytiharkan muktamad, kelas anak tidak boleh mengatasi kaedah tersebut. Jika kelas diisytiharkan muktamad, ia tidak boleh diwarisi.
Orang kelas akhir
{
...... <?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()
?>
Panggil pembina kelas induk
<?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();
?>Laksanakan atur cara di atas, hasil output ialah: Kaedah pembinaan dalam kelas BaseClass Kaedah pembinaan dalam kelas BaseClass
Kaedah pembinaan dalam kelas SubClass
Kaedah pembinaan dalam Kelas BaseClass