PHP5新特性: 更加面向对象化的PHP

php处理对象部分的内核完全重新开发过，提供更多功能的同时也提高了性能。在以前版本的php中，处理对象和处理基本类型（数字，字符串）的方式是一样的。这种方式的缺陷是：当将对象赋值给一个变量时，或者通过参数传递对象时，对象将被完全拷贝一份。在新的版本里，上述操作将传递引用（可以把引用理解成对象的标识符），而非值。

很多php程序员可能甚至没有察觉到老的对象处理方式。事实上，大多数的php应用都可以很好地运行。或者仅仅需要很少的改动。

私有和受保护成员
php5引入了私有和受保护成员变量的概念。我们可以用它来定义类成员的可见性。

例子
受保护成员可以被子类访问， 而私有成员只能被类本身访问。

<?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();
?> 

私有方法和受保护方法
php5也引入了私有方法和受保护方法的概念。

例子：
<?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）的代码可以不经改动运行。

抽象类和抽象方法
php5也引入了抽象类和抽象方法的概念。抽象方法只是声明了方法的签名并不提供它的实现。包含抽象方法的类必须被声明成抽象类。

例子：
<?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();
?> 

抽象类不能被实例化。以前的不使用抽象类的老代码可以不经改动运行。

接口
php5引入了接口。一个类可以实现多个接口。

例子：
<?php
interface throwable {
   public function getmessage();
}

class myexception implements throwable {
   public function getmessage() {
       // ...
   }
}
?> 

以前的不使用接口的老代码可以不经改动运行

 

类的型别提示

php5依然是弱类型的，不过在定义函数参数时，可以使用类的型别提示来声明期望传入的对象类型

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);
?> 

和其他强类型语言一样，php5类的型别提示在运行期间检查而非编译期间检查。即：

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

和下面的代码是一样的：

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

这个语法只适用于类，不适用于内建类型。 

final

php 5 引入了final关键字来声明final成员和final方法。final成员和final方法不能被子类覆盖。

example
<?php
class foo {
   final function bar() {
       // ...
   }
}
?> 

更进一步，可以把类声明成final。将类声明成final可以阻止这个类被继承。final类里面的方法缺省地都是final的,无需再声明一次。

example
<?php
final class foo {
   // class definition
}

// the next line is impossible
// class bork extends foo {}
?> 

属性不能定义成为final.

以前的不使用final的老代码可以不经改动运行.

对象克隆
php4没有提供一种机制来让用户自己定义复制构造子（copy constructor）控制对象的复制过程。php4做二进制的拷贝，因而很精确地复制了对象的所有属性。

精确地复制对象的所有属性可能并不是我们一直想要的。有个例子可以很好地说明我们确实需要复制构造子：比如一个gtk window的对象 a。 a持有它所需要的全部资源。当复制的这个gtk window到对象b时候，我们更希望b持有新的资源对象。再举个例子：对象a包含了一个对象c, 当你把对象a 复制到对象c的时候。我们可能更希望对象b包含一个新的对象c的copy， 而不是一个对象c的引用。（译者注：这里所说的就是浅克隆和深克隆。）

对象的复制是通过clone这个关键字达到的(clone调用被克隆对象的__clone()方法)。对象的__clone方法不能够直接被调用。

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

当developer创建对象的一份拷贝的时候,php5将会检查 __clone()方法是否存在。如果不存在，那么它就会呼叫缺省的__clone()方法，复制对象的所有属性。如果__clone()方法已经定义过，那么_clone()方法就会负责设置新对象的属性。为了方便起见，engine会缺省地复制所有的属性。所以在__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";
?> 

统一构造函数
php5允许开发者声明一个类的构造方法。拥有构造方法的类在每次创建新的对象的时候都会呼叫这个方法，因此构造方法适合对象在被使用之前的初始化工作

php4中，构造方法的名称和类的名称一样。考虑到从子类构造方法呼叫父类构造方法的情况是非常普遍的，而将类从一个继承体系中搬迁引起的父类变更就常常导致需要更改类的构造方法，php4的做法显然是不太合理的。

php5引入了一个声明构建函数的标准方法： __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()，它会寻找老式的构造方法，即与类同名的方法。简单的说，只有当老代码里包含了一个__construct()方法的时候，才存在一个兼容性的问题。

