對象傳遞：一種說法是“PHP對象是通過引用傳遞的”，更準確的說法是別名(標識符)傳遞，即它們都保存著同一個標識符(ID)的拷貝，這個標識符指向同一個對象的真正內容。

1. classA { 
2.  
3.   public$foo= 1; 
4.  
5. } 
6.  
7. $a=newA; 
8.  
9. $b=$a;  // $a ,$b都是同一個標識符的拷貝 
10.  
11.       // ($a) = ($b) = 
12.  
13. $b->foo = 2; 
14.  
15. echo$a->foo."/n";//2 
16.  
17. $c=newA; 
18.  
19. $d= &$c; // $c ,$d是引用 
20.  
21.       // ($c,$d) = 
22.  
23. $d->foo = 2; 
24.  
25. echo$c->foo."/n";//2 
26.  
27. $e=newA; 
28.  
29. functionfoo($obj) { 
30.  
31.   // ($obj) = ($e) = 
32.  
33.   $obj->foo = 2; 
34.  
35. } 
36.  
37. foo($e); 
38. //Vevb.com 
39. echo$e->foo."/n";//2 

•對象復制：對象復制可以通過  clone 關鍵字來完成，如果原對象定義了 __clone() 方法，則新對象中的 __clone()  方法將在復制完后被調用，__clone() 方法可用于修改復制對象屬性的值。當對象被復制后，會對對象的所有屬性執行一個淺復制(shallow  copy)，但所有的引用屬性仍然會是一個指向原來的變量的引用。

1. classSubObject  
2.  
3. { 
4.  
5.   static$instances= 0; 
6.  
7.   public$instance; 
8.  
9.    
10.  
11.   publicfunction__construct() 
12.  
13.   { 
14.  
15.     $this->instance = ++self::$instances; 
16.  
17.   } 
18.  
19.    
20.  
21.   publicfunction__clone() 
22.  
23.   { 
24.  
25.     $this->instance = ++self::$instances; 
26.  
27.   } 
28.  
29. } 
30.  
31.    
32.  
33. classMyCloneable 
34.  
35. { 
36.  
37.   public$object1; 
38.  
39.   public$object2; 
40.  
41.    
42.  
43.   function__clone() 
44.  
45.   { 
46.  
47.     // 強制復制一份this->object， 否則仍然指向同一個對象 
48.  
49.     $this->object1 =clone$this->object1; 
50.  
51.   } 
52.  
53.      
54.  
55.   functioncloneTest() 
56.  
57.   { 
58.  
59.     echo'cloneTest' 
60.  
61.   } 
62.  
63. } 
64.  
65. $obj=newMyCloneable();  
66.  
67. $obj->object1 =newSubObject(); 
68.  
69. $obj->object2 =newSubObject(); 
70.  
71. $obj2=clone$obj; 
72.  
73. print("Original Object:/n"); 
74.  
75. print_r($obj); 
76.  
77. print("Cloned Object:/n"); 
78.  
79. print_r($obj2); 
80.  
81. echo$obj2->cloneTest().":/n"; 
82.  
83. echo(newReflectionclass($obj2)); 
84.  
85. 上例輸出結果： 
86.  
87. Original Object: 
88.  
89. MyCloneable Object 
90.  
91. ( 
92.  
93.   [object1] => SubObject Object 
94.  
95.     ( 
96.  
97.       [instance] => 1 
98.  
99.     ) 
100.  
101.    
102.  
103.   [object2] => SubObject Object 
104.  
105.     ( 
106.  
107.       [instance] => 2 
108.  
109.     ) 
110.  
111.    
112.  
113. ) 
114.  
115. Cloned Object: 
116.  
117. MyCloneable Object 
118.  
119. ( 
120.  
121.   [object1] => SubObject Object 
122.  
123.     ( 
124.  
125.       [instance] => 3 
126.  
127.     ) 
128.  
129.    
130.  
131.   [object2] => SubObject Object 
132.  
133.     ( 
134.  
135.       [instance] => 2 
136.  
137.     ) 
138.  
139.    
140.  
141. ) 
142.  
143. cloneTest: 
144.  
145. Class [classMyCloneable ] { 
146.  
147.  @@ /public/t.php 18-33 
148.  
149.    
150.  
151.  - Constants [0] { 
152.  
153.  } 
154.  
155.    
156.  
157.  - Static properties [0] { 
158.  
159.  } 
160.  
161.    
162.  
163.  - Static methods [0] { 
164.  
165.  } 
166.  
167.    
168.  
169.  - Properties [2] { 
170.  
171.   Property [public$object1] 
172.  
173.   Property [public$object2] 
174.  
175.  } 
176.  
177.    
178.  
179.  - Methods [2] { 
180.  
181.   Method [publicmethod __clone ] { 
182.  
183.    @@ /public/t.php 23 - 27 
184.    //Vevb.com 
185.   } 
186.  
187.   Method [publicmethod cloneTest ] { 
188.  
189.    @@ /public/t.php 29 - 32 
190.  
191.   } 
192.  
193.  } 
194.  
195. } 

