PHP處理對象部分的內(nèi)核完全重新開發(fā)過，提供更多功能的同時也提高了性能。在以前版本的php中，處理對象和處理基本類型（數(shù)字，字符串）的方式是一樣的。這種方式的缺陷是：當(dāng)將對象賦值給一個變量時，或者通過參數(shù)傳遞對象時，對象將被完全拷貝一份。在新的版本里，上述操作將傳遞引用（可以把引用理解成對象的標(biāo)識符），而非值。

很多PHP程序員可能甚至沒有察覺到老的對象處理方式。事實上，大多數(shù)的php應(yīng)用都可以很好地運行?；蛘邇H僅需要很少的改動。

私有和受保護(hù)成員
PHP5引入了私有和受保護(hù)成員變量的概念。我們可以用它來定義類成員的可見性。

例子
受保護(hù)成員可以被子類訪問， 而私有成員只能被類本身訪問。

<?php
class MyClass {
   private $Hello = "Hello, World!\n";
   protected $Bar = "Hello, Foo!\n";
   protected $Foo = "Hello, Bar!\n";

   function printHello() {
       print "MyClass::printHello() " . $this->Hello;
       print "MyClass::printHello() " . $this->Bar;
       print "MyClass::printHello() " . $this->Foo;
   }
}

class MyClass2 extends MyClass {
   protected $Foo;

   function printHello() {
       MyClass::printHello();                          /* Should print */
       print "MyClass2::printHello() " . $this->Hello; /* Shouldn't print out anything */
       print "MyClass2::printHello() " . $this->Bar;  /* Shouldn't print (not declared)*/
       print "MyClass2::printHello() " . $this->Foo;  /* Should print */
   }
}

$obj = new MyClass();
print $obj->Hello;  /* Shouldn't print out anything */
print $obj->Bar;    /* Shouldn't print out anything */
print $obj->Foo;    /* Shouldn't print out anything */
$obj->printHello(); /* Should print */

$obj = new MyClass2();
print $obj->Hello;  /* Shouldn't print out anything */
print $obj->Bar;    /* Shouldn't print out anything */
print $obj->Foo;    /* Shouldn't print out anything */
$obj->printHello();
?> 

私有方法和受保護(hù)方法
PHP5也引入了私有方法和受保護(hù)方法的概念。

例子：
<?php
class Foo {
   private function aPrivateMethod() {
       echo "Foo::aPrivateMethod() called.\n";
   }

   protected function aProtectedMethod() {
       echo "Foo::aProtectedMethod() called.\n";
       $this->aPrivateMethod();
   }
}

class Bar extends Foo {
   public function aPublicMethod() {
       echo "Bar::aPublicMethod() called.\n";
       $this->aProtectedMethod();
   }
}

$o = new Bar;
$o->aPublicMethod();
?> 

以前的不使用類的老代碼，沒有訪問修飾符（public, protected, private）的代碼可以不經(jīng)改動運行。

抽象類和抽象方法
Php5也引入了抽象類和抽象方法的概念。抽象方法只是聲明了方法的簽名并不提供它的實現(xiàn)。包含抽象方法的類必須被聲明成抽象類。

例子：
<?php
abstract class AbstractClass {
   abstract public function test();
}

class ImplementedClass extends AbstractClass {
   public function test() {
       echo "ImplementedClass::test() called.\n";
   }
}

$o = new ImplementedClass;
$o->test();
?> 

抽象類不能被實例化。以前的不使用抽象類的老代碼可以不經(jīng)改動運行。

接口
Php5引入了接口。一個類可以實現(xiàn)多個接口。

例子：
<?php
interface Throwable {
   public function getMessage();
}

class MyException implements Throwable {
   public function getMessage() {
       // ...
   }
}
?> 

以前的不使用接口的老代碼可以不經(jīng)改動運行

 

類的型別提示

PHP5依然是弱類型的，不過在定義函數(shù)參數(shù)時，可以使用類的型別提示來聲明期望傳入的對象類型

