设计模式-简单工厂

结构

1个工厂；
1个 interface 或者 abstract 产品父类；
多个实现 interface 或者继承 abstract 的具体产品类；

先整一个计算器  正常版的  不考虑扩展的

<?php 

namespace SimpleFactory;
/**
 *    计算器 
 *
 * 
 */
Class Bad {

    public function getResult($numA, $operate, $numB)
    {
        switch ($operate) {
            case '+':
                $result = $numA + $numB;
                break;
            case '-':
                $result = $numA - $numB;
                break;
            case '*':
                $result = $numA * $numB;
                break;
            case '/':
                if($numB != 0) {
                    $result = $numA / $numB;
                } else {
                    throw new Exception('除数不能为0', 1);
                }
                
                break;

            default:
                throw new Exception('暂不支持当前运算', 1);
        }
        return $result;
    }
}


$program = new Bad();
$result = $program->getResult(1, '+', 2);
var_dump($result);
 ?>

这里的逻辑判断流程和  实现代码各种混和   不利于扩展

来个简单工厂

先整个操作抽象类

<?php 

namespace SimpleFactory;

/**
 *
 * 操作抽象类
 */

abstract class Operate 
{
    /**
     * 运算符号左边的值
     */
    
    protected $numA = 0;

    /*运算符号右边的值*/

    protected $numB = 0;

    /**
     * 计算结果
     */
    abstract public function getResult();
    
    // 给 numA 赋值

    public function setNumA($number)
    {
        $this->numA = $number;
    }

    // 给 numB赋值
    public function setNumB($number)
    {
            $this->numB = $number;
    }
}


 ?>

把各个运算独立分装

<?php 

namespace SimpleFactory;


/**
 * 加法类
 */
class Add extends Operate
{
    
    public function getResult()
    {
        return $this->numA + $this->numB;
    }
}

 ?>

<?php 

namespace SimpleFactory;

/**
 * 减法类
 */
class Sub extends Operate
{
    
    public function getResult()
    {
        return $this->numA - $this->numB;
    }
}


 ?>

<?php 


namespace SimpleFactory;

/**
 * 乘法类
 */
class Mul extends Operate
{
    
    function getResult()
    {
        return $this->numA * $this->numB;
    }
}


 ?>

<?php 

namespace SimpleFactory;

/**
 * 除法类
 */
class Div extends Operate
{
    
    function get_Result()
    {
        if($this->numB == 0) {
            throw new Exception('除数不能为0', 1);
        }
        return $this->numA / $this->numB;
    }
}



 ?>

来个工厂类实现一下

<?php 

namespace SimpleFactory;
require './operate.php';
require './add.php';

/**
 * 工厂类
 */
class Factory  
{
    // 创建一种运算
    public function create($operate)
    {
        switch ($operate) {
            case '+':
                $result = new Add();
                break;
            case '-':
                $result = new sub();
                break;
            case '*':
                $result = new mul();
                break;
            case '/':
                $result = new div();
                break;
            
            default:
                throw new Exception("暂不支持", 1);
                
                break;
        }
        return $result;
    }
}

$factory = new Factory();
$operate = $factory->create('+');
$operate->setNumA(23);
$operate->setNumB(3777);
$result = $operate->getResult();
echo $result;

 ?>