Example explanation of 'Simple Factory Pattern' in PHP

Simple factory pattern:
①Abstract base class: Define some abstract methods in the class to implement in subclasses
②Subclasses that inherit from the abstract base class: implement abstract methods in the base class
③Factory class: used to Instantiate the object

After reading the article, look back at this picture, the effect will be better

采用封装方式

<?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 &#39;+&#39;:
                        $result= $num1+$num2;
                        break;
                    case &#39;-&#39;:
                        $result= $num1-$num2;
                        break;
                    case &#39;*&#39;:
                        $result= $num1*$num2;
                        break;
                    case &#39;/&#39;:
                        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,&#39;+&#39;);//打印:5
    echo $test->calculate(5,0,&#39;/&#39;);//打印:您输入有误:除数不能为0
?>

Advantages: The above code uses the object-oriented encapsulation feature, as long as you have the include class, other pages can Used casually

Disadvantages: Unable to flexibly expand and maintain
For example: If you want to add a "remainder" operation, you need to add a branch statement in the switch statement block, and the code needs to be changed as follows

添加分支语句

<?php
    class Calc{
        public function calculate($num1,$num2,$operator){
            try {
                $result=0;
                switch ($operator){
                    //......省略......
                    case &#39;%&#39;:
                        $result= $num1%$num2;
                        break;
                    //......省略......
                }
            }catch (Exception $e){
                echo "您输入有误:".$e->getMessage();
            }
        }
    }
?>

Code analysis: Use the above The method to add new functional operations to the calculator has the following disadvantages

① It is necessary to modify the original code block. You may accidentally change the original code when modifying the original code in order to "add new functions" Corrected the error
②If you want to add many functions, such as: 'power', 'square root', 'logarithm', 'trigonometric function', 'statistics', or add some programmer-specific calculation functions, such as: And, Or, Not, Xor, this requires adding N branch statements to the switch statement. Imagine that if a calculation function has twenty or thirty case branch statements, the code will exceed one screen. Not only will the readability of the code be greatly reduced, but the key is that in order to add small functions, other unrelated functions must be involved. Explanation, this greatly reduces the execution efficiency of the program
Solution: Adopt OOP inheritance and polymorphism ideas

简单工厂模式的初步实现
 <?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();
             }
         }
     }
 ?>

The object-oriented inheritance feature is used here. First, declare a virtual base class, and the specified subclass in the base class must be implemented method (getValue())

Analysis: By using object-oriented inheritance features, we can easily extend the original program, such as: 'power', 'square root', 'logarithm', ' Trigonometric functions', 'Statistics', etc.

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

We only need to write another class (this class inherits the virtual base class), complete the corresponding functions in the class (such as: the calculation of exponentiation), and greatly reduce the degree of coupling, which facilitates future maintenance and expansion.

There is still an unresolved problem, which is how to let the program instantiate the corresponding object according to the operator input by the user?
Solution: Use a separate class to implement the instantiation process. This class is the factory.
The code is as follows:

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

For more related articles explaining the "Simple Factory Pattern" examples in PHP, please pay attention to PHP Chinese net!