PHP中简单工厂模式的学习笔记

工厂模式在php中是什么模式呢，对于这个我们对于php初学者可能不会明白了，下面小编给各位整理一个关于PHP中简单工厂模式实例讲解了，其实中也整理了一些其它的实例来进行补充了。

简单工厂模式：

①抽象基类：类中定义抽象一些方法，用以在子类中实现
②继承自抽象基类的子类：实现基类中的抽象方法
③工厂类：用以实例化对象

使用工厂模式的目的或目标？

工厂模式的最大优点在于创建对象上面，就是把创建对象的过程封装起来，这样随时可以产生一个新的对象。
减少代码进行复制粘帖，耦合关系重，牵一发动其他部分代码。

通俗的说，以前创建一个对象要使用new，现在把这个过程封装起来了。
假设不使用工厂模式：那么很多地方调用类a，代码就会这样子创建一个实例：new a(),假设某天需要把a类的名称修改，意味着很多调用的代码都要修改。

工厂模式的优点就在创建对象上。

工厂模式的优点就在创建对象上。建立一个工厂（一个函数或一个类方法）来制造新的对象,它的任务就是把对象的创建过程都封装起来，
创建对象不是使用new的形式了。而是定义一个方法，用于创建对象实例。

每个类可能会需要连接数据库。那么就将连接数据库封装在一个类中。以后在其他类中通过类名:

为什么引入抽象的概念？

想一想，在现实生活中，当我们无法确定某个具体的东西的时候，往往把一类东西归于抽象类别。
工厂方法：
比如你的工厂叫做“香烟工厂”，那么可以有“七匹狼工厂”“中华工厂”等，但是，这个工厂只生厂一种商品：香烟；
抽象工厂：无法描述它到底生产什么产品，它生产很多类型的产品(所以抽象工厂就会生成子工厂)。
你的工厂是综合型的，是生产“一系列”产品，而不是“一个”，比如：生产“香烟”，还有“啤酒”等。然后它也可以有派生出来的具体的工厂，但这些工厂都是生产这一系列产品，只是可能因为地域不一样，为了适应当地人口味，味道也不太一样。
工厂模式：理解成只生成一种产品的工厂。比如生产香烟的。
工厂方法：工厂的一种产品生产线 。比如键盘的生成过程。

 

别人会反驳：吃饱了没事干，一定要修改类名称呢？这个说不定。一般都不会去修改类名称。

 

其实工厂模式有很多变体，抓住精髓才是关键：只要是可以根据不同的参数生成不同的类实例，那么就符合工厂模式的设计思想。

这样子让我联想到框架中经常会有负责生成具体类实例的方法供调用。

看完文章再回头来看下这张图，效果会比较好

 

采用封装方式

<?php
    class Calc{
        /**
         * 计算结果
         *
         * @param int|float $num1
         * @param int|float $num2
         * @param string $operator
         * @return int|float
         */
        public function calculate($num1,$num2,$operator){
            try {
                $result=0;
                switch ($operator){
                    case '+':
                        $result= $num1+$num2;
                        break;
                    case '-':
                        $result= $num1-$num2;
                        break;
                    case '*':
                        $result= $num1*$num2;
                        break;
                    case '/':
                        if ($num2==0) {
                            throw new Exception("除数不能为0");
                        }
                        $result= $num1/$num2;
                        break;
                }
            return $result;
            }catch (Exception $e){
                echo "您输入有误:".$e->getMessage();
            }
        }
    }
    $test=new Calc();
//    echo $test->calculate(2,3,'+');//打印:5
    echo $test->calculate(5,0,'/');//打印:您输入有误:除数不能为0
?>
 

优点：以上代码使用了面向对象的封装特性，只要有了include这个类，其他页面就可以随便使用了

缺点：无法灵活的扩展和维护

比如：想要增加一个“求余”运算，需要在switch语句块中添加一个分支语句，代码需要做如下改动

<?php
    class Calc{
        public function calculate($num1,$num2,$operator){
            try {
                $result=0;
                switch ($operator){
                    //......省略......
                    case '%':
                        $result= $num1%$num2;
                        break;
                    //......省略......
                }
            }catch (Exception $e){
                echo "您输入有误:".$e->getMessage();
            }
        }
    }
