Example code explanation of "Simple Factory Pattern" in PHP_PHP Tutorial

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

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

Using encapsulation method

Copy code The code is as follows:

class Calc{
/**
* Calculation result
*
* @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("The divisor cannot be 0");
}
$result= $num1/$num2;
break;
return $result;
}
}catch (Exception $e){
echo "You entered something wrong:".$e->getMessage();
}
}
}
$test=new Calc ();
// echo $test->calculate(2,3,'+');//Print: 5
echo $test->calculate(5,0,'/'); //Print: You entered an error: the divisor cannot be 0
?>

Advantages: The above code uses object-oriented encapsulation features. As long as the include class is included, other pages will be Can be used casually
Disadvantages: cannot be flexibly expanded and maintained
For example: if you want to add a "remainder" operation, you need to add a branch statement to the switch statement block, and the code needs to be changed as follows
Add Branch statement

Copy code The code is as follows:

class Calc{
public function calculate ($num1,$num2,$operator){
try {
$result=0;
switch ($operator){
//...omitted... .
case '%':
$result= $num1%$num2;
break;
//...omitted...
}
}catch (Exception $e){
echo "You entered something wrong:".$e->getMessage();
}
}
}
?>

Code analysis: Using the above method to add new functional operations to the calculator has the following disadvantages
① It is necessary to change the original code block, which may be changed in order to "add new functions" When editing the original code, I accidentally changed the original code to the wrong one
② If there are many functions to be added, such as: 'power', 'square root', 'logarithm', 'trigonometric function', ' Statistics', or add some programmer-specific calculation functions, such as: And, Or, Not, Xor, so you need to add 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 polymorphic ideas
Initial implementation of simple factory pattern

Copy code The code is as follows:

/**
* Operation class
* Because it contains abstract methods, the class must be declared as an abstract class
*/
abstract class Operation{
//Abstract methods cannot contain function bodies
abstract public function getValue($num1,$num2);//It is strongly required that subclasses must implement this functional function
}
/**
* Addition class
*/
class OperationAdd extends Operation {
public function getValue($num1,$num2){
return $num1+$num2;
}
}
/**
* Subtraction class
*/
class OperationSub extends Operation {
public function getValue($num1,$num2){
return $num1-$num2;
}
}
/**
* Multiplication class
*/
class OperationMul extends Operation {
public function getValue($num1,$num2){
return $num1*$num2;
}
}
/**
* Division class
*/
class OperationDiv extends Operation {
public function getValue($num1,$num2){
try {
if ($num2==0){
throw new Exception("The divisor cannot be 0");
}else {
return $num1/$num2;
}
}catch (Exception $e){
echo "Error message:".$e->getMessage();
}
}
}
?>

The object-oriented inheritance feature is used here. First, declare a virtual base class, and specify the methods that the subclass must implement in the base class ( getValue())
Analysis: By using object-oriented inheritance features, we can easily extend the original program, such as: 'power', 'square root', 'logarithm', 'trigonometric function' ', 'Statistics' and so on.

Copy code The code is as follows:

/**
* Find remainder (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) and complete the corresponding functions in the class ( For example: power calculation), and greatly reduces 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:

Copy the code The code is as follows :

/**
* Engineering class, mainly used to create objects
* Function: According to the input operation symbols, the factory can instantiate the appropriate object
*
*/
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;
?>

Original article, please indicate the source when reprinting: http://www.cnblogs.com/hongfei/

http://www.bkjia.com/PHPjc/325885.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/325885.htmlTechArticleSimple factory pattern: ①Abstract base class: Define some abstract methods in the class to implement in subclasses② Subclasses inherited from the abstract base class: implement abstract methods in the base class ③Factory class: use...