Example
<?php
interface Foo {
   function a(Foo $foo);
}

interface Bar {
   function b(Bar $bar);
}

class FooBar implements Foo, Bar {
   function a(Foo $foo) {
       // ...
   }

   function b(Bar $bar) {
       // ...
   }
}

$a = new FooBar;
$b = new FooBar;

$a->a($b);
$a->b($b);
?> 

和其他強(qiáng)類型語言一樣，php5類的型別提示在運行期間檢查而非編譯期間檢查。即：

<?php
function foo(ClassName $object) {
   // ...
}
?> 

和下面的代碼是一樣的：

<?php
function foo($object) {
   if (!($object instanceof ClassName)) {
       die("Argument 1 must be an instance of ClassName");
   }
}
?> 

這個語法只適用于類，不適用于內(nèi)建類型。 

Final

PHP 5 引入了final關(guān)鍵字來聲明final成員和final方法。final成員和final方法不能被子類覆蓋。

Example
<?php
class Foo {
   final function bar() {
       // ...
   }
}
?> 

更進(jìn)一步，可以把類聲明成final。將類聲明成final可以阻止這個類被繼承。final類里面的方法缺省地都是final的,無需再聲明一次。

Example
<?php
final class Foo {
   // class definition
}

// the next line is impossible
// class Bork extends Foo {}
?> 

屬性不能定義成為final.

以前的不使用final的老代碼可以不經(jīng)改動運行.

對象克隆
Php4沒有提供一種機(jī)制來讓用戶自己定義復(fù)制構(gòu)造子（copy constructor）控制對象的復(fù)制過程。Php4做二進(jìn)制的拷貝，因而很精確地復(fù)制了對象的所有屬性。

精確地復(fù)制對象的所有屬性可能并不是我們一直想要的。有個例子可以很好地說明我們確實需要復(fù)制構(gòu)造子：比如一個GTK Window的對象 a。 a持有它所需要的全部資源。當(dāng)復(fù)制的這個GTK Window到對象b時候，我們更希望b持有新的資源對象。再舉個例子：對象a包含了一個對象c, 當(dāng)你把對象a 復(fù)制到對象c的時候。我們可能更希望對象b包含一個新的對象c的copy， 而不是一個對象c的引用。（譯者注：這里所說的就是淺克隆和深克隆。）

對象的復(fù)制是通過clone這個關(guān)鍵字達(dá)到的(Clone調(diào)用被克隆對象的__clone()方法)。對象的__clone方法不能夠直接被調(diào)用。

<?php
$copy_of_object = clone $object;
?> 

當(dāng)developer創(chuàng)建對象的一份拷貝的時候,php5將會檢查 __clone()方法是否存在。如果不存在，那么它就會呼叫缺省的__clone()方法，復(fù)制對象的所有屬性。如果__clone()方法已經(jīng)定義過，那么_clone()方法就會負(fù)責(zé)設(shè)置新對象的屬性。為了方便起見，Engine會缺省地復(fù)制所有的屬性。所以在__clone()方法中，只需要覆蓋那些需要更改的屬性就可以了。如下：
Example
<?php
class MyCloneable {
   static $id = 0;

   function MyCloneable() {
       $this->id = self::$id++;
   }

   function __clone() {
       $this->address = "New York";
       $this->id = self::$id++;
   }
}

$obj = new MyCloneable();

$obj->name = "Hello";
$obj->address = "Tel-Aviv";

print $obj->id . "\n";

$obj_cloned = clone $obj;

print $obj_cloned->id . "\n";
print $obj_cloned->name . "\n";
print $obj_cloned->address . "\n";
?> 

統(tǒng)一構(gòu)造函數(shù)
Php5允許開發(fā)者聲明一個類的構(gòu)造方法。擁有構(gòu)造方法的類在每次創(chuàng)建新的對象的時候都會呼叫這個方法，因此構(gòu)造方法適合對象在被使用之前的初始化工作

