1.工厂模式

工厂模式是一种类,它具有为您创建对象的某些方法,您可以使用工厂类创建对象,而不直接使用 new,这样,如果您想要更改所创建的对象类型,只需更改该工厂即可,使用该工厂的所有代码会自动更改。

主要作用是降低耦合度,代码如下:

1. abstract class Operation{ 
2.     abstract public  function getValue($num1,$num2); 
3.     public  function getAttr(){ 
4.         return 1; 
5.     } 
6. } 
7. class Add extends Operation{ 
8.     public function getValue($num1, $num2){         
9.         return $num1+$num2; 
10.     } 
11. } 
12. class Sub extends Operation{ 
13.     public function getValue($num1, $num2){ 
14.         return $num1-$num2; 
15.     } 
16. } 
17. class Factory{ 
18.     public static function CreateObj($operation){ 
19.          
20.         switch ($operation){ 
21.             case '+': return new Add(); 
22.             case '-': return new Sub(); 
23.         } 
24.          
25.     } 
26. } 
27. $Op=Factory::CreateObj('-'); 
28. echo $Op->getValue(3, 6); 

用在真正开发中一般当做数据库选择类。

实例2 显示使用工厂方法的一个示例,代码如下:

1. <?php 
2. interface IUser 
3. { 
4.   function getName(); 
5. } 
6. class User implements IUser 
7. { 
8.   public static function Load( $id )  
9.   { 
10.         return new User( $id ); 
11.   } 
12.   public static function Create( )  
13.   { 
14.         return new User( null ); 
15.   } 
16.   public function __construct( $id ) { } 
17.   public function getName() 
18.   { 
19.     return "Jack"; 
20.   } 
21. } 
22. $uo = User::Load( 1 ); 
23. echo( $uo->getName()."n" ); 
24. ?> 

这段代码要简单得多,它仅有一个接口 IUser 和一个实现此接口的 User 类,User 类有两个创建对象的静态方法.PHP里通过工厂模式提高效率

我们建立以下四个文件,代码如下:

1. //index.php 
2. <?php 
3. include_once("f.inc.php"); 
4. $f=new factory; 
5. $t1=&$f->create('T1'); 
6. echo $t1->getName(); 
7. echo $config; 
8. ?> 
9. //f.inc.php 
10. <?php 
11. class factory 
12. { 
13.  function factory() 
14.  { 
15.   $this->mClasses=array('T1'=>'t1.inc.php','T2'=>'t2.inc.php'); 
16.  } 
17.  function &create($class) 
18.  { 
19.   if (!class_exists($class)) 
20.   { 
21.    require_once($this->mClasses[$class]); 
22.   } 
23.   return new $class; 
24.  } 
25. } 
26. ?> 
27. //t1.inc.php 
28. <?php 
29. global $config; 
30. $config='surfchen'; 
31. class T1 
32. { 
33.  var $mName='name::T1'; 
34.  function getName() 
35.  { 
36.   return $this->mName; 
37.  } 
38. } 
39. ?> 
40. //t2.inc.php 
41. <?php 
42. class T2 
43. { 
44.  function T2() 
45.  { 
46.   echo 't2 is ok'; 
47.  } 
48. } 
49. ?> 

在index.php里，我们通过一个factory类来创建其他的类实例。

在factory里，保存有一个数组$this->mClasses，格式为array(“类名”=>”类文件路径”).

我们通过factory::create()来创建一个类实例的时候，在create()里，会首先检测类是否存在，如果不存在，就根据$this->mClasses把类对应的类文件包含进来。然后创建并返回一个该类的实例。

这样,我们只需要把factory类文件包含进执行的脚本（如index.php）中就可以了,大家可能还注意到了在t1.inc.php中的这两行代码,代码如下:global $config;$config='surfchen';

2.单例模式

简单来说,PHP单例模式就是一个功能用一个类来实现,并且在整个应用程序当中只有一个这个类的实例存在；

工厂模式强调的是面向对象的多态性,它可以把功能上的差异部分封装起来,对外实现共有的功能,比如说数据库的链接,由于数据库的不同,我们可能需要写不同的方法去实现数据库的链接,但作为应用程序来讲,它不需要了解数据库用的是MySQL还是Oracle,它只需要用query()这个方法去执行数据库的相应操作即可,这样就屏蔽了差异,使类更加健壮！代码如下:

1. class Mysql{ 
2.     public static $conn; 
3.     public static function getInstance(){ 
4.         if (!self::$conn){ 
5.             new self(); 
6.             return self::$conn; 
7.         }else { 
8.             return self::$conn; 
9.         } 
10.          
11.     } 
12.     private  function __construct(){     
13.         self::$conn=  "mysql_connect:";//    mysql_connect('','','')     
14.     } 
15.      
16.     public function __clone() 
17.     { 
18.         trigger_error("Only one connection"); 
19.     } 
20. } 
21. echo Mysql::getInstance(); 
22. echo Mysql::getInstance(); 

实际中用作数据库连接类和工厂模式一起使用,根据参数调用单例模式,可以提高资源使用效率.