Shulou(Shulou.com)06/03 Report--

Editor to share with you the example analysis of the factory pattern in the PHP design pattern, I believe that most people do not know much about it, so share this article for your reference, I hope you can learn a lot after reading this article, let's go to know it!

The simple factory pattern is the creation pattern of the class, also known as the static factory method (Static Factory Method) pattern. The simple factory pattern is that a factory object decides which instance of the product class to create.

1. Several forms of factory model

The factory pattern is specifically responsible for instantiating a large number of classes that have a common interface. The factory pattern can dynamically determine which class to instantiate without having to know which class to instantiate each time. The factory model has the following forms:

(1) simple factory (Simple Factory) pattern, also known as static factory method pattern (Static Factory Method Pattern).

(2) Factory method (Factory Method) model, also known as polymorphic factory (Polymorphic Factory) model or virtual constructor (Virtual Constructor) model.

(3) the abstract factory (Abstract Factory) pattern, also known as the toolbox (Kit or Toolkit) pattern. The following is a brief class diagram of the simple factory pattern.

The simple factory pattern, or static factory method pattern, is a special implementation of different factory method patterns. In other literature, simple factories are often discussed as a special case of the ordinary factory model.

Learning simple factory patterns is not only a good preparation for learning factory method patterns, but also a good preparation for learning other patterns, especially singleton patterns and multiple patterns.

2. The introduction of simple factory model

For example, there is a farm company that specializes in selling all kinds of fruits to the market. The following fruits need to be described in this system:

Grape Grape

Strawberry Strawberry

Apple Apple

Fruit is very different from other plants in that it can eventually be picked and eaten. Then it is natural to establish an interface that is suitable for all kinds of fruits in order to distinguish them from other plants on the farm. This is shown in the following figure.

The fruit interface specifies the interfaces that all fruits must implement, including the methods that any fruit must have: planting plant (), growing grow (), and harvesting harvest (). The class diagram for the interface Fruit is shown below.

The source code for this fruit interface is shown below.

Listing 1: source code for interface Fruit

Interface Fruit {public function grow (); public function harvest (); public function plant ();}

The Apple class is a kind of fruit class, so it implements all the methods declared by the fruit interface. In addition, because apples are perennials, there is an extra treeAge property to describe the age of apple trees. The following is the source code for this apple class.

Listing 2: source code for class Apple

Class Apple implements Fruit {private $_ treeAge;public function grow () {echo "Apple is growing.";} public function harvest () {echo "Apple has been harvested.";} public function plant () {echo "Apple has been planted.";} public function getTreeAge () {return $this- > _ treeAge;} public function setTreeAge ($treeAge) {$this- > _ treeAge = (int) $treeAge;}}

Similarly, the Grape class is a fruit class that implements all the methods declared by the Fruit interface. However, because grapes are seeded and seedless, they have one more seedless property than the usual fruit, as shown in the following figure.

The source code for grapes is shown below. As you can see, the Grape class also implements the fruit interface, making it a sub-type of the fruit type.

Listing 3: source code for class Grape

Class Grape implements Fruit {private $seedless;public function grow () {echo "Grape is growing.";} public function harvest () {echo "Grape has been harvested.";} public function plant () {echo "Grape has been planted.";} public function getSeedless () {return $this- > seedless;} public function setSeedless ($seedless) {$this- > seedless = (boolean) $seedless;}}

The Strawberry class implements the Fruit interface and, therefore, is a subtype of the fruit type, and its source code is shown below.

Listing 4: source code for class Strawberry

Class Strawberry implements Fruit {public function grow () {echo "Strawberry is growing.";} public function harvest () {echo "Strawberry has been harvested.";} public function plant () {echo "Strawberry has been planted.";}}

The gardener on the farm is also part of the system and is naturally represented by an appropriate class. This class is the FruitGardener class, and its structure is described by the following class diagram.

The FruitGardener class creates different fruit objects, such as Apple, Grape or Strawberry, according to the client's requirements. If an illegal request is received, the FruitGardener class throws a BadFruitException exception.

The source code for the gardener class is as follows.

Code listing source code for the 5:FruitGardener class

Class FruitGardener {public static function factory ($which) {$which = strtolower ($which); if ($which = = 'apple') {return new Apple ();} elseif ($which = =' strawberry') {return new Strawberry ();} elseif ($which = = 'grape') {return new Grape ();} else {throw new BadFruitException (' Bad fruit request');}

As you can see, the gardener class provides a static factory method. Under the call of the client, this method creates the fruit object needed by the client. If the client request is not supported by the system, the factory method throws a BadFruitException exception. The source code for this exception class is shown below.

Code listing source code for the 6:BadFruitException class

Class BadFruitException extends Exception {}

When in use, the client only needs to call the static method factory () of FruitGardener. Please see the following sign

Sexual client source code.

Listing 7: how to use the exception class BadFruitException

Try {FruitGardener::factory ('apple'); FruitGardener::factory (' grape'); FruitGardener::factory ('strawberry'); / /...} catch (BadFruitException $e) {/ /.}

In this way, the farm will certainly have a bumper harvest!

3. Use simple factory pattern to design an "object-oriented" calculator

/ * * object-oriented calculator * ideas: * 1. Object-oriented fundamentals, encapsulation, inheritance, multi-second_num * 2, parent common class * 3, various operation classes * / / * base classes, operation classes * only provide basic data and do not participate in operations * / class Operation {/ / the first number public $first_num = 0; / / the second number public $second_num = 0 / * get the result, other classes override this method * @ return double $result * / public function getResult () {$result = 0.00; return $result;}} / * * addition class * / class OperationAdd extends Operation {/ * overwrite the parent class and implement the addition algorithm * / public function getResult () {$result = 0; return $this- > first_num + $this- > second_num The subtraction class * * / class OperationSub extends Operation {/ * overrides the parent class and implements the addition algorithm * / public function getResult () {$result = 0; return $this- > first_num-$this- > second_num;}} / * * multiplication class * / class OperationMul extends Operation {/ * overwrites the parent class and implements the addition algorithm * / public function getResult () {$result = 0 Return $this- > first_num * $this- > second_num;}} / * * remove the class * * / class OperationDiv extends Operation {/ * overrides the parent class and implements the addition algorithm * / public function getResult () {$result = 0; if ($this- > second_num = 0) {throw new Exception ('the second parameter of the division operation cannot be zero!'); return 0;} return $this- > first_num / $this- > second_num }} / * Factory class * / class OperationFactory {/ * Factory function * @ param string $operation * @ return object * / public function createOperation ($operation) {$oper = null; switch ($operation) {case'+': $oper = new OperationAdd (); break; case'-': $oper = new OperationSub (); break; case'*': $oper = new OperationMul (); break Case'/': $oper = new OperationDiv (); break; default: return 0;} return $oper;}} $operation = new OperationFactory (); $oper = $operation- > createOperation ('/'); $oper- > first_num = 10 other operations-> second_num = 20 × varnish dump ($oper- > getResult ())

The above is all the content of the article "sample Analysis of Factory patterns in PHP Design patterns". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.