Php4中，構(gòu)造方法的名稱和類的名稱一樣。考慮到從子類構(gòu)造方法呼叫父類構(gòu)造方法的情況是非常普遍的，而將類從一個繼承體系中搬遷引起的父類變更就常常導(dǎo)致需要更改類的構(gòu)造方法，php4的做法顯然是不太合理的。

Php5引入了一個聲明構(gòu)建函數(shù)的標(biāo)準(zhǔn)方法： __construct().如下：

Example
<?php
class BaseClass {
   function __construct() {
       print "In BaseClass constructor\n";
   }
}

class SubClass extends BaseClass {
   function __construct() {
       parent::__construct();
       print "In SubClass constructor\n";
   }
}

$obj = new BaseClass();
$obj = new SubClass();
?> 

為保持向后的兼容性，如果php5不能夠找到 __construct()，它會尋找老式的構(gòu)造方法，即與類同名的方法。簡單的說，只有當(dāng)老代碼里包含了一個__construct()方法的時候，才存在一個兼容性的問題。

析構(gòu)方法
對于面向?qū)ο蟮木幊虂碚f，可以定義析構(gòu)方法是非常有用的一個功能。析構(gòu)方法可以用來記錄調(diào)試信息，關(guān)閉數(shù)據(jù)庫連接等等一些清除收尾的工作。Php4中沒有析構(gòu)方法，盡管php4已經(jīng)支持可以注冊一個函數(shù)以便請求結(jié)束的時候被調(diào)用。

Php5引進(jìn)的析構(gòu)方法的概念和其他面向?qū)ο蟮恼Z言（比如java）是一致的。當(dāng)指向這個對象的最后一個引用被銷毀的時候，析構(gòu)方法被調(diào)用，調(diào)用完成后釋放內(nèi)存。注意：析構(gòu)方法不接受任何參數(shù)。

Example
<?php
class MyDestructableClass {
   function __construct() {
       print "In constructor\n";
       $this->name = "MyDestructableClass";
   }

   function __destruct() {
       print "Destroying " . $this->name . "\n";
   }
}

$obj = new MyDestructableClass();
?> 

和構(gòu)建方法一樣，父類的析構(gòu)方法也不會被隱含調(diào)用。子類可以在自己的析構(gòu)方法通過調(diào)用parent::__destruct()來顯式地調(diào)用它。

Constants
Php5引入了class級別的常量。 

<?php
class Foo {
   const constant = "constant";
}

echo "Foo::constant = " . Foo::constant . "\n";
?> 

老的沒有使用const的代碼仍然正常運行。

Exceptions
Php4沒有異?？刂?。Php5引入了和其它語言（java）相似的異常控制模式。應(yīng)該注意的是php5里面支持捕捉全部異常，但是不支持finally子句。

在catch語句塊里面，可以重新拋出異常。也可以有多個catch語句，在這種情況下，被捕捉到的異常從上往下依次比較和catch語句比較異常，第一個類型匹配的catch語句將會被執(zhí)行。如果一直搜索到底還沒有發(fā)現(xiàn)匹配的catch子句，則尋找下一個try/catch語句。最后不能捕捉的異常將被顯示出來。如果異常被捕捉，那么程序會接著catch語句塊的下面開始執(zhí)行。

Example
<?php
class MyException {
   function __construct($exception) {
       $this->exception = $exception;
   }

   function Display() {
       print "MyException: $this->exception\n";
   }
}

class MyExceptionFoo extends MyException {
   function __construct($exception) {
       $this->exception = $exception;
   }

   function Display() {
       print "MyException: $this->exception\n";
   }
}

try {
   throw new MyExceptionFoo('Hello');
}
catch (MyException $exception) {
   $exception->Display();
}
catch (Exception $exception) {
   echo $exception;
}
?> 

上面的例子表明可以定義一個并不繼承自 Exception的異常類，但是，最好還是從Exception繼承并定義自己的異常。這是因為系統(tǒng)內(nèi)建的Exception類能夠收集到很多有用的信息， 而不繼承它的異常類是得不到這些信息的。下面的php代碼模仿了系統(tǒng)內(nèi)建Exception類。每個屬性后面都加了注釋。每個屬性都有一個getter，由于這些getter方法經(jīng)常被系統(tǒng)內(nèi)部處理調(diào)用，所以這些方法被標(biāo)明了final。

