标题php4和php5区别
日期:    作者:   来源:
文章打印自:
访问文章完全地址:
头部广告
构造函数和析构函数

在 PHP4 中,当函数与对象同名时,这个函数将成为该对象的构造函数,并且在 PHP4 中没有析构函数的概念.
在 PHP5 中,构造函数被统一命名为 __construct,并且引入了析构函数的概念,被统一命名为 __destruct.

例一：构造函数和析构函数  

PHP代码
  1. <?   
  2. class foo {    
  3.     var $x;    
  4.     function __construct($x) {    
  5.         $this->x = $x;    
  6.     }   
  7.     function display() {    
  8.         print($this->x);    
  9.     }   
  10.     function __destruct() {    
  11.         print("bye bye");    
  12.     }   
  13. }   
  14. $o1 = new foo(4);    
  15. $o1->display();    
  16. ?>  


在上面的例子中,当你终止调用 foo 类的时候,其析构函数将会被调用,上例中会输出 “bye bye”.

对象的引用

众所周知,在PHP4 中,传递变量给一个函数或方法,实际是把这个变量做了一次复制,也就意味着你传给函数或方法的是这个变量的一个副本,除非你使用了引用符号 “&” 来声明是要做一个引用,而不是一个 Copy.在 PHP5 中,对象总是以引用的形式存在的,对象中的赋值操作同样也都是一个引用操作.

例二：对象的引用

PHP代码
  1. <?   
  2. class foo {    
  3.  var $x;    
  4.  function setX($x) {    
  5.   $this->x = $x;    
  6.  }    
  7.  function getX() {    
  8.   return $this->x;    
  9.  }    
  10. }    
  11. $o1 = new foo;    
  12. $o1->setX(4);    
  13. $o2 = $o1;    
  14. $o1->setX(5);    
  15. if($o1->getX() == $o2->getX()) print("Oh my god!");    
  16. ?>   
对象的克隆

如上所述,当一个对象始终以引用的形式来被调用时,如果我想得到该对象的一个副本,该怎么办呢？PHP5 提供了一个新的功能,就是对象的克隆,语法为 __clone.

例三：对象的克隆

PHP代码
  1. <?   
  2. class foo {    
  3.     var $x;    
  4.     function setX($x) {    
  5.         $this->x = $x;    
  6.     }    
  7.     function getX() {    
  8.         return $this->x;    
  9.     }    
  10. }    
  11. $o1 = new foo;    
  12. $o1->setX(4);    
  13. $o2 = $o1->__clone();    
  14. $o1->setX(5); if($o1->getX() != $o2->getX()) print("Copies are independant");    
  15. ?>  

对象克隆的方法在其它很多应用程序语言中都是存在的,所以你不必担心它的稳定性.

对象中的私有、公共及保护模式

PHP4 中,一个对象的所有方法和变量都是公共的,这意味着你可以在一个对象的外部操作其中的任意一个变量和方法.PHP5 引入了三种新的用来控制这种存取权限的模式,它们是：公共的(Public)、受保护的(Protected)及私有的(Private).

公共模式(Public):允许在对象外部进行操作控制.
私有模式(Private):只允许本对象内的方法对其进行操作控制.
受保护模式(Protected)：允许本对象及其父对象对其进行操作控制.

例四： 对象中的私有、公共及受保护模式

PHP代码
  1. <?   
  2. class foo {    
  3.     private $x;    
  4.     public function public_foo() {    
  5.         print("I'm public");    
  6.     }   
  7.     protected function protected_foo() {    
  8.         $this->private_foo(); //Ok because we are in the same class we can call private methods    
  9.         print("I'm protected");    
  10.     }   
  11.     private function private_foo() {    
  12.         $this->x = 3;    
  13.         print("I'm private");    
  14.     }    
  15. }   
  16. class foo2 extends foo {    
  17.     public function display() {    
  18.         $this->protected_foo();    
  19.         $this->public_foo();    
  20.         // $this->private_foo(); // Invalid! the function is private in the base class    
  21.     }   
  22. }   
  23. $x = new foo();   
  24. $x->public_foo();   
  25. //$x->protected_foo(); //Invalid cannot call protected methods outside the class and derived classes    
  26. //$x->private_foo(); //Invalid private methods can only be used inside the class $x2 = new foo2();    
  27. $x2->display();   
  28. ?>  