•對象遍歷： foreach只能遍歷對象的可見屬性，無法遍歷其方法，實現起來比較容易；另外，也可通過實現Iterator接口或IteratorAggregate接口的方法遍歷對象屬性。

•類型約束：   PHP作為一種弱類型語言，類型約束可以讓編程更加規范，也少出些差錯；類型約束不只能用在對象定義中，也能用在函數定義中。類型約束可指定對象、接口、array、callable(閉包callback)，類型約束用來保證實際數據類型與原型定義一致，不一致則拋出一個可捕獲的致命錯誤；不過如果定義了默認值為NULL，那么實參可以是NULL；類型約束不能用于標量類型如  int 或 string，Traits 也不允許。

•對象序列化與還原：函數serialize()可將打成包含字節流的字符串便于存儲對象，函數unserialize()能夠還原字符串為對象。但有一個前提是，無論序列化還是反序列化，對象的類定義已經完成，即需要先導入類(文件)。

•重載：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. classFoo 
2.  
3. { 
4.  
5.   publicstatic$my_static='foo' 
6.  
7.   publicfunctionstaticValue() { 
8.  
9.     returnself::$my_static; 
10.  
11.   } 
12.  
13. } 
14.  
15. classBarextendsFoo 
16.  
17. { 
18.  
19.   publicfunctionfooStatic() { 
20.  
21.     returnparent::$my_static; 
22.  
23.   } 
24.  
25. } 
26.   
27. printFoo::$my_static."/n"; 
28.  
29. $foo=newFoo(); 
30.  
31. print$foo->staticValue() ."/n"; 
32.  
33. print$foo->my_static ."/n";  // Undefined "Property" my_static  
34.  
35. print$foo::$my_static."/n"; 
36.  
37. $classname='Foo' 
38.  
39. print$classname::$my_static."/n";// As of PHP 5.3.0 
40.  
41. printBar::$my_static."/n"; 
42.  
43. $bar=newBar(); 
44.  
45. print$bar->fooStatic() ."/n"; 

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

1. classA 
2.  
3. { 
4.  
5.   private$proPrivate="private of A"; 
6.  
7.   protected$proProtected="protected of A"; 
8.  
9.   public$proPublic="public of A"; 
10.  
11.   privatefunctionfoo() 
12.  
13.   { 
14.  
15.     echo$this->proPrivate."/n"; 
16.  
17.     echo$this->proProtected."/n"; 
18.  
19.     echo$this->proPublic."/n"; 
20.  
21.   } 
22.  
23.      
24.  
25.   publicfunctiontest() 
26.  
27.   { 
28.  
29.     $this->foo(); 
30.  
31.     static::foo(); 
32.  
33.   } 
34.  
35. } 
36.  
37.    
38.  
39. classBextendsA 
40.  
41. { 
42.  
43.  /* foo() will be copied to B, hence its scope will still be A and 
44.  
45.   * the call be successful */ 
46.  
47. } 
48.  
49.    
50.  
51. classCextendsA 
52.  
53. { 
54.  
55.   private$proPrivate="private of C"; 
56.  
57.   protected$proProtected="protected of C"; 
58.  
59.   public$proPublic="public of C"; 
60.  
61.      
62.  
63.   privatefunctionfoo() 
64.  
65.   { 
66.  
67.     /* original method is replaced; the scope of the new one is C */ 
68.  
69.     echo"I am C/n"; 
70.  
71.   } 
72.  
73.      
74.  
75.   publicfunctionmyFoo() 
76.  
77.   { 
78.  
79.     //parent::foo(); 
80.  
81.     $this->foo(); 
82.  
83.   } 
84.  
85. } 
86.  
87.    
88.  
89. echo"Class B:/n"; 
90.  
91. $b=newB(); 
92.  
93. $b->test(); 
94.  
95. echo"/nClass C:/n"; 
96.  
97. $c=newC(); 
98.  
99. $c->myFoo(); 
100.  
101. $c->test(); //fails 

上例輸出結果：

Class B:

privateof A

protectedof A

publicof A

privateof A

protectedof A

publicof A

Class C:

I am C

privateof A

protectedof C

publicof C

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