Example
<?php
class Exception {
   function __construct(string $message=NULL, int code=0) {
       if (func_num_args()) {
           $this->message = $message;
       }
       $this->code = $code;
       $this->file = __FILE__; // of throw clause
       $this->line = __LINE__; // of throw clause
       $this->trace = debug_backtrace();
       $this->string = StringFormat($this);
   }

   protected $message = 'Unknown exception';  // exception message
   protected $code = 0; // user defined exception code
   protected $file;    // source filename of exception
   protected $line;    // source line of exception

   private $trace;      // backtrace of exception
   private $string;    // internal only!!

   final function getMessage() {
       return $this->message;
   }
   final function getCode() {
       return $this->code;
   }
   final function getFile() {
       return $this->file;
   }
   final function getTrace() {
       return $this->trace;
   }
   final function getTraceAsString() {
       return self::TraceFormat($this);
   }
   function _toString() {
       return $this->string;
   }
   static private function StringFormat(Exception $exception) {
       // ... a function not available in PHP scripts
       // that returns all relevant information as a string
   }
   static private function TraceFormat(Exception $exception) {
       // ... a function not available in PHP scripts
       // that returns the backtrace as a string
   }
}
?> 

如果我們定義的一異常類都是繼承自Exception基類

無兼容性問題。老的代碼不會受到這一特性的影響。

Dereferencing objects returned from functions
Php4中不能再次引用函數(shù)返回的對象以進(jìn)一步呼叫返回對象的方法，而php5是可以的。

<?php
class Circle {
   function draw() {
       print "Circle\n";
   }
}

class Square {
   function draw() {
       print "Square\n";
   }
}

function ShapeFactoryMethod($shape) {
   switch ($shape) {
       case "Circle": 
           return new Circle();
       case "Square": 
           return new Square();
   }
}

ShapeFactoryMethod("Circle")->draw();
ShapeFactoryMethod("Square")->draw();
?> 

靜態(tài)成員變量能夠被初始化。
Example
<?php
class foo {
   static $my_static = 5;
   public $my_prop = 'bla';
}

print foo::$my_static;
$obj = new foo;
print $obj->my_prop;
?> 

靜態(tài)方法
PHP 5 引入了靜態(tài)方法，可以在不實例化類的情況下呼叫靜態(tài)方法。

Example
<?php
class Foo {
   public static function aStaticMethod() {
       // ...
   }
}

Foo::aStaticMethod();
?> 

偽變量$this不能夠在靜態(tài)方法方法中使用。

instanceof
Php5引入了instanceof關(guān)鍵字，允許用它來測試一個對象是一個類的實例，或者是一個派生類的實例，或者實現(xiàn)了某個接口

Example
<?php
class baseClass { }

$a = new baseClass;

if ($a instanceof baseClass) {
   echo "Hello World";
}
?> 

Static function variables
現(xiàn)在，靜態(tài)變量在編譯階段處理。因此程序員可以通過引用為靜態(tài)變量賦值。這可以改善性能，不過，不能夠使用對靜態(tài)變量的間接引用了。

按引用傳遞的函數(shù)參數(shù)現(xiàn)在也可以設(shè)置缺省值了。

Example
<?php
function my_function(&$var = null) {
   if ($var === null) {
       die("$var needs to have a value");
   }
}
?> 

__autoload()
__autoload() 攔截函數(shù)在一個未聲明的類被初始化的時候自動調(diào)用。該類的名字會被自動傳遞給__autoload()函數(shù)。而__autoload()也只有這么唯一的一個參數(shù)。

Example
<?php
function __autoload($className) {
   include_once $className . ".php";
}

$object = new ClassName;
?> 

可重載的方法呼叫和屬性訪問
方法呼叫和屬性訪問都能夠通過__call, __get() and __set()方法重載。

