PHP物件相關知識點的總結

物件傳遞：一種說法是“PHP物件是通過引用傳遞的”，更準確的說法是別名(識別符號)傳遞，即它們都儲存著同一個識別符號(ID)的拷貝，這個識別符號指向同一個物件的真正內容，與引用(&)有質的區別，請比較下例中行11和行18的輸出結果。

 1 <?php 2 class A { 3     public $foo = 1; 4 }  
 5  6 $a = new A; 7 $b = $a;     // $a ,$b都是同一個識別符號的拷貝 ($a) = ($b) = <id> 8 $b->foo = 2; 9 echo $a->foo."
";//210 $b = null;11 echo $a->foo."
";//212 13 $c = new A;14 $d = &$c;    // $c ,$d是引用 ($c,$d) = <id>15 $d->foo = 2;16 echo $c->foo."
";//217 $d = null;18 echo $c->foo."
";//Notice: Trying to get property of non-object19 20 $c = new A;21 $d = &$c;    // $c ,$d是引用 ($c,$d) = <id>22 $d->foo = 2;23 echo $c->foo."
";//224 unset($d);   //unset()刪除引用，$c = <id>25 echo $c->foo."
";//226 27 $e = new A;28 function foo($obj) {29     // ($obj) = ($e) = <id>30     $obj->foo = 2;31 }32 foo($e);33 echo $e->foo."
";//2