?>
代码分析：用以上方法实现给计算器添加新的功能运算有以下几个缺点

①需要改动原有的代码块，可能会在为了“添加新功能”而改动原有代码的时候，不小心将原有的代码改错了
②如果要添加的功能很多，比如：‘乘方’，‘开方’，‘对数’，‘三角函数’，‘统计’，或者添加一些程序员专用的计算功能，比如：And, Or, Not, Xor，这样就需要在switch语句中添加N个分支语句。想象下，一个计算功能的函数如果有二三十个case分支语句，代码将超过一屏，不仅令代码的可读性大大降低，关键是，为了添加小功能，还得让其余不相关都参与解释，这令程序的执行效率大大降低

解决途径：采用OOP的继承和多态思想

 <?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 OperationMul extends Operation {
         public function getValue($num1,$num2){
             return $num1*$num2;
         }
     }
     /**
      * 除法类
      */
     class OperationDiv extends Operation {
         public function getValue($num1,$num2){
             try {
                 if ($num2==0){
                     throw new Exception("除数不能为0");
                 }else {
                     return $num1/$num2;
                 }
             }catch (Exception $e){
                 echo "错误信息：".$e->getMessage();
             }
         }
     }
 ?>
 

这里采用了面向对象的继承特性，首先声明一个虚拟基类，在基类中指定子类务必实现的方法（getValue()）

分析：通过采用面向对象的继承特性，我们可以很容易就能对原有程序进行扩展，比如:‘乘方’，‘开方’，‘对数’，‘三角函数’，‘统计’等等。

<?php
    /**
     * 求余类（remainder）
     *
     */
    class OperationRem extends Operation {
        public function getValue($num1,$num2){
            return $num1%$num12;
        }
    }
?>
 

我们只需要另外写一个类（该类继承虚拟基类）,在类中完成相应的功能（比如：求乘方的运算）,而且大大的降低了耦合度，方便日后的维护及扩展

现在还有一个问题未解决,就是如何让程序根据用户输入的操作符实例化相应的对象呢？
解决办法：使用一个单独的类来实现实例化的过程，这个类就是工厂
代码如下:

<?php
    /**
     * 工程类，主要用来创建对象
     * 功能：根据输入的运算符号，工厂就能实例化出合适的对象
     *
     */
    class Factory{
        public static function createObj($operate){
            switch ($operate){
                case '+':
                    return new OperationAdd();
                    break;
                case '-':
                    return new OperationSub();
                    break;
                case '*':
                    return new OperationSub();
                    break;
                case '/':
                    return new OperationDiv();
                    break;
            }
        }
    }
    $test=Factory::createObj('/');
    $result=$test->getValue(23,0);
    echo $result;
?>
 

再扩展一些

比如如何根据玩家输入的内容（尽管可以转化为其他字符串），来确定要制造的兵种，玩家不会输入代码：new Marine()。
和星际一样，PHP也没有终极兵种，如果类和接口是兵种的话，那么设计模式就是你的战术和控制，它可以让你靠各种兵种的搭配获胜。
待解决的问题：在人族的兵营，我们靠相应玩家的输入来动态确定要造的兵种，假设是机枪兵和火焰兵。

思路：动态的根据传递的数据，新建相应的类的对象。
简单工厂模式示例：
我们把机枪兵类的代码放入一个文件，Marine.php，它的代码如下：

<?php
class Marine {
//机枪兵攻击的方法
public function attack()
{
echo 'Marine attack';
}
}
?>
 

我们把火焰兵类的代码放入一个文件，Firebat.php，它的代码如下：

<?php
class Firebat {
//火焰兵攻击的方法
public function attack()
{
echo 'Firebat attack';
}
}
?>
 

主文件中的内容如下：

<?php
//兵种制造器的类
class BarracksCreator {
//制造兵种的方法
public create($createWhat)
{
//根据输入的参数，动态的把需要的类的定义文件载入
require_once($createWhat.'.php');
//根据输入的参数，动态的返回需要的类的对象
return new $createWhat;
}
}

//新建一个兵种制造器对象
$creator = new BarracksCreator()；

//靠接收参数制造一个火焰兵对象
$troop1 = $creator->create('Marine');
$troop1->attack();

