PHP中实现面向对象编程

　　这篇文章介绍在PHP的面向对象编程（OOP）。我将演示如何用面向对象的概念编出较少的代码但更好的程序。祝大家好运。

　　面向对象编程的概念对每一个作者来说都有不同的看法，我提醒一下一个面向对象语言应有的东西：

　　　- 数据抽象和信息隐藏
　　　- 继承
　　　- 多态性

　　在PHP中使用类进行封装的办法：

 1 <? php
 2 class  Something { 
 3 //  In OOP classes are usually named starting with a cap letter. 
 4 var   $x ; 
 5
 6 function  setX( $v ) { 
 7 //  Methods start in lowercase then use lowercase to seprate 
 8 // words in the method name example getValueOfArea() 
 9 $this - ＞x = $v ; 
10 } 
11
12 function  getX() { 
13 return   $this - ＞x; 
14 } 
15 } 
16
17 ? ＞

当然你可以用你自己的办法，但有一个标准总是好的。

　　PHP中类的数据成员使用 "var" 定义，数据成员是没有类型直到被赋值。一个数据成员可能是一个 integer、数组、联合数组(associative array)或甚至对象(object). 方法在类里定义成函数，在方法里存取数据成员，你必须使用$this-＞name 这样的办法，否则对方法来说是一个函数的局部变量。

　　使用 new 来创建一个对象

1 $obj   =   new  Something; 

然后使用成员函数

1 $obj - ＞setX( 5 ); 
2 $see   =   $obj - ＞getX();  
3

