PHP常用设计模式及面向对象设计(笔记和学习)

 

 

建造者模式

<?php          
               //一个导演类，传入一个 不同Builder类(具体怎么制造由此决定)，来创建一辆车
               // 定义Build接口
               //不同车辆Build类,根据不同来建造
               //和工厂差不多，要稍复杂一点
                
class Director
{	
	public function build($build){
		$build->createVehicle();
		$build->setDoor();
		$build->setWhell();
		$build->setEnginer();

		return $build->getVehicle();
	}
}

class Engineer{

}
class Whell{

}
class Door{

}

Interface Builder
{
	public function createVehicle();
	public function setDoor();
	public function setWhell();
	public function setEnginer();
	public function getVehicle();
}

class CarBuild implements Builder{
	private $car;
	public function createVehicle(){
		$this->car=new Car();
		echo "安装了一个汽车车架<br />";
	}
	public function setDoor(){
		$this->car->setPart('door1',new Door());
		$this->car->setPart('door2',new Door());
		$this->car->setPart('door3',new Door());
		$this->car->setPart('door4',new Door());
		echo "汽车安装了四个窗户<br />";
	}
	public function setWhell(){
		$this->car->setPart('whell1',new Whell());
		$this->car->setPart('whell2',new Whell());
		$this->car->setPart('whell3',new Whell());
		$this->car->setPart('whell4',new Whell());
		echo "汽车安装了四个轮子<br />";
	}
	public function setEnginer(){
		$this->car->setPart('engineer1',new Engineer());
		echo "汽车安装了一个超级引擎<br />";
	}
	public function getVehicle(){
		return $this->car;
	}

}
abstract class Vehicle
{
	private $data=array();
	public function setPart($key,$part)
	{
		$this->data[$key]=$part;
	}
	abstract public function startRun();
}
class Car extends Vehicle
{
	public function startRun(){
		echo "汽车开始运行<br />";
	}
}

class BikeBuilder implements Builder
{
	private $bike;
	public function createVehicle(){
		$this->bike=new Bike();
		echo "自行车放了一个车架<br />";
	}
	public function setDoor()
	{

	}
	public function setWhell(){
		$this->bike->setPart('whell1',new Whell());
		$this->bike->setPart('whell2',new Whell());
		echo "自行车安装了连个车轱辘<br />";
	}
	public function setEnginer(){
		$this->bike->setPart('engineer1',new Engineer());
		echo "自行车引擎<br />";
	}
	public function getVehicle(){
		return $this->bike;
	}
}

class Bike extends Vehicle{
	public function startRun(){
		echo "自行车运行起来了<br />";
	}
}

$carBuild=new CarBuild();
$car=(new Director())->build($carBuild);
$car->startRun();

echo "------------------------<br />";

$bikeBuild=new BikeBuilder();
$bike=(new Director())->build($bikeBuild);
$bike->startRun();

共享数据池

<?php 

class WorkerPool implements Countable
{
	private $occupiedWorks=array();
	private $freeWorks=array();

	public function get()
	{
		if(count($this->freeWorks)==0){
			$worker=new StringReverseWorker();
		}else{
			$worker=array_pop($this->freeWorks);
		}
		$this->occupiedWorks[spl_object_hash($worker)]=$worker;
		return $worker;
	}

	public function dispose($worker){

		$key = spl_object_hash($worker);

		if(isset($this->occupiedWorks[$key])){
		     unset($this->freeWorks[$key]);	
		}
		$this->freeWorks[$key]=$worker;
	}


	public function count(){      //必须继承此方法
		return count($this->occupiedWorks)+count($this->freeWorks);
	}
}
class StringReverseWorker
{
    private  $createdAt;

    public function __construct()
    {
        $this->createdAt = new DateTime();
    }

    public function run(string $text)
    {
        return strrev($text);
    }
}
$workerPool=new WorkerPool();

$work1=$workerPool->get();
// $work2=$workerPool->get();
$workerPool->dispose($work1);
$work2=$workerPool->get();
var_dump($work1==$work2);

$count=$workerPool->count();
var_dump($count);

 

 

原型模式

<?php 

class Student{                     //快速复制较大的对象，减少时间

	public $name=null;
	public $socre="99";

	public function __construct($name){
		$this->name=$name;
	}
	public function getScore(){
		echo $this->name."的分数是:".$this->socre."<br />";
	}
}
	$stu=new Student("jianhanke");
	$stu->getScore();

	$stu2=clone $stu;
	$stu2->getScore();

 

 

单例模式

<?php 


class Person{                             //运行过程中，始终只能有一个实例

	private static $instance=null;                 //实现定义好

	private  function __clone(){}                

	private  function  __construct(){}

	public static function getInstance(){    
		if(self::$instance==null){
			self::$instance=new self();             //只能子啊内部实例化
		} 
			return self::$instance;
	}

}

简单工厂模式

<?php
abstract class Operation{                // 定义接口,所有实现类都是同一个方法名

	abstract public function getValue($num1,$num2);
}

class OperationAdd extends Operation{

	public function getValue($num1,$num2){
		return $num1+$num2;
	}
}

class OperationSub extends Operation{

	public function getValue($num1,$num2){
		return $num1-$num2;
	}

}

class Factory{       /根据参数创造不同类,但不同类都有同一个方法

	public static function createObj($operate){  
		echo "$operate";
		switch ($operate) {
			case '+':
				return new OperationAdd();
				break;
			case '-':
				return new OperationSub();
				break;
			default :
				return null;
		}
	}
}

面向对象，

抽象类

abstract class Animal{               //定义抽象类,抽象类不能实例化,有抽象方法的必须是抽象类  

	public function  shout(){         // 普通方法  
		echo "所有动物都要吃饭";
	}

	abstract  public function eat();  //抽象方法,不能包含方法体(出现{}就会出错)
}

class Dog extends Animal{

	public function eat(){
		echo "小狗要吃饭";
	}	
}

$dog=new Dog();
$dog->shout();                           //两个方法都会有
$dog->eat();

接口

Interface Person{                    //定义接口
 
	const score="99";                 //接口只能定义 常量
	public function getSocre();        //接口方法 默认都是 abstract
    public function getName();           //子类必须继承，否则出错

}
class Student implements Person{

	public function getSocre(){
		echo self::score;
	}
}

$stu=new Student();
$stu->getSocre();