//靠接收参数制造一个机枪兵对象
$troop2 = $creator->create('Firebat');
$troop2->attack();
?>
 

用途总结：简单工厂模式可以将新建对象的任务进行封装，一旦需要增加新的返回类，只要修改负责新建对象的那部分代码。
实现总结：需要一个自动根据参数返回新建对象的工厂，比如上面兵种制造器BarracksCreator，使用的时候只需要将参数传递给他的生产方法create()，无需考虑具体的生产细节。

对于php反射类我相信许多作php开发的朋友都不知道是一个什么东西了，但如果去大公司这些东西还是必须要知道了，今天我们来看篇关于php反射类 ReflectionClass使用例子，希望例子能够帮助到各位。

反射类是一个类的映射

  namespace News;
  class News{
      public $newsid; 
      public function index(){
           ……
      }
  }
正常我们实例化一个类是这样： $News = new News\News();
如果我们要实例化News类的反射类是这样：$News = new \ReflectionClass(‘News\News’);

那么通过反射类实例化的类和普通类有什么不同呢？

通过反射类实例化的类我们可以获取这个这个类的详细信息,可以对类进行分析

例如：$News->getProperties()可以获取这个类的所有属性与方法。

 array (size=1)
      0 => & object(ReflectionProperty)[2]
        public 'name' => string 'newsid' (length=6)
        public 'class' => string 'News' (length=4)
getShortName() getName() getNamespaceName() 分别可以获得类名，带命名空间的类名，和命名空间的名称 News News\News News

ReflectionClass的一个应用就是在父类中获取子类的名称，从而针对不同的子类做不同的处理：

    $reflection = new \ReflectionClass($this);
    $class_name = $reflection->getShortName();
    // check key
    if (!key_exists($class_name, $this->configs)) {
        return true;
    }
    // params
    $params = $this->configs[$class_name];

    return $this->_handle($params);
反射类的使用应该可以相当灵活，还有相当多的其他用途待发掘。

本文章来为各位整理一篇关于　php 建造者生成器模式学习笔记，希望这篇文章能够帮助到各位朋友哦，有兴趣的朋友可以进来看看的哦。

适用场景：

1、 需要生成的产品对象有复杂的内部结构。
2、 需要生成的产品对象的属性相互依赖，生成器模式可以强迫生成顺序。
3、 在对象创建过程中会使用到系统中的一些其它对象，这些对象在产品对象的创建过程中不易得到。

使用效果：

1、 生成器模式的使用使得产品的内部表象可以独立的变化。使用生成器模式可以使客户端不必知道产品内部组成的细节。
2、 每一个Builder都相对独立，而与其它的Builder无关。
3、 模式所建造的最终产品更易于控制。

<?php
/**
* Created by PhpStorm.
*/
 
/**具体产品角色 车
* Class Car
*/
class Car
{
public $_head;
public $_engine;//引擎
public $_tyre;//轮胎
 
function show()
{
echo "车头的颜色:{$this->_head}<br/>";
echo "引擎的品牌:{$this->_engine}<br/>";
echo "轮胎的品牌:{$this->_tyre}<br/>";
}
}
 
/**抽象车的建造者(生成器)
* Class CarBuilder
*/
abstract class CarBuilder
{
protected $_car;
 
function __construct()
{
$this->_car=new Car();
}
 
abstract function BuildHead();
abstract function BuildEngine();
abstract function BuildTyre();
abstract function GetCar();
}
 
/**具体车的建造者(生成器) 宝马
* Class BMW
*/
class BMW extends CarBuilder
{
 
function BuildHead()
{
// TODO: Implement BuilderHead() method.
$this->_car->_head="Black";
}
 
function BuildEngine()
{
// TODO: Implement BuildEngine() method.
$this->_car->_engine="BMW";
}
 
function BuildTyre()
{
// TODO: Implement BuildTyre() method.
$this->_car->_tyre="BMW";
}
 
function GetCar()
{
// TODO: Implement GetCar() method.
return $this->_car;
}
}
 
