PHP berorientasikan objek

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 abstraksi dunia nyata.

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, warna, saiz dan rupa apabila kaedah tersebut digunakan.

· Perwakilan objek: Perwakilan objek adalah bersamaan dengan kad ID, khususnya membezakan perbezaan dalam kelakuan dan status yang sama.

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 dan kaedah data 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 ia juga boleh dipanggil kelas terbitan.

·     Polymorphism − Polimorfisme bermaksud bahawa operasi, fungsi atau proses yang sama boleh digunakan pada pelbagai jenis objek dan memperoleh hasil yang berbeza. Objek yang berbeza boleh menghasilkan hasil yang berbeza apabila menerima mesej yang sama Fenomena ini dipanggil polimorfisme.

· Overloading - Ringkasnya, ia adalah situasi di mana fungsi atau kaedah mempunyai nama yang sama tetapi senarai parameter yang berbeza Fungsi atau kaedah sedemikian dengan nama yang sama dan parameter yang berbeza dipanggil fungsi atau kaedah terlebih beban.

·                                                                                                                                                                                                                  . 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.

· Enkapsulasi − Enkapsulasi merujuk kepada mengikat bersama sifat dan tingkah laku objek yang wujud dalam dunia nyata dan meletakkannya dalam unit logik.

· Pembina − Ia digunakan terutamanya untuk memulakan objek semasa menciptanya, 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 = new Car ();
$bmw = new Car ();
$audi = new Car ();

Takrif kelas PHP

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

<?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;
  }
}
?>

Buat objek dalam PHP

Panggil kaedah ahli

Selepas membuat instantiat objek, kita boleh menggunakan objek untuk memanggil kaedah ahli Kaedah ahli objek hanya boleh beroperasi pada objek. Pembolehubah ahli:

// Panggil fungsi ahli, tetapkan tajuk dan URL

$runoob->setTitle( "Rangkaian PHP Cina" );

$ taobao-> setTitle( "Taobao" );

$google->setTitle( "Google Search" );

$runoob->setUrl( ' www.ask. php.cn' );

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

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

// Panggil fungsi ahli untuk mendapatkan tajuk dan URL

$runoob->getTitle();

$ taobao->getTitle( );

$google->getTitle();

$runoob->getUrl();

$taobao->getUrl ();

$google->getUrl();

Kod lengkap adalah seperti berikut:

Instance

<?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; 
   } 
 } 
 
 $runoob = new Site; 
 $taobao = new Site; 
 $google = new Site; 
 
 // 调用成员函数，设置标题和URL 
 $runoob->setTitle( " PHP中文网" ); 
 $taobao->setTitle( "淘宝" ); 
 $google->setTitle( "Google 搜索" ); 
 
 $runoob->setUrl( 'www. ask.php.cn ' ); 
 $taobao->setUrl( 'www.taobao.com' ); 
 $google->setUrl( 'www.google.com' ); 
 
 // 调用成员函数，获取标题和URL 
 $runoob->getTitle(); 
 $taobao->getTitle(); 
 $google->getTitle(); 
 
 $runoob->getUrl(); 
 $taobao->getUrl(); 
 $google->getUrl(); 
 ?>

Laksanakan kod di atas, hasil output ialah:

Tapak web PHP Cina

Taobao

Carian Google

www.ask.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.

PHP 5 membenarkan pembangun mentakrifkan kaedah sebagai pembina dalam kelas Format sintaks adalah seperti berikut:

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

Dalam contoh di atas, kita boleh memulakan pembolehubah $url dan $title melalui kaedah pembina:

fungsi __construct( $par1, $par2 ) {

$this - >url = $par1;

$this->title = $par2;

}

Kini kita tidak perlu lagi memanggil kaedah setTitle dan setUrl:

Instance

$runoob = new Site('www.runoob.com', 'PHP中文网'); 
 $taobao = new Site('www.taobao.com', '淘宝'); 
 $google = new Site('www.google.com', 'Google 搜索'); 
 
 // 调用成员函数，获取标题和URL 
 $runoob->getTitle(); 
 $taobao->getTitle(); 
 $google->getTitle(); 
 
 $runoob->getUrl(); 
 $taobao->getUrl(); 
 $google->getUrl();

Pemusnah

Pemusnah (pemusnah) Bertentangan dengan pembina, apabila objek menamatkan kitaran hayatnya (contohnya, fungsi di mana objek terletak telah dipanggil), sistem secara automatik melaksanakan pemusnah.

PHP 5 memperkenalkan konsep pemusnah, yang serupa dengan bahasa berorientasikan objek lain format sintaksnya adalah seperti berikut:

void __destruct ( void )

Instance<. 🎜 >

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

Warisan

set fungsiCate($par){

$this->category = $par;

}

fungsi getC ate() {

<?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
?>

<?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
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 起
?>

<?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;
?>

<?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;
?>

<?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
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();
?>