PHP Design Pattern Decorator Pattern_PHP Tutorial

Introducing
The Decorator pattern dynamically attaches responsibilities to objects. To extend functionality, decorators provide a more flexible alternative to inheritance.

Mind Map

There is such a project to build a restaurant ordering system. The initial code structure is like this. There were many Beverage inheritance classes in the past. The problem we are encountering now is that the price of milk has increased. So we have to adjust all related classes, such as Milk and SugarAndMilk classes. There are many such classes. We need to modify the classes one by one. method in - developers are going crazy every time they do this! So we have to change the existing structure. The following pictures are simple diagrams, the actual pictures are not that simple.

Design issues:

1》The number of classes has exploded, and there are many classes, making it difficult to maintain;
2》The entire design is dull;
3》New functions added to the base class cannot be used in subclasses;
Reusing class methods There are many ways, such as inheritance, combination, and delegation. Why do you always use inheritance? I see Zend Framework also has this habit! Every time you find the corresponding method, keep scrolling up. ——Off-topic!!!
Later, after group research, we decided to extract the basic category. For example, we made coffee a separate category, and other coffees, such as milk coffee and sweet coffee, we Only materials are individually packaged into a class.
Improved design:

Detailed explanation
1》For drinks, we directly inherit the Beverage class and write the quotation directly into the beverage class;
2》For some special drinks that need to add condiments, we do an accumulation operation. For example, if I want a cup of coffee with milk, the total price = coffee price + milk price
3》This way, it is easy to know the prices of different drinks.
Code

Copy code The code is as follows:

abstract class Beverage{
public $_name;
abstract public function Cost();
}
// Decorator class
class Coffee extends Beverage{
public function __construct(){
$this- >_name = 'Coffee';
}
public function Cost(){
return 1.00;
}
}
// The following three classes are decorator-related classes
class CondimentDecorator extends Beverage{
public function __construct(){
$this->_name = 'Condiment';
}
public function Cost(){
return 0.1;
}
}
class Milk extends CondimentDecorator{
public $_beverage;
public function __construct($beverage){
$this->_name = 'Milk';
if($beverage instanceof Beverage){
$this->_beverage = $beverage;
}else
exit('Failure');
}
public function Cost(){
return $this->_beverage->Cost() + 0.2;
}
}
class Sugar extends CondimentDecorator{
public $_beverage;
public function __construct($beverage ){
$this->_name = 'Sugar';
if($beverage instanceof Beverage){
$this->_beverage = $beverage;
}else{
exit ('Failure');
}
}
public function Cost(){
return $this->_beverage->Cost() + 0.2;
}
}
// Test Case
//1. Get a cup of coffee
$coffee = new Coffee();
//2. Add some milk
$coffee = new Milk($coffee);
///3. Add some sugar
$coffee = new Sugar($coffee);
printf("Coffee Total:%0.2f yuann",$coffee->Cost());

Summary
1. The decorator (Milk) and the decorator (Coffee) must be of the same type. The purpose is that the decorator must replace the decorator.
2. Add behavior: When decorators and components are combined, new behaviors are added.
Digression:
1. Use inheritance to design subclass behavior, which is statically determined at compile time, and all subclasses will inherit the same behavior. For example, I want to learn some kung fu, and seeing that your son knows Tai Chi, I only need to inherit from you, and I will also know Tai Chi - haha, at this time I will become your son, and it seems that inheritance is necessary. Pay the price.
2. Combination, we can extend the behavior of the object and expand it dynamically at runtime. Using composition, we can add methods to objects that we didn't think of when designing the superclass at any time without changing the existing code. For example, I have no internal power now, and the power-absorbing method can absorb the internal power (behavior objects) of monks, nuns, and Taoist priests. Then during the fight (running time), I can use different internal powers at any time, but also Don't suck in the internal energy randomly, otherwise you will go crazy!
3. Classes should be open for extension and closed for modification. If we design each part using the decorator pattern, it will be a bit wasteful for the entire framework, and you will also increase the difficulty of the code. So when should you use this pattern? We generally use it in places that change frequently. So how do we know which places change frequently? This requires our experience and your understanding of the industry you are in. It is recommended that you look at more examples every day.
4. The decoration mode injects flexibility into the design, but at the same time it adds a large number of small categories to the design, which occasionally makes it difficult for others to understand the design.
5. When using the decorator pattern, be particularly careful with the inserted decorators. Because the decorator pattern relies on a specific type (Beverage).
6. To use the decorator pattern well, we also need to use the factory pattern and the generator pattern together, but today we will only talk about the decorator pattern. To know more, please listen to the next chapter.
Reference: "head first design pattern"

http://www.bkjia.com/PHPjc/325090.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/325090.htmlTechArticleIntroducing the decorator pattern to dynamically attach responsibilities to objects. To extend functionality, decorators provide a more flexible alternative to inheritance. Mind map There is such a project, do a...