/**别克
* Class BuickBird
*/
class BuickBird extends CarBuilder
{
 
function BuildHead()
{
// TODO: Implement BuildHead() method.
$this->_car->_head="Red";
}
 
function BuildEngine()
{
// TODO: Implement BuildEngine() BMmethod.
$this->_car->_engine="Buick";//
}
 
function BuildTyre()
{
// TODO: Implement BuildTyre() method.
$this->_car->_tyre="Buick";
}
 
function GetCar()
{
// TODO: Implement GetCar() method.
return $this->_car;
}
}
 
/**指挥者
* Class Director
*/
class Director
{
/**
* @param $_builder 建造者
* @return mixed 产品类：车
*/
function Construct($_builder)
{
$_builder->BuildHead();
$_builder->BuildEngine();
$_builder->BuildTyre();
return $_builder->GetCar();
}
}

适配器模式许多和php程序员都没有碰到关于适配器的应用了，这里小编整理了两个关于适配器的使用例子，下面我们就一起来看看吧，希望各位有帮助。

【目的】：将一个类的接口转换成客户希望的另外一个接口，Adapter模式使得原来由于接口不兼容而不能一起工作的那此类可以一起工作

【主要角色】

目标(Target)角色：定义客户端使用的与特定领域相关的接口，这也就是我们所期待得到的
源(Adaptee)角色：需要进行适配的接口
适配器(Adapter)角色：对Adaptee的接口与Target接口进行适配；适配器是本模式的核心，适配器把源接口转换成目标接口，此角色为具体类
【适用性】
1、你想使用一个已经存在的类，而它的接口不符合你的需求
2、你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类协同工作
3、你想使用一个已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口（仅限于对象适配器）

//目标角色 
interface Target { 
    public function simpleMethod1(); 
    public function simpleMethod2(); 
} 
 
//源角色 
class Adaptee { 
     
    public function simpleMethod1(){ 
        echo 'Adapter simpleMethod1'."<br>"; 
    } 
} 
 
//类适配器角色 
class Adapter implements Target { 
    private $adaptee; 
     
     
    function __construct(Adaptee $adaptee) { 
        $this->adaptee = $adaptee;  
    } 
     
    //委派调用Adaptee的sampleMethod1方法 
    public function simpleMethod1(){ 
        echo $this->adaptee->simpleMethod1(); 
    } 
     
    public function simpleMethod2(){ 
        echo 'Adapter simpleMethod2'."<br>";    
    }  
     
} 
 
//客户端 
class Client { 
     
    public static function main() { 
        $adaptee = new Adaptee(); 
        $adapter = new Adapter($adaptee); 
        $adapter->simpleMethod1(); 
        $adapter->simpleMethod2();  
    } 
} 
 
Client::main();

 【运行结果】

Adapter simpleMethod1
Adapter simpleMethod2

例子2

生活中最常见到的足球换人机制

<?php
/**
* Created by PhpStorm.
*/
//-------------抽象接口---------------
/**抽象运动员
* Interface IPlayer
*/
interface SoccerPlayer
{
function Attack();
function Defense();
}
 
/**前锋
* Class Forward
*/
class Forward implements SoccerPlayer
{
 
function Attack()
{
echo "前锋攻击<br/>";
}
 
function Defense()
{
echo "前锋防御<br/>";
}
}
 
/**中锋
* Class Center
*/
class Center implements SoccerPlayer
{
 
function Attack()
{
echo "中锋攻击<br/>";
}
 
function Defense()
{
echo "中锋防御<br/>";
}
}
 
//--------------待适配对象-----------
/**梅西 刚进入罢赛的运动员
* Class Yaoming
*/
class Messi
{
function 进攻()
{
echo "梅西进攻<br/>";
}
 
function 防御()
{
echo "梅西防御<br/>";
}
}
 
//------------适配器--------------
/**适配器
* Class Adapter
*/
class Adapter implements SoccerPlayer
{
private $_player;
 
function __construct()
{
$this->_player=new Messi();
}
 
function Attack()
{
$this->_player->进攻();
}
 
function Defense()
{
$this->_player->防御();
}
}

测试如下

$player1=new Forward();
 
echo "前锋上场:<br/>";
$player1->Attack();
$player1->Defense();
 
echo "<hr/><br/>";
 
echo "梅西上场:<br/>";
$Messi=new Adapter();
$Messi->Attack();
$Messi->Defense();