析构方法
对于面向对象的编程来说，可以定义析构方法是非常有用的一个功能。析构方法可以用来记录调试信息，关闭数据库连接等等一些清除收尾的工作。php4中没有析构方法，尽管php4已经支持可以注册一个函数以便请求结束的时候被调用。

php5引进的析构方法的概念和其他面向对象的语言（比如java）是一致的。当指向这个对象的最后一个引用被销毁的时候，析构方法被调用，调用完成后释放内存。注意：析构方法不接受任何参数。

example
<?php
class mydestructableclass {
   function __construct() {
       print "in constructor\n";
       $this->name = "mydestructableclass";
   }

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

$obj = new mydestructableclass();
?> 

和构建方法一样，父类的析构方法也不会被隐含调用。子类可以在自己的析构方法通过调用parent::__destruct()来显式地调用它。

constants
php5引入了class级别的常量。 

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

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

老的没有使用const的代码仍然正常运行。

exceptions
php4没有异常控制。php5引入了和其它语言（java）相似的异常控制模式。应该注意的是php5里面支持捕捉全部异常，但是不支持finally子句。

在catch语句块里面，可以重新抛出异常。也可以有多个catch语句，在这种情况下，被捕捉到的异常从上往下依次比较和catch语句比较异常，第一个类型匹配的catch语句将会被执行。如果一直搜索到底还没有发现匹配的catch子句，则寻找下一个try/catch语句。最后不能捕捉的异常将被显示出来。如果异常被捕捉，那么程序会接着catch语句块的下面开始执行。

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继承并定义自己的异常。这是因为系统内建的exception类能够收集到很多有用的信息， 而不继承它的异常类是得不到这些信息的。下面的php代码模仿了系统内建exception类。每个属性后面都加了注释。每个属性都有一个getter，由于这些getter方法经常被系统内部处理调用，所以这些方法被标明了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中不能再次引用函数返回的对象以进一步呼叫返回对象的方法，而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();
?> 

静态成员变量能够被初始化。
example
<?php
class foo {
   static $my_static = 5;
   public $my_prop = 'bla';
}

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

静态方法
php 5 引入了静态方法，可以在不实例化类的情况下呼叫静态方法。

example
<?php
class foo {
   public static function astaticmethod() {
       // ...
   }
}

foo::astaticmethod();
?> 

伪变量$this不能够在静态方法方法中使用。

instanceof
php5引入了instanceof关键字，允许用它来测试一个对象是一个类的实例，或者是一个派生类的实例，或者实现了某个接口

example
<?php
class baseclass { }

$a = new baseclass;

if ($a instanceof baseclass) {
   echo "hello world";
}
?> 

static function variables
现在，静态变量在编译阶段处理。因此程序员可以通过引用为静态变量赋值。这可以改善性能，不过，不能够使用对静态变量的间接引用了。

按引用传递的函数参数现在也可以设置缺省值了。

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

__autoload()
__autoload() 拦截函数在一个未声明的类被初始化的时候自动调用。该类的名字会被自动传递给__autoload()函数。而__autoload()也只有这么唯一的一个参数。

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);
?> 

迭代
当和foreach一起使用对象的时候，迭代的方式被重载过了。缺省的行为是迭代类的所有属性。

example
<?php
class foo {
   public $x = 1;
   public $y = 2;
}

$obj = new foo;

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

一个类的所有对象都能够被迭代浏览到， 如果这个类实现了一个空的接口：traversable. 换句话说，实现了traversable接口的类可以和foreach一起使用。

接口 iteratoraggregate 和iterator允许指定类的对象在代码中如何迭代。iteratoraggregate接口有一个方法：getiterator() 必须返回一个数组

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方法来控制对象到字符串的转换。

example
<?php
class foo {
   function __tostring() {
       return "what ever";
   }
}

$obj = new foo;

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

reflection api
php5引入了全套的反射api，以支持对类，接口，函数，方法的反向工程。

它也提供了api以从程序中提取注释文档。反射api的详细资料参考此处：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');
?> 

新内存管理机制
php5有一个全新的内存管理机制，使得它在多线程的环境下可以更有效地运行。在分配和释放内存时，不再使用mutex锁定/解除锁定