PHP Simple Factory Mode example explained _php tutorial

PHP Simple Factory Model Example explained, a simple explanation of the people can refer to a bit.

Simple Factory mode:
① abstract base class: Some methods of defining abstractions in classes to implement in subclasses
② inherits from the subclass of the abstract base class: Implementing an abstract method in a base class
③ Factory class: Used to instantiate objects

Read the article and then look back to see this picture, the effect will be better

Package Type

The code is as follows

Copy Code

Class calc{ /** * Calculation results * * @param int|float $num 1 * @param int|float $num 2 * @param string $operator * @return Int|float */ Public function Calculate ($num 1, $num 2, $operator) { try { $result = 0; Switch ($operator) { Case ' + ': $result = $num 1+ $num 2; Break Case '-': $result = $num 1-$num 2; Break Case ' * ': $result = $num 1* $num 2; Break Case '/': if ($num 2==0) { throw new Exception ("divisor cannot be 0"); } $result = $num 1/$num 2; Break return $result; } }catch (Exception $e) { echo "You entered in error:". $e->getmessage (); } } } $test =new Calc (); echo $test->calculate (2,3, ' + ');//Print: 5 echo $test->calculate (5,0, '/');//Print: You entered the wrong: divisor cannot be 0 ?>

Advantage: The above code uses the object-oriented encapsulation feature, as long as the Include this class, other pages can be used casually

Cons: Inability to scale and maintain flexibly
For example, if you want to add a "redundancy" operation, you need to include a branch statement in the switch statement block, the code needs to make the following changes
To add a branch statement

The code is as follows	Copy Code
Class calc{ Public function Calculate ($num 1, $num 2, $operator) { try { $result = 0; Switch ($operator) { //...... Omitted...... Case '% ': $result = $num 1% $num 2; Break //...... Omitted...... } }catch (Exception $e) { echo "You entered in error:". $e->getmessage (); } } } ?>

Code Analysis: Using the above method to add a new function to the calculator has the following disadvantages

① need to change the original code block, may be in order to "add new features" and change the original code, accidentally changed the original code is wrong
② If you want to add a lot of features, such as: ' Power ', ' root ', ' log ', ' trigonometric ', ' statistics ', or add some programmer-specific computing functions, such as: and, or, not, Xor, so you need to add N branch statements in the switch statement. Imagine that a function of computing function if there are twenty or thirty case branch statements, the code will be more than one screen, not only make the code readability greatly reduced, the key is, in order to add small functions, but also to let the rest of the irrelevant are involved in interpretation, which makes the execution of the program significantly less efficient
Solution approach: Using OOP's inheritance and polymorphic thinking
Preliminary implementation of simple factory model

The code is as follows

Copy Code

/** * Operation class * Because an abstract method is included, the class must be declared as an abstract class */ Abstract class operation{ Abstract methods cannot contain function bodies Abstract public Function GetValue ($num 1, $num 2);//strongly require subclasses to implement the function function } /** * Addition class */ Class Operationadd extends Operation { Public Function GetValue ($num 1, $num 2) { return $num 1+ $num 2; } } /** * Subtraction Class */ Class Operationsub extends Operation { Public Function GetValue ($num 1, $num 2) { Return $num 1-$num 2; } } /** * Multiplication Class */ Class Operationmul extends Operation { Public Function GetValue ($num 1, $num 2) { return $num 1* $num 2; } } /** * Division Class */ Class Operationdiv extends Operation { Public Function GetValue ($num 1, $num 2) { try { if ($num 2==0) { throw new Exception ("divisor cannot be 0"); }else { return $num 1/$num 2; } }catch (Exception $e) { echo "error message:". $e->getmessage (); } } } ?>

uses an object-oriented inheritance feature, first declaring a virtual base class, specifying a method in the base class that must be implemented (GetValue ())

Analysis: By using object-oriented inheritance, we can easily extend the original program, such as: ' exponentiation ', ' root ', ' logarithmic ', ' trigonometric ', ' statistics ' and so on.

Find the remainder class

The code is as follows	Copy Code
/** * Seeking remainder class (remainder) * */ Class Operationrem extends Operation { Public Function GetValue ($num 1, $num 2) { return $num 1% $num 12; } } ?>

We only need to write another class (the class inherits the virtual base class), in the class to complete the corresponding functions (such as: exponentiation), and greatly reduce the coupling degree, convenient for future maintenance and expansion

Now there is one more question unresolved, that is, how can the program instantiate the corresponding object according to the user input operator?
Workaround: Use a separate class to implement the instantiation process, which is the factory
The code is as follows:

Factory class

copy code

!--? php /** * Engineering class, used primarily to create objects * Function: According to the input operation symbol, 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 to New Operationdiv (); break; } } } $test =factory::createobj ('/'); $result = $test->getvalue (23,0); Echo $result; ?

http://www.bkjia.com/PHPjc/444687.html www.bkjia.com true http://www.bkjia.com/PHPjc/444687.html techarticle PHP Simple Factory Model Example explained, a simple explanation of the people can refer to a bit. Simple Factory mode: ① Abstract base class: Defines abstract methods in a class to implement in subclasses ...