物件複製：物件複製可以通過 clone 關鍵字來完成，如果原物件定義了 __clone() 方法，則新物件中的 __clone() 方法將在複製完後被呼叫，__clone() 方法可用於修改複製物件屬性的值。當物件被複制後，會對物件的所有屬性執行一個淺複製(shallow copy)，但所有的引用屬性仍然會是一個指向原來的變數的引用。

 <?         = 0                       ->instance = ++self::                  ->instance = ++self::                                          ->object1 =  ->                      `cloneTest`     =   ->object1 =  ->object2 =    =    ("Original Object:
" (  ("Cloned Object:
" (  ->cloneTest()

上例輸出結果：

Original Object:
MyCloneable Object
(
    [object1] => SubObject Object
        (            [instance] => 1
        )

    [object2] => SubObject Object
        (            [instance] => 2
        )

)
Cloned Object:
MyCloneable Object
(
    [object1] => SubObject Object
        (            [instance] => 3
        )

    [object2] => SubObject Object
        (            [instance] => 2
        )

)cloneTest

物件遍歷： foreach只能遍歷物件的可見屬性，無法遍歷其方法，實現起來比較容易；另外，也可通過實現Iterator介面或IteratorAggregate介面的方法遍歷物件屬性。

型別約束： PHP作為一種弱型別語言，型別約束可以讓程式設計更加規範，也少出些差錯；型別約束不只能用在物件定義中，也能用在函式定義中。型別約束可指定物件、介面、array、callable(閉包callback)，型別約束用來保證實際資料型別與原型定義一致，不一致則丟擲一個可捕獲的致命錯誤；不過如果定義了預設值為NULL，那麼實參可以是NULL；型別約束不能用於標量型別如 int 或 string，Traits 也不允許。

物件序列化與還原：函式serialize()可將物件打成包含位元組流的字串，但不含靜態屬性(如果屬性需要序列化後進行儲存，最好將該屬性例項化)和方法；函式unserialize()能夠還原字串為物件。無論序列化還是反序列化，物件的類定義已經完成，即需要先匯入類(檔案)。大致過程是先建立一個同類例項，然後再合併之前儲存的物件屬性來實現最後還原物件。

  = 0  ->instanceProp = self:: + 5 :: += 10  "instanceProp:".->instanceProp."
" "staticProp:".self::."
" `SerializationTest.php` = ->->doPrint()."
" = ((`object.store`,  `SerializationTest.php` = (`object.store` = (->doPrint();

上例執行結果：如果上述三個檔案中的程式碼放在同一個檔案中去執行，由於類的靜態屬性是其所有例項所共享而導致序列化後恢復物件的staticProp值也為10

/object.store.php:
instanceProp:5
staticProp:10

/object.restore.php:
instanceProp:5
staticProp:0

過載：PHP的過載包括屬性和方法，更像一個套用說法，不支援常見的過載語法規範，具有不可預見性，影響範圍更寬泛，就是利用魔術方法(magic methods)來呼叫當前環境下未定義或不可見的類屬性或方法。所有過載方法都必須被宣告為 public(這一條應該比較好理解，別人可能因不可見才需要你，那你自己必須可見才行)，引數也不能通過引用傳遞(過載方法具有不可預見性，估計出於安全方面的考慮吧，防止變數被隨意引用)。在除 isset() 外的其它語言結構中無法使用過載的屬性，這意味著當對一個過載的屬性使用 empty() 時，過載魔術方法將不會被呼叫； 為避開此限制，必須將過載屬性賦值到本地變數再使用 empty()，可見過載屬性是介於合法屬性與非法屬性之間的存在。

[屬性過載]：這些方法不能被宣告為 static，在靜態方法中，這些魔術方法將不會被呼叫public void __set ( string $name , mixed $value )
在給不可訪問屬性賦值時，__set() 會被呼叫

public mixed __get ( string $name )
讀取不可訪問屬性的值時，__get() 會被呼叫

public bool __isset ( string $name )
當對不可訪問屬性呼叫 isset() 或 empty() 時，__isset() 會被呼叫

public void __unset ( string $name )
當對不可訪問屬性呼叫 unset() 時，__unset() 會被呼叫Note:
因為 PHP 處理賦值運算的方式，__set() 的返回值將被忽略。類似的, 在下面這樣的鏈式賦值中，__get() 不會被呼叫：
 $a = $obj->b = 8; [方法過載]：
public mixed __call ( string $name , array $arguments )
在物件中呼叫一個不可訪問方法時，__call() 會被呼叫

public static mixed __callStatic ( string $name , array $arguments )
在靜態上下文中呼叫一個不可訪問方法時，__callStatic() 會被呼叫

靜態屬性和方法：static 關鍵字用來定義靜態屬性、靜態方法，靜態屬性不能通過例項化的物件來呼叫(但靜態方法可以)。靜態屬性只能被初始化為常量表示式，所以可以把靜態屬性初始化為整數或陣列，但不能初始化為另一個變數或函式返回值，也不能指向一個物件。可以用一個變數表示類來動態呼叫靜態屬性，但該變數的值不能為關鍵字 self，parent 或 static。

 1 class Foo 2 { 3     public static $my_static = `foo`; 4  5     public function staticValue() { 6         return self::$my_static; 7     } 8 } 9 10 class Bar extends Foo11 {12     public function fooStatic() {13         return parent::$my_static;14     }15 }16 17 18 print Foo::$my_static . "
";19 20 $foo = new Foo();21 print $foo->staticValue() . "
";22 print $foo->my_static . "
";      // Undefined "Property" my_static 23 24 print $foo::$my_static . "
";25 $classname = `Foo`;26 print $classname::$my_static . "
"; // As of PHP 5.3.027 28 print Bar::$my_static . "
";29 $bar = new Bar();30 print $bar->fooStatic() . "
";

後期靜態繫結：static:: 定義後期靜態繫結工作原理是儲存了上一個“非轉發呼叫”（non-forwarding call）的類名。當進行靜態方法呼叫時，該類名即為明確指定的那個（通常在 :: 運算子左側部分）；當進行非靜態方法呼叫時，即為該物件所屬的類。使用 self:: 或者 __CLASS__ 對當前類的靜態引用，取決於定義當前方法所在的類；static:: 不再被解析為定義當前方法所在的類，而是在實際執行時計算的，可以用於靜態屬性和所有方法的呼叫。

 1 <?php 2 class A 3 { 4      5     private $proPrivate = "private of A"; 6     protected $proProtected = "protected of A"; 7     public $proPublic = "public of A"; 8      9     private function foo()10     {11         echo $this->proPrivate."
";12         echo $this->proProtected."
";13         echo $this->proPublic."
";14     }15     16     public function test()17     {18         $this->foo();19         static::foo();20     }21 }22 23 class B extends A24 {25    /* foo() will be copied to B, hence its scope will still be A and26     * the call be successful */27 }28 29 class C extends A30 {31     private $proPrivate = "private of C";32     protected $proProtected = "protected of C";33     public $proPublic = "public of C";34     35     private function foo()36     {37         /* original method is replaced; the scope of the new one is C */38         echo "I am C
";39     }40     41     public function myFoo()42     {43         //parent::foo();44         $this->foo();45     }46 }47 48 echo "Class B:
";49 $b = new B();50 $b->test();51 echo "
Class C:
";52 $c = new C();53 $c->myFoo();54 $c->test();   //fails

上例輸出結果：

Class B:
private of A
protected of A
public of A
private of A
protected of A
public of A

Class C:
I am C
private of A
protected of C
public of C 
Fatal error: Uncaught Error: Call to private method C::foo() from context `A` in /public/t.php:19 Stack trace: #0 /public/t.php(54): A->test() #1 {main} thrown in /public/t.php on line 19

繼承：官方文件對繼承有這樣一段描述“當擴充套件一個類，子類就會繼承父類所有公有的和受保護的方法。除非子類覆蓋了父類的方法，被繼承的方法都會保留其原有功能”，言下之意似乎私有屬性和方法不會被繼承；然而上例又告訴我們子類擁有與父類一致的屬性和方法，繼承就是全盤複製，這才能滿足我們對繼承程式設計的需求，如果私有的不能繼承，子類就必須自行重新定義，在大多數時候沒有必要。另外就是可見性問題，父類的私有屬性和方法在子類是不可見的。上例還告訴我們物件實際執行的域要考慮可見性、繼承、後期靜態繫結機制。