nota kajian php berorientasikan objek

awam Awam: kelas ini, subkelas dan objek luaran semuanya boleh memanggil
dilindungi Dilindungi: subkelas kelas ini boleh dilaksanakan, objek luaran tidak boleh memanggil
peribadi: hanya kelas ini Pelaksanaan, subkelas dan objek luaran tidak boleh dipanggil
Tiga ciri utama pengaturcaraan berorientasikan objek

1) Penutupan

Penutupan, yang juga boleh dipanggil penyembunyian maklumat. Ia adalah untuk memisahkan penggunaan dan pelaksanaan kelas, hanya meninggalkan antara muka (kaedah) terhad untuk berhubung dengan luar. Bagi pembangun yang menggunakan kelas ini, mereka hanya perlu tahu cara menggunakan kelas ini, dan tidak perlu mengambil berat tentang cara kelas ini dilaksanakan. Melakukannya membolehkan pembangun memberi tumpuan yang lebih baik pada perkara lain, di samping mengelakkan kesulitan yang disebabkan oleh saling bergantung antara program.

2) Warisan

Warisan bermaksud kelas terbitan (subkelas) secara automatik mewarisi atribut dan kaedah dalam satu atau lebih kelas asas (kelas induk), dan boleh menggantikan atau menambah sifat baharu dan kaedah. Warisan memudahkan penciptaan objek dan kelas dan meningkatkan kebolehulangan kod. Warisan dibahagikan kepada warisan tunggal dan warisan berbilang PHP menyokong warisan tunggal, iaitu, subkelas mempunyai dan hanya mempunyai satu kelas induk.

3) Polimorfisme

Polymorphism bermaksud objek yang berbeza daripada kelas yang sama boleh memperoleh hasil yang berbeza menggunakan kaedah yang sama. Polimorfisme meningkatkan fleksibiliti perisian dan kebolehgunaan semula.

Definisi kelas

Sesuatu kelas boleh mengandungi pemalar, pembolehubah (dipanggil "sifat") dan fungsinya sendiri (dipanggil "kaedah").
Seperti kebanyakan bahasa berorientasikan objek, PHP juga mentakrifkan kelas melalui kata kunci kelas serta nama kelas. Format kelas adalah seperti berikut:

Kodnya adalah seperti berikut:

<?php
  Class myobject{
    //……
    }
?>

Definisi: Burung bulu berkumpul bersama, dan objek yang mempunyai ciri yang serupa dikumpulkan ke dalam kelas. Kelas mentakrifkan atribut dan atribut yang sama yang dimiliki oleh kaedah serupa ini. Kelas ialah perihalan objek yang serupa, dipanggil definisi kelas, yang merupakan pelan tindakan atau prototaip objek kelas itu.

Objek kelas dipanggil instance kelas. Untuk membuat contoh kelas, kata kunci baharu mesti digunakan.

<?php
//类的定义以关键字class开始，类的命名通常以每个单词第一个字母大写
    class NbaPlayer{
        public $name = "Jordan"; //定义属性
        public $height = "198cm";
        public $team = "Bull";
        public $playerNumber = "23";
        //定义方法
    public function run(){
        echo "Running\n";
    }
    public function dribblr(){
        echo "Dribbling\n";
    }
    public function pass(){
        echo "Passing\n";
    }
}
    //类到对象的实例化
    //类的实例化为对象时使用关键字new，new之后紧跟类的名称和一对括号
    $jordan = new NbaPlayer(); 
    //对象中的属性成员可以通过"->"符号来访问
    echo $jordan->name."\n";
    //对象中的成员方法可以通过"->"符号来访问
    $jordan->dribble();
    $jordan->run();
?>

Kaedah ahli

Fungsi dalam kelas dipanggil kaedah ahli. Satu-satunya perbezaan antara fungsi dan kaedah ahli ialah fungsi melaksanakan fungsi bebas, manakala kaedah ahli melaksanakan tingkah laku dalam kelas dan merupakan sebahagian daripada kelas.
Mari kembangkan kelas myobject di atas dan tambahkan kaedah ahli padanya Kodnya adalah seperti berikut:

<?php
classmyobject{
   function getobjectname($name){
      echo "商品名称为：".$name;
   }
}
?>

Fungsi kaedah ini adalah untuk mengeluarkan nama produk, yang dihantar melaluinya. parameter kaedah.
Kelas ialah penerangan abstrak, koleksi objek dengan fungsi yang serupa. Jika anda ingin menggunakan kaedah dan pembolehubah dalam kelas, anda mesti melaksanakannya terlebih dahulu ke dalam entiti, iaitu objek.