Example: __get() and __set()
<?php
class Setter {
   public $n;
   public $x = array("a" => 1, "b" => 2, "c" => 3);

   function __get($nm) {
       print "Getting [$nm]\n";

       if (isset($this->x[$nm])) {
           $r = $this->x[$nm];
           print "Returning: $r\n";
           return $r;
       } else {
           print "Nothing!\n";
       }
   }

   function __set($nm, $val) {
       print "Setting [$nm] to $val\n";

       if (isset($this->x[$nm])) {
           $this->x[$nm] = $val;
           print "OK!\n";
       } else {
           print "Not OK!\n";
       }
   }
}

$foo = new Setter();
$foo->n = 1;
$foo->a = 100;
$foo->a++;
$foo->z++;
var_dump($foo);
?> 

Example: __call()
<?php
class Caller {
   private $x = array(1, 2, 3);

   function __call($m, $a) {
       print "Method $m called:\n";
       var_dump($a);
       return $this->x;
   }
}

$foo = new Caller();
$a = $foo->test(1, "2", 3.4, true);
var_dump($a);
?> 

迭代
當(dāng)和foreach一起使用對象的時候，迭代的方式被重載過了。缺省的行為是迭代類的所有屬性。

Example
<?php
class Foo {
   public $x = 1;
   public $y = 2;
}

$obj = new Foo;

foreach ($obj as $prp_name => $prop_value) {
   // using the property
}
?> 

一個類的所有對象都能夠被迭代瀏覽到， 如果這個類實現(xiàn)了一個空的接口：Traversable. 換句話說，實現(xiàn)了Traversable接口的類可以和foreach一起使用。

接口 IteratorAggregate 和Iterator允許指定類的對象在代碼中如何迭代。IteratorAggregate接口有一個方法：getIterator() 必須返回一個數(shù)組

Example
<?php
class ObjectIterator implements Iterator {

   private $obj;
   private $num;

   function __construct($obj) {
       $this->obj = $obj;
   }
   function rewind() {
       $this->num = 0;
   }
   function valid() {
       return $this->num < $this->obj->max;
   }
   function key() {
       return $this->num;
   }
   function current() {
       switch($this->num) {
           case 0: return "1st";
           case 1: return "2nd";
           case 2: return "3rd";
           default: return $this->num."th";
       }
   }
   function next() {
       $this->num++;
   }
}

class Object implements IteratorAggregate {

   public $max = 3;

   function getIterator() {
       return new ObjectIterator($this);
   }
} 

$obj = new Object;

// this foreach ...
foreach($obj as $key => $val) {
   echo "$key = $val\n";
}

// matches the following 7 lines with the for directive.
$it = $obj->getIterator();
for($it->rewind(); $it->hasMore(); $it->next) {
   $key = $it->current();
   $val = $it->key();
   echo "$key = $val\n";
}
unset($it);
?> 

新的__toString方法
可以通過覆蓋__toString方法來控制對象到字符串的轉(zhuǎn)換。

Example
<?php
class Foo {
   function __toString() {
       return "What ever";
   }
}

$obj = new Foo;

echo $obj; // call __toString()
?> 

Reflection API
Php5引入了全套的反射API，以支持對類，接口，函數(shù)，方法的反向工程。

它也提供了API以從程序中提取注釋文檔。反射API的詳細(xì)資料參考此處：http://sitten-polizei.de/php/reflection_api/docs/language.reflection.html

Example
<?php
class Foo {
   public $prop;
   function Func($name) {
       echo "Hello $name";
   }
}

reflection_class::export('Foo');
reflection_object::export(new Foo);
reflection_method::export('Foo', 'func');
reflection_property::export('Foo', 'prop');
reflection_extension::export('standard');
?> 

新內(nèi)存管理機(jī)制
Php5有一個全新的內(nèi)存管理機(jī)制，使得它在多線程的環(huán)境下可以更有效地運行。在分配和釋放內(nèi)存時，不再使用mutex鎖定/解除鎖定