提示：对象中的变量总是以私有形式存在的,直接操作一个对象中的变量不是一个好的面向对象编程的习惯,更好的办法是把你想要的变量交给一个对象的方法去处理.

接口 (Interfaces)

众所周知,PHP4 中的对象支持继承,要使一个对象成为另一个对象的派生类,你需要使用类似 “class foo extends parent” 的代码来控制. PHP4 和 PHP5 中,一个对象都仅能继承一次,多重继承是不被支持的.不过,在 PHP5 中产生了一个新的名词：接口,接口是一个没有具体处理代码的特殊对象,它仅仅定义了一些方法的名称及参数,此后的对象就可以方便的使用 'implement' 关键字把需要的接口整合起来,然后再加入具体的执行代码.

例五：接口
 

PHP代码
  1. <?   
  2. interface displayable {    
  3.     function display();    
  4. }    
  5. interface printable {    
  6.     function doprint();    
  7. }    
  8.   
  9. class foo implements displayable,printable {    
  10.     function display() {    
  11.     // code    
  12.     } function doprint() {    
  13.     // code    
  14.     }    
  15. }    
  16. ?>  

这对提高代码的可读性及通俗性有很大的帮助,通过上面的例子可以看到,对象 foo 包含了 displayable 和 printable 两个接口,这时我们就可以清楚的知道,对象 foo 一定会有一个 display() 方法和一个 print() 方法,只需要去了解接口部分,你就可以轻易的操作该对象而不必去关心对象的内部是如何运作的.

抽象类

抽象类不能被实例化.
抽象类与其它类一样,允许定义变量及方法.
抽象类同样可以定义一个抽象的方法,抽象类的方法不会被执行,不过将有可能会在其派生类中执行.

例六：抽象类

PHP代码
  1. <?   
  2. abstract class foo {    
  3.     protected $x;    
  4.     abstract function display();    
  5.     function setX($x) {    
  6.         $this->x = $x;    
  7.     }    
  8. }    
  9. class foo2 extends foo {    
  10.     function display() {    
  11.     // Code    
  12.     }    
  13. }    
  14. ?>  
__call

PHP5 的对象新增了一个专用方法 __call(),这个方法用来监视一个对象中的其它方法.如果你试着调用一个对象中不存在的方法,__call 方法将会被自动调用.

例七：__call

PHP代码
  1. <?   
  2. class foo {   
  3.     function __call($name,$arguments) {   
  4.         print("Did you call me? I'm $name!");   
  5.     }   
  6. }   
  7. $x = new foo();   
  8. $x->doStuff();   
  9. $x->fancy_stuff();   
  10. ?>  

这个特殊的方法可以被用来实现“过载(overloading)”的动作,这样你就可以检查你的参数并且通过调用一个私有的方法来传递参数.

例八：使用 __call 实现“过载”动作

PHP代码
  1. <?   
  2. class Magic {    
  3.     function __call($name,$arguments) {   
  4.         if($name=='foo') {   
  5.         if(is_int($arguments[0])) $this->foo_for_int($arguments[0]);   
  6.         if(is_string($arguments[0])) $this->foo_for_string($arguments[0]);   
  7.         }    
  8.     }   
  9.     private function foo_for_int($x) {   
  10.         print("oh an int!");    
  11.     }   
  12.     private function foo_for_string($x) {   
  13.         print("oh a string!");   
  14.     }   
  15. }   
  16. $x = new Magic();    
  17. $x->foo(3);    
  18. $x->foo("3");    
  19. ?>  
__set 和 __get

这是一个很棒的方法,__set 和 __get 方法可以用来捕获一个对象中不存在的变量和方法.
例九： __set 和 __get

PHP代码
  1. <?   
  2. class foo {    
  3.     function __set($name,$val) {    
  4.         print("Hello, you tried to put $val in $name");    
  5.     }    
  6.     function __get($name) {    
  7.         print("Hey you asked for $name");    
  8.     }    
  9. }    
  10. $x = new foo();    
  11. $x->bar = 3;    
  12. print($x->winky_winky);    
  13. ?>  
类型指示

在 PHP5 中,你可以在对象的方法中指明其参数必须为另一个对象的实例.

例十：类型指示

PHP代码
  1. <?   
  2. class foo {   
  3. // code ...   
  4. }    
  5. class bar {   
  6.     public function process_a_foo(foo $foo) {   
  7.     // Some code   
  8.     }   
  9. }    
  10. $b = new bar();   
  11. $f = new foo();   
  12. $b->process_a_foo($f);   
  13. ?>  

可以看出,我们可以显性的在参数前指明一个对象的名称,PHP5 会识别出这个参数将会要是一个对象实例.

静态成员

静态成员和静态方法在面象对象编程的术语中被称作 “对象方法(class methods)” 和 “对象变量(class variables)”.
“对象方法” 在一个对象没有实例化前允许被调用.同样,“对象变量” 在一个对象没有实例化前可以被独立操作控制(不需要用一个对象的方法来控制).

例十一：对象方法和对象变量

PHP代码
  1. <?   
  2. class calculator {    
  3.     static public $pi = 3.14151692;   
  4.     static public function add($x,$y) {   
  5.         return $x + $y;    
  6.     }   
  7. }    
  8. $s = calculator::$pi;   
  9. $result = calculator::add(3,7);   
  10. print("$result");    
  11. ?>  
异常处理

异常处理是公认的处理程序错误的理想方法,在 Java 及 C++ 中都有这个概念,我们欣喜的看到,在 PHP5 已经加入了这方面的应用.你可以尝试使用 “try” 和 “catch” 来控制程序的错误.

例十二：异常处理

PHP代码
  1. <?   
  2. class foo {    
  3.     function divide($x,$y) {    
  4.         if($y==0) throw new Exception("cannot divide by zero");    
  5.         return $x/$y;    
  6.     }    
  7. }    
  8. $x = new foo();    
  9. try {    
  10.     $x->divide(3,0);    
  11. }   
  12. catch (Exception $e) {    
  13.     echo $e->getMessage();    
  14.     echo "n   
  15.     n";    
  16.     // Some catastrophic measure here    
  17. }    
  18. ?>  


上例中,我们使用了 “try” 来执行花括号中的语句,当有错误发生的时候,代码会把错误交给 “catch” 子句来处理,在 “catch” 子句中,你需要指明要把错误交给某个对象处理,这样做可以使代码结构看起来更清晰,因为现在我们可以把所有的错误信息交给一个对象来处理.

自定义错误处理

你可以很方便的用自定义的处理错误的代码来控制你的程序中的意外.你仅仅需要从异常类中派生出一个自己的错误控制类,在你自己的错误控制类中,你需要有一个构造函数和一个 getMessage 方法,以下是一个例子.

例十三：自定义错误处理

PHP代码
  1. <?   
  2. class WeirdProblem extends Exception {    
  3.     private $data;    
  4.     function WeirdProblem($data) {    
  5.         parent::exception();    
  6.         $this->data = $data;    
  7.     }    
  8.     function getMessage() {    
  9.         return $this->data . " caused a weird exception!";    
  10.     }    
  11. }    
  12. ?>  

现在我们可以使用 “throw new WeirdProblem($foo)” 来抛出一个错误句柄,如果错误在 “try” 的代码块中发生,PHP5 会自动把错误交给 “catch” 部分来处理.

名称空间

名称空间对类的分组或函数分组很有用.它可以把一些相关的类或函数给组合到一起,方便以后调用.

例十四：名称空间

PHP代码
  1. <?   
  2. namespace Math {    
  3.     class Complex {    
  4.         //...code...    
  5.         function __construct() {    
  6.         print（"hey"）;    
  7.         }    
  8.     }    
  9. }   
  10. $m = new Math::Complex();    
  11. ?>  

注意你需要在何种情况下使用名称空间,在实际运用中,你可能会需要声明两个或多个名称一样的对象来做不同的事情,那么你就可以把他们分别放到不同的名称空间中去（但接口是要相同的）.

责任编辑:semirock