　　setX 成员函数将 5 赋给对象(而不是类）obj 中成员变量, 然后 getX 返回值 5.

　　你也可以用对象引用来存取成员变量，例如：$obj-＞x=6; 然而，这不一种好的面向对象编程的方法。我坚持你应使用成员函数来设置成员变量的值和通过成员函数来读取成员变量。如果你认为成员变量是不可存取的除了使用成员函数的办法，你将成为一个好的面向对象程序员。 但不幸的是PHP本身没有办法声明一个变量是私有的，所以允许糟糕的代码存在。

　　在 PHP 中继承使用 extend 来声明。 

 1 <? php
 2 class  Another  extends  Something { 
 3 　 var   $y ; 
 4 　 function  setY( $v ) { 
 5 　　 //  Methods start in lowercase then use lowercase to seperate 
 6 　　// words in the method name example getValueOfArea() 
 7 　　 $this - ＞y = $v ; 
 8 　} 
 9
10 　 function  getY() { 
11 　　 return   $this - ＞y; 
12 　} 
13 } 
14
15 ? ＞  
16

　　这样类 "Another" 的对象拥有父类的所用成员变量及方法函数，再加上自己的成员变量及成员函数。如：

1 $obj2 = new  Another; 
2 $obj2 - ＞setX( 6 ); 
3 $obj2 - ＞setY( 7 );  
4

　　多重继承不被支持，所以你不能让一个类继承多个类。

　　在继承类中你可以重新定义来重定义方法，如果我们在 "Another" 重新定义 getX，那么我们不再能存取 "Something" 中的成员函数 getX. 同样，如果我们在继承类中声明一个和父类同名的成员变量，那么继承类的变量将隐藏父类的同名变量。

　　你可以定义一个类的构造函数, 构造函数是和类同名的成员函数，在你创建类的对象时被调用。

 1 <? php
 2 class  Something { 
 3 　 var   $x ; 
 4
 5 　 function  Something( $y ) { 
 6 　　 $this - ＞x = $y ; 
 7 　} 
 8
 9 　 function  setX( $v ) { 
10 　　 $this - ＞x = $v ; 
11 　} 
12
13 　 function  getX() { 
14 　　 return   $this - ＞x; 
15 　} 
16 } 
17
18 ? ＞ 
19

所以可以用如下方法创建对象：

1 $obj = new  Something( 6 ); 

　　构造函数自动赋值 5 给成员变量 x, 构造函数和成员函数都是普通的PHP函数,所以你可以使用缺省参数。

1 function  Something( $x = " 3 " , $y = " 5 " ) 

然后:

1 $obj = new  Something();  //  x=3 and y=5 
2 $obj = new  Something( 8 );  //  x=8 and y=5 
3 $obj = new  Something( 8 , 9 );  //  x=8 and y=9  
4

　　缺省参数的定义方法和 C++ 一样，因此你不能传一个值给 Y 但让 X 取缺省值，实参的传递是从左到右，当没有更多的实参时函数将使用缺省参数。

　　只有当继承类的构造函数被调用后，继承类的对象才被创建，父类的构造函数没有被调用，这是PHP不同其他面向对象语言的特点，因为构造函数调用链是面向对象编程的特点。如果你想调用基类的构造函数，你不得不在继承类的构造函数中显式调用它。这样它能工作是因为在继承类中父类的方法全部可用。 

1 function  Another() { 
2 $this - ＞y = 5 ; 
3 $this - ＞Something();  // explicit call to base class constructor. 
4 } 
5
6 ? ＞ 
7

　　在面向对象编程中一种好的机制是使用抽象类，抽象类是一种不能实例化而是用来给继承类定义界面的类。设计师经常使用抽象类来强制程序员只能从特定的基类来继承，所以就能确定新类有所需的功能，但在PHP中没有标准的办法做到这一点，不过：

　　如果你在定义基类是需要这个特点，可以通过在构造函数中调用 "die"，这样你就可以确保它不能实例化，现在定义抽象类的函数并在每个函数中调用 "die",如果在继承类中程序员不想重定义而直接调用基类的函数，将会产生一个错误。

　　此外，你需要确信因为PHP没有类型，有些对象是从基类继承而来的继承类创建的，因此增加一个方法在基类来辨别类(返回 "一些标识")并验证这一点，当你收到一个对象作为参数派上用场。 但对于一个恶棍程序没用办法，因为他可以在继承类中重定义此函数，通常这种办法只对懒惰的程序员奏效。当然，最好的办法是防止程序接触到基类的代码只提供界面。

　　重载在PHP中不被支持。在面向对象编程中你可以通过定义不同参数种类和多少来重载一个同名成员函数。PHP是一种松散的类型语言，所以参数类型重载是没有用的，同样参数个数不同的办法重载也不能工作。

　　有时候，在面向对象编程中重载构造函数很有用，所以你能以不同的方式创建不同的对象(通过传递不同的参数个数)。一个小巧门可以做到这一点：

 1 class  Myclass { 
 2 function  Myclass() { 
 3 $name = " Myclass " . func_num_args (); 
 4 $this - ＞ $name (); 
 5 // Note that $this-＞$name() is usually wrong but here 
 6 //$name is a string with the name of the method to call. 
 7 } 
 8
 9 function  Myclass1( $x ) { 
10 code; 
11 } 
12 function  Myclass2( $x , $y ) { 
13 code; 
14 } 
15 } 
16
17 ? ＞  
18

通过这种办法可以部分达到重载的目的。

1 $obj1 = new  Myclass( 1 );  // Will call Myclass1 
2 $obj2 = new  Myclass( 1 , 2 );  // Will call Myclass2 

　　多态性

　　多态性被定义为当在运行时刻一个对象作为参数传递时，对象能决定调用那个方法的能力。例如，用一个类定义了方法 "draw"，继承类重定义 "draw" 的行为来画圆或正方形，这样你就有一个参数为 x 的函数，在函数里可以调用$x-＞draw(). 如果支持多态性，那么 "draw" 方法的调用就取决于对象 x 的类型。多态性在PHP中很自然被支持（想一想这种情况在C++编译器中如果编译，那一个方法被调用？然而你不知道对象的类型是什么，当然现在不是这种情况）。

　　幸好PHP支持多态性。

 1 function  niceDrawing( $x ) { 
 2 // Supose this is a method of the class Board. 
 3 $x - ＞draw(); 
 4 } 
 5
 6 $obj = new  Circle( 3 , 187 ); 
 7 $obj2 = new  Rectangle( 4 , 5 ); 
 8
 9 $board - ＞niceDrawing( $obj );  // will call the draw method of Circle. 
10 $board - ＞niceDrawing( $obj2 );  // will call the draw method of Rectangle. 
11
12 ? ＞

　　 PHP的面向对象编程

　　纯对象论者认为PHP不是真正的面向对象语言，这是对的。PHP是一种混合语言，你可以用面向对象或传统结构编程的方法来使用它。对于大型工程，然而你可能或需要使用纯面向对象方法来定义类，并在你的工程中只使用对象和类。越来越大的工程通过使用面向对象的方法会获得益处，面向对象工程非常容易维持，容易理解并且重用。这是软件工程的基本。使用这些概念在网站设计中是未来成功的关键。

　　PHP中的高级面向对象技术

　　在回顾面向对象的基本概念之后，我将介绍一些更高级的技术。

　　 串行化

　　PHP并不支持持久性对象，在面向对象语言中持久性对象是一些经过应用程序多次调用仍然保持其状态和功能的对象，这意味着有一种能保存对象到文件或数据库中然后重新装载对象。这种机制称之为串行化。PHP 有一个串行化函数，可以在对象中调用，串行化函数返回一个字符串代表这个对象。然后串行化函数保存的是成员数据而不是成员函数。

　　在PHP4中，如果你串行化一个对象到字符串 $s, 然后删除此对象，再反串行化对象到 $obj， 你仍然可以调用对象的方法函数。但我不推荐这种方法，这因为(a)这种功能在将来不一定支持(b)这导致一种幻象，如果你保存串行化对象到磁盘并退出程序。将来重新运行此脚本时你不能反串行化此对象并希望对象的方法函数仍有效，因为串行化出来的字符串并没有表示任何成员函数。最后，串行化保存对象的成员变量在PHP中非常有用，仅仅如此. （你可以串行化联合数组和数组到磁盘里）。

　　例子:

 1 $obj = new  Classfoo(); 
 2 $str = serialize ( $obj ); 
 3 //  Save $str to disk 
 4
 5 //some months later 
 6
 7 //Load str from disk 
 8 $obj2 = unserialize ( $str ) 
 9
10 ? ＞ 
11

　　上例中，你可以恢复成员变量而没有成员函数(根据文档)。这导致 $obj2-＞x 是唯一的方法来存取成员变量（因为没有成员函数）。

　　这里还有一些方法解决这个问题，但我留下给你因为它会搞脏这个干净的文档。

　　我希望PHP将来能全面支持串行化。

　　 使用类来操纵保存的数据

　　PHP和面向对象编程中一个比较好的地方是你很容易定义类来操纵某些东西，并且当需要时调用合适的类。假设有一个HTML文件，你需要通过选择产品的ID号来选择一个产品，你的数据保存在数据库中，而你想显示产品的信息，如价格等等。你有不同种类的产品，同样的动作对不同的产品有不同的含义。

　　例如，显示一个声音意味着播放它，而对其他产品来说可能是显示一个存储在数据库的图片。你可以用面向对象编程和PHP来达到，代码少但更好。


　　定义一个类，定义类应该有的方法，然后通过继承来定义每一种产品的类(SoundItem类, ViewableItem类，等等)，重定义每个产品类的方法，使它们如你所需。根据你保存在数据库中的表的产品类型字段来给每一种产品类型定义一个类，一个典型的产品表应有字段(id, 类型, 价格, 描述,等等)。

　　在脚本中你从数据库的表中获取类型信息，然后实例化相应类的对象：

1 $obj = new   $type (); 
2 $obj - ＞action(); 
3
4 ? ＞ 
5

　　这是PHP比较的特性，你可以调用 $obj 的显示方法或其他方法而不用去管对象的类型。通过这种技术，当你增加一种新类型的对象时，你不需要去修改脚本。这个方法有点威力，就是定义所有对象应有的方法而不管它的类型，然后在不同的类中以不同的方式来实现，这样就可以在脚本中对不同的类型对象使用他们，再没有 if, 没有两个程序员在同一个文件里，永远快乐。你相信编程是这样快乐不？维护代价小并且可重用？

　　如果你带领一组程序员，最好的方法是划分任务，每人可以对某种类和对象负责。国际化可以用同样的技术解决，使合适的类对应使用者选择的不同的语言等等。

　　 复制和克隆

　　当你创建一个对象 $obj, 你可以使用 $obj2 = $obj 来拷贝一个对象，新的对象是 $obj 的一个拷贝(不是引用)，所以在赋值完新对象有 $obj 同新的状态。有时候你不想这样，只想创建和 obj 同样的新对象，调用新对象的构造函数如同你曾使用过 new 命令。这可以通过PHP的串行化和使用基类并且其他类必须从基类继承来达到。

　　 进行危险的地带

　　当你串行化一个对象，你得到一个有特定格式的字符串，如果你有好奇心，可能你会探寻其中的秘密，字符串中有一个东西就是类的名字，你可以解开它：

1 $herring = serialize ( $obj ); 
2 $vec = explode ( :, $herring ); 
3 $nam = str_replace ( " \ "" ,\,$vec[2]); 
4
5 ?＞

　　假设你创建一个类 "Universe" 并且使所有类都从 "Universe" 继承而来，你可以在 "Universe" 定义一个克隆的方法:

 1 class  Universe { 
 2 　 function   clone () { 
 3 　　 $herring = serialize ( $this ); 
 4 　　 $vec = explode ( :, $herring ); 
 5 　　 $nam = str_replace ( " \ "" ,\,$vec[2]); 
 6 　　$ret=new $nam; 
 7 　　return $ret; 
 8 　} 
 9 } 
10
11 //Then: 
12
13 $obj=new Something(); 
14 //Something extends Universe !! 
15 $other=$obj-＞clone(); 
16
17 ?＞

　　你所得的是类 Something 的新对象如同使用 new 一样，并且构造函数被调用等等。我不知道这对你是不是有用，这是一个很好的实践，Universe 类知道它的继承类的名字。对你来说，唯一的限制是你的想象力！！！

　　注意：我使用的是PHP4， 文章里有些东西可能不适合PHP3。

转载于:https://www.cnblogs.com/savageworld/archive/2007/06/14/783886.html