Pemalar kelas
Oleh kerana terdapat pembolehubah, sudah tentu terdapat juga pemalar. Pemalar ialah kuantiti yang tidak berubah dan merupakan nilai tetap. Pemalar yang terkenal ialah pi. Untuk mentakrifkan pemalar, gunakan kata kunci const, seperti:
ConstPI=3.14159;

Pembina

PHP 5 membenarkan pembangun mentakrifkan kaedah sebagai pembina dalam kelas. Kelas dengan pembina akan memanggil kaedah ini setiap kali objek baharu dicipta, jadi ia sangat sesuai untuk melakukan beberapa kerja permulaan sebelum menggunakan objek.

Pemusnah

<?php
//类的定义以关键字class开始，类的命名通常以每个单词第一个字母大写
    class NbaPlayer{
        public $name = "Jordan"; //定义属性
        public $height = "198cm";
        public $team = "Bull";
        public $playerNumber = "23";
        //构造函数，在对象被实例化的时候自动调用
        function __construct($name,$height,$weight,$team){
            echo "It is an  NbaPlayer constructor\n";
            $this->name = $name;
            //$this是PHP里面的伪变量，表示对象自身。可以通过$this->的方式访问对象的属性和方法
            $this->height = $height;
            $this->weight = $weight;
            $this->team = $team;
        }
        //定义方法
    public function run(){
        echo "Running\n";
    }
    public function dribblr(){
        echo "Dribbling\n";
    }
    public function pass(){
        echo "Passing\n";
    }
}
    //类到对象的实例化
    //类的实例化为对象时使用关键字new，new之后紧跟类的名称和一对括号
    $jordan = new NbaPlayer("Jordan","198cm","98kg","Bull");   
    //对象中的属性成员可以通过"->"符号来访问
    echo $jordan->name."\n";
    //对象中的成员方法可以通过"->"符号来访问
    $jordan->dribble();
    $jordan->run();
    //每一次用new实例化对象的时候，都会用类名后面的参数列表调用构造函数
    $james = new NbaPlayer("James","203cm","120kg","Heat")
    echo $james->name."\n";
?>

Pemusnah berlaku apabila semua rujukan kepada objek telah dipadamkan atau apabila objek dimusnahkan secara eksplisit dilaksanakan.

Rujukan objek

<?php
//类的定义以关键字class开始，类的命名通常以每个单词第一个字母大写
    class NbaPlayer{
        public $name = "Jordan"; //定义属性
        public $height = "198cm";
        public $team = "Bull";
        public $playerNumber = "23";

        //构造函数，在对象被实例化的时候自动调用
        function __construct($name,$height,$weight,$team){
            echo "It is an  NbaPlayer constructor\n";
            $this->name = $name;
            //$this是PHP里面的伪变量，表示对象自身。可以通过$this->的方式访问对象的属性和方法
            $this->height = $height;
            $this->weight = $weight;
            $this->team = $team;
        }
        //析构函数，在程序执行结束的时候会自动调用
        //析构函数通常被用于清理程序使用的资源。比如程序使用了打印机，那么可以再析构函数里面释放打印机资源
        function __destruct(){
            echo "Destroying".$this->name."\n";
        }
        //定义方法
    public function run(){
        echo "Running\n";
    }
    public function dribblr(){
        echo "Dribbling\n";
    }
    public function pass(){
        echo "Passing\n";
    }
}
    //类到对象的实例化
    //类的实例化为对象时使用关键字new，new之后紧跟类的名称和一对括号
    $jordan = new NbaPlayer("Jordan","198cm","98kg","Bull");   
    //对象中的属性成员可以通过"->"符号来访问
    echo $jordan->name."\n";
    //对象中的成员方法可以通过"->"符号来访问
    $jordan->dribble();
    $jordan->run();
    //每一次用new实例化对象的时候，都会用类名后面的参数列表调用构造函数
    $james = new NbaPlayer("James","203cm","120kg","Heat")
    echo $james->name."\n";
    //对象的引用用于访问对象的属性和方法，$james,$james1和$james2都是对象的引用
    //$james和$james1是对象的两个独立引用
    //$james2是$james的影子，使用对象的同一个引用，任何一个赋值为null相当于删除了同一个引用
    $james1 = $james;
    $james2 = &$james
    $james = null;
    echo "from now on James will not be used.\n"
?>