摘要：方法如無的調用，則默認為為靜態方法。聲明靜態方法會有錯誤提示，但很方便，能用盡量用效率高。

一、面向對象的關鍵字

1.instanceof操作符：

對象是否屬于類（檢測繼承性），如下：

    class Person {};
    class Student extends Person {};
    $p=new Person;
    $s=new Student;
    echo $p instanceof Student;//false
    echo $s instanceof Student;//true
    echo $s instanceof Person;//true

2.final關鍵字：

不定義常量，不能使用final修飾成員屬性

    a.final可以修飾類，該類不能擴展（不能有子類），即最終類，如下：

    final class Person {......};

    b.final可以修飾方法，這個方法不能在子類中被覆蓋（不能被擴展），即最終方法，如下：

    public final function say(){......};
    //子類不能用parent::say();調用

3.static關鍵字：

    a.將一個類中多個實例對象的共用屬性/方法存入初始化靜態段中，節省內存空間
    b.類第一次出現，加載時，已將static成員加載到了內存，即不創建實例對象，也可以訪問該成員//echo Person::country
    c.靜態成員一定要使用類來訪問//echo Person::country
    d.靜態成員可以訪問也可以賦值，賦值后所有實例都變化，self關鍵字可以在本類中代表本類名，類似this
    e.靜態成員一旦被加載，只有腳本結束才釋放    
    f.該關鍵字可以修飾屬性和方法，不能修飾類。方法如無$this的調用，則默認為為靜態方法。聲明靜態方法會有錯誤提示，但很方便，能用盡量用（效率高）。
    g.上述第f條的缺點如下：
        （1）占內存，腳本結束才釋放
        （2）靜態方法只能使用靜態屬性，因為不能使用$this

4.const關鍵字

a.常量存儲區域為初始化靜態段
b.define只能在類外部聲明常量，內部報錯
c.const只能修飾成員屬性，即定義常量，注意：
    （1）常量使用大寫，不能使用$
    （2）聲明時必有初值
    （3）訪問方式與static相同（self::name），但只能讀
          

二、魔術方法

1.自動調用，只有PHP語言存在
2.以“__”開始
3.方法名固定        
4.如果不寫就不存在，也沒有默認功能   

1.__toString()：將對象轉為自定義的字符串（類似js），該方法不能有參數，必須返回一個字符串（echo/print后常用），如下：

    class Person {
        function __toString(){
            return "$$$$
";
        }
    };
    $p=new Person;
    echo $p;//$$$$

2.__clone()：

a.克隆對象

    class Person {
        function __toString(){
            return "$$$$
";
        }
    };
    $p=new Person;
    $p2=clone $p;

b.魔術方法：

（1）在克隆對象時自動調用
（2）作用：與構造方法一樣，對新克隆的對象初始化
（3）該方法中$this代表副本，可進行初始化（$that有時可代表原本，有的版本能用）

    class Person {
        var $name;
        function __construct($name){
            $this->name=$name;
        }
        function say(){
            echo $this->name."
";
        }
        function __clone(){
            $this->name="ni";
        }
    };
    $p=new Person("wo");
    $p->say();//wo
    $p2=clone $p;
    $p2->say();//ni

3.__call()：

a.調用對象中不存在的方法時，自動調用
b.有兩個參數，第一個參數不存在的方法名，第二個是不存在方法的參數數組
c.作用：將功能相似方法進行批量處理或對不存在方法完成提示功能

    class Person {
        var $name;
        function __construct($name){
            $this->name=$name;
        }
        function say(){
            echo $this->name."
";
        }
        function __clone(){
            $this->name="ni";
        }
        function __call($method,$args){
            echo "方法{$method}()，參數為";
            print_r($args);
            echo"不存在！
";
        }
    };
    $p=new Person("wo");
    $p->eat("肉","米");
    //方法eat()，參數為Array ( [0] => 肉 [1] => 米 ) 不存在！

d.可以用來實現重載（與JS函數的arguments方法類似）

class Foo1{
        public function __call($name,$arguments){
                if($name=="doStuff"){
                        /**
                         *實際上，不僅僅可以第一個參數類型，還可以判斷參數個數，以及參數順序，那么就和C++等強數據類型語言的重載效果是一樣的了！
                        */
                        if(is_int($arguments[0])){
                                $this->doStuffForInt($arguments[0]);
                        }else if(is_string($arguments[0])){
                                $this->doStuffForString($arguments[0]);
                        }
                }
        }

        private function doStuffForInt($a){
                echo "執行的是doStuffForInt()方法";
        }

        private function doStuffForString($a){
                echo "執行的是doStuffForString()方法";
        }
}

$foo1=new Foo1;

$foo1->doStuff("1");//執行的是doStuffForString()方法

三、單態/單件/單例設計模式

概念：一個類只能創建一個對象，最適合PHP使用的設計模式

方法：

a.先將構造函數私有化，讓類不能創建對象，如下：

    class Person {
        private function __construct(){
            
        }
        function __destruct(){
            echo "######
";
        }
        function say(){
            echo "$$$$
";
        }
    };
    $p=new Person;//報錯

b.定義（static）靜態方法，在類中創建類的對象，外部使用類調用來創建對象，但這樣仍然是每次調用創建一個新對象，而不是只能創建一個對象，具體如下：

    class Person {
        private function __construct(){
            
        }
        static function createObj(){
            $obj=new self;
            return $obj;
        }
        function __destruct(){
            echo "######
";
        }
        function say(){
            echo "$$$$
";
        }
    };
    $p=Person::createObj();//######
    $p=Person::createObj();//######
    $p=Person::createObj();//######
    $p=Person::createObj();//######
    $p->say();//$$$$

c.將新建對象的變量$obj設定為靜態屬性（唯一的），即可達到要求，該類只能創建一個對象，如下：

    class Person {
        static $obj=null;
        private function __construct(){
            
        }
        static function createObj(){
            if(is_null(self::$obj)){
                self::$obj=new self;
            }
            return self::$obj;
        }
        function __destruct(){
            echo "######
";
        }
        function say(){
            echo "$$$$
";
        }
    };
    $p=Person::createObj();
    $p=Person::createObj();
    $p=Person::createObj();
    $p=Person::createObj();
    //由于只創建了一個類，只輸出一次######
    $p->say();//$$$$