PHP5的几个新特性

1.构造函数和析构函数
  在 PHP4 中，当函数与对象同名时，这个函数将成为该对象的构造函数，并且在 PHP4 中没有析构函数的概念。 
  在 PHP5 中，构造函数被统一命名为 __construct，并且引入了析构函数的概念，被统一命名为 __destruct。
  例一：
  class foo { 
      var $x; 
      function __construct($x) { 
          $this->x = $x; 
      } 
      function display() { 
          echo $this->x; 
      } 
      function __destruct() { 
          echo "bye bye"; 
      } 
  } 
  $o1 = new foo(4); 
  $o1->display(); 
?> 
在上面的例子中，当你终止调用 foo 类的时候，其析构函数将会被调用，上例中会输出 “bye bye”。


2.对象的引用
  在PHP4 中，传递变量给一个函数或方法，实际是把这个变量做了一次复制，也就意味着你传给函数或方法的是这个变量的一个副本，除非你使用了引用符号 “&” 来声明是要做一个引用，而不是一个 Copy。在 PHP5 中，对象总是以引用的形式存在的，对象中的赋值操作同样也都是一个引用操作。
  例二：
  class foo { 
var $x; 
function setX($x) { 
$this->x = $x; 
} 
function getX() { 
return $this->x; 
} 
function copy(){
return clone $this;//克隆对象
}
  } 
  $o1 = new foo; 
  $o1->setX(4); 
  $o2 = $o1; 
  $o1->setX(5); 
  if($o1->getX() == $o2->getX()) print("Oh my god!"); //输出
  $o3 = $o1->copy();
  $o1->setX(6); 
  if($o1->getX() != $o3->getX()) print("Copies are independant"); //输出


3.对象中的私有、公共及保护模式
  PHP4 中，一个对象的所有方法和变量都是公共的，这意味着你可以在一个对象的外部操作其中的任意一个变量和方法。PHP5 引入了三种新的用来控制这种存取权限的模式，它们是：公共的(Public)、受保护的(Protected)及私有的(Private)。
  公共模式(Public):允许在对象外部进行操作控制。 
  私有模式(Private):只允许本对象内的方法对其进行操作控制。 
  受保护模式(Protected)：允许本对象及其父对象以及子对象对其进行操作控制。
  例三：
  class foo { 
public $a='a';
private $b='b';
protected $c='c';
function testb(){
return $this->b;
}
function testc(){
return $this->c;
}
  } 
  class foo2 extends foo{
function test2b(){
return parent::$b;
}
function test2c(){
return $this->c;
}
  }
  $f = new foo();
  //echo $f->a;
  //echo $f->b;//Cannot access private property
  //echo $f->c;//Cannot access protected property
  //echo $f->testb();
  //echo $f->testc();
  $f2 = new foo2();
  //echo $f2->test2b();// Cannot access private property
  echo $f2->test2c();


4.__call
  PHP5 的对象新增了一个专用方法 __call()，这个方法用来监视一个对象中的其它方法。如果你试着调用一个对象中不存在的方法，__call 方法将会被自动调用。
  例四：
  class foo { 
function __call($name,$arguments) { 
print("Did you call me? I'm $name!");
} 
  } 
  $x = new foo(); 
  $x->doStuff(); 
  $x->fancy_stuff(); 


5.__set 和 __get
  可以用来捕获一个对象中不存在的变量和方法。
  例五：
  class foo { 
var $a;
function __set($name,$val) { 
print("Hello, you tried to put $val in $name"); 
} 
function __get($name) { 
print("Hey you asked for $name"); 
} 
  } 
  $x = new foo(); 
  $x->bar = 3; //输出
  print($x->winky_winky); //输出


6.类型指示
  例六：
  class foo { 
// code ... 
  } 
  class foo2 { 
// code ... 
  } 
  class bar { 
public function process_a_foo(foo $foo) { 
// Some code 
} 
  } 
  $b = new bar(); 
  $f = new foo(); 
  $b->process_a_foo($f); 
  $f2 = new foo2();
  //$b->process_a_foo($f2); // Argument 1 passed to bar::process_a_foo() must be an instance of foo, instance of foo2 given


7.静态成员
  静态成员和静态方法在面象对象编程的术语中被称作 “对象方法(class methods)” 和 “对象变量(class variables)”。 “对象方法” 在一个对象没有实例化前允许被调用。同样，“对象变量” 在一个对象没有实例化前可以被独立操作控制(不需要用一个对象的方法来控制)。
  例七：
  class calculator { 
    static public $pi = 3.14151692; 
static public function add($x,$y) { 
return $x + $y; 
} 
  } 
  $s = calculator::$pi; 
  $result = calculator::add(3,7); 
  echo $result;


8.异常处理
  异常处理是公认的处理程序错误的理想方法，在 Java 及 C++ 中都有这个概念，我们欣喜的看到，在 PHP5 已经加入了这方面的应用。你可以尝试使用 “try” 和 “catch” 来控制程序的错误。
  例八：
  class foo { 
function divide($x,$y) { 
if($y==0){
throw new Exception("cannot divide by zero"); 
}
return $x/$y; 
} 
  } 
  $x = new foo(); 
  try { 
$x->divide(3,0); 
  } catch (Exception $e) { 
echo $e->getMessage(); 
  } 
  上例中，我们使用了 “try” 来执行花括号中的语句，当有错误发生的时候，代码会把错误交给 “catch” 子句来处理，在 “catch” 子句中，你需要指明要把错误交给某个对象处理，这样做可以使代码结构看起来更清晰，因为现在我们可以把所有的错误信息交给一个对象来处理。
  例九：自定义错误处理
  class WeirdProblem extends Exception { 
private $data; 
function WeirdProblem($data) { 
$this->data = $data; 
} 
function getWeirdMessage() { 
return $this->data . " caused a weird exception!"; 
} 
  } 
  class foo { 
function divide($x,$y) { 
if($y==0){
throw new WeirdProblem("cannot divide by zero"); 
}
return $x/$y; 
} 
  } 
  $x = new foo(); 
  try { 
$x->divide(3,0); 
  } catch (Exception $e) { 
echo $e->getWeirdMessage(); 
  } 


9.命名空间
  名称空间对类的分组或函数分组很有用。它可以把一些相关的类或函数给组合到一起，方便以后调用。
  在实际运用中，你可能会需要声明两个或多个名称一样的对象来做不同的事情，那么你就可以把他们分别放到不同的名称空间中去。
  例十：
  namespace Foo; 
  class Test {
function __construct(){
echo 'a';
}
  } 
  use Foo as ns; 
  $a = new ns\Test;