面向对象设计模式学习（一）

面向对象应该是属于一种工程思想，并不是某种语言带来的东西。所以用UML图结合设计模式，能方便分析系统，写出良好的代码。刚好碰上软考，之前没学完的设计模式，趁着一下子搞完它。

创建型设计模式：

1.工厂模式：

<?php
   //工厂模式

   //可以定义一个专门的创建接口，里边存放一个工厂创建实例方法，然后用一个工厂类实现接口，当然也可以省掉这一步

   class Factory{

   		public function create($sysName){

   			switch ($sysName) {
   				case 'Mac':
   					return new MacSys($sysName);
   					break;
   				
   				case 'Linux':
   					return new LinuxSys($sysName);
   					break;

   				case 'Win':
   					return new WinSys($sysName);
   					break;
   			
   			}

   		}

   }


   abstract class System{

   		public $is_who;
   		public function __construct($sysName){

   			print_r($this->is_who=$sysName);
   		}
   		
   }

   class LinuxSys extends System{
   		
   		public function __construct($sysName){

   			print_r($this->is_who=$sysName);
   		}

   }

   class MacSys extends System{
   		public function __construct($sysName){

   			print_r($this->is_who=$sysName);
   		}


   }

   class WinSys extends System{
   		public function __construct($sysName){

   			print_r($this->is_who=$sysName);
   		}


   }

   $Factory=new Factory;

   $win=$Factory->create('Linux');


?>

2.建造者模式：

<?php
//建造者模式

//这个设计模式就好比产品经理指挥程序员干活，产品经理不关心功能的实现只要程序员能做出来，而程序者要依赖具体的产品事物特征来把事物开发出来。

//这个建造产品的过程算法代码要独立于组装代码部分，这就有了专门描述product算法的product类，专门负责组装的组装类,product只要写好固定算法，实现组装就由组装类内部搞定，对外部透明。


//以车为例
class product{

	public function CarDoor(){

		echo '添加车门'.'<br>';	
	}

	public function CarWindow(){

		echo '添加车窗';
	}

}

abstract class Builder{

	public abstract function createDoor();

	public abstract function createWindow();

}

class ConstructBuilder extends Builder{

	//php 不允许直接在类成员变量中new 一个实例
	
	private $car ; //对外隐蔽产品对象的建造环节

	public function __construct(){
		$this->car= new product();
	}

	public function createDoor(){

		$this->car->CarDoor();
	}

	public  function createWindow(){

		$this->car->CarWindow();
	}

}

 class director{

 	public function __construct(Builder $build){//php的多态和强类型语言一样

 		$build->createDoor();

 		$build->createWindow();
 	}

 }

 $build = new ConstructBuilder;

 $director=new director($build);

?>

3.抽象工厂模式：

<?php
//抽象工厂是工厂模式的进一步抽象，当不同种类型的对象要实例化时，就要用到不同种类的工厂

abstract class FactoryType{

	public function create($createType){}
}


class LinuxFactory extends FactoryType{

	public function create($createType){
			switch($createType){
				case 'Soft':
					return new LinuxSoft();
					break;
				case 'Sys':
					return new LinuxSys();
					break;
			}
	}

}

class WinFactory extends FactoryType{

	public function create($createType){
			switch($createType){
				case 'Soft': 
				return new WinSoft();
				break;
				case 'Sys': 
				return new WinSys();
				break;	
			}	
	}

}

class LinuxSys{public $me='is LinuxSys';}

class WinSys{public $me='is WinSys';}

class WinSoft{public $me='is WinSoft';}

class LinuxSoft{public $me='is LinuxSoft';}

$WinFactory=new WinFactory();

$WinSoft=$WinFactory->create('Soft');

print_r($WinSoft->me);

4.原型模式：

<?php
//原型模式，就是提高需要多次重复实例化对象的复用性，通过对象拷贝（复制）代替实例化，减少对象的实例化次数，因为实例化时，构造函数生成要花费时间导致降低系统性能。

//克隆的对象是属于浅拷贝，所以这里也会遇到一个问题，就是当成员是对象时会发生一个意想不到的事情，下面用代码实现

//这里以简历模板为例子


abstract class Prototype{
	protected $sex;
	protected $age;
	protected $work;
	protected $company;
	public abstract function create();//如果是抽象方法，就不要body以分号结尾。
	public abstract function copy();
}


//工作经历类
class experience{
	public $workplace;

	public function copy(){
		return clone $this;
	}
}
class ResumPrototype{
	
	private  $experience;

	//php不支持构造函数重载，采用类型判断生效
	//实现浅复制时，类中的对象成员能够是不同的引用型变量
	public function __construct($obj){
		
		if(!($obj instanceof experience))
		$this->experience=new experience;

		if($obj instanceof experience)
		$this->experience=$obj->copy();
	}



	public function create($sex,$age,$work,$company){
		$this->sex=$sex;
		$this->age=$age;
		$this->work=$work;
		$this->company=$company;
	}

	public function copy(){
		$obj = new ResumPrototype($this->experience);
		return $obj;//直接克隆本对象
	}

	public function add($workplace){
		
		$this->experience->workplace=$workplace;
		
	}

	public function display(){
		print_r($this->experience->workplace.'<br>');
	}
}


//创建原型模式
class createResum{

	public  function main(){

		$resum=new ResumPrototype('');

		//$resum->create('男','13','engneer','tengxun');
		$resum->add('sdsd');

		$r2=$resum->copy();

		//$r2->create('女','13','engneer','tengxun');
		$r2->add('gfhfhf');

		$r2->display();

		$resum->display();
		//这里由于克隆是浅复制的原因导致的工作经历对象还是指向同一个

	}

}
$a=new createResum();
$a->main();

?>

5.单例模式：

<?php
 
class MySql{
	//单例模式因为要防止多实例化，只能在类的内部实现。当然调用的时候也只能以类：：变量的形式，此时变量就是一个实例
	public static $Instance;

	public $str;
	
	private function  __construct(){}  // 不允许为外部实例化

	public static function GetInstance(){
		if(!(self::$Instance instanceof self)){  //instanceof关键字用来判定一个实例是否是某个类型
			self::$Instance=new self();
		}
		return self::$Instance;
	}

	private function __clone()
    {
        trigger_error('Clone is not allowed !');
    }

}
$one=MySql::GetInstance();//得到的是一个实例

$two=MySql::GetInstance();

$one->str='one';

//$two->str='two';

print_r($one->str);

print_r($two->str);

?>