PHP design pattern Template (template pattern)_PHP tutorial

Due to its own shortcomings, inheritance relationships have been labeled as "evil" by experts. "Use delegation relationships instead of inheritance relationships", "try to use interface implementation instead of abstract class inheritance" and other expert warnings, let us rookies "look at inheritance in a different light". In fact, inheritance still has many advantages of its own. It’s just that the shortcomings of being abused by everyone seem to be more obvious. Reasonable use of inheritance relationships can still play a good role in your system design. The template method pattern is one of the usage examples.

GOF defines the skeleton of an algorithm in operation for the Template Method pattern, while deferring some steps to subclasses. Allows subclasses to redefine certain specific steps of an algorithm without changing the structure of the algorithm. The structure of the algorithm here can be understood as a business process designed according to your needs. Specific steps refer to those links where there may be variations in content.

It can be seen that the template method pattern is also designed to cleverly solve the impact of changes on the system. Using the template method enhances the scalability of the system and minimizes the impact of changes on the system. This can be clearly seen in the following example.

Copy code The code is as follows:

/**
* Template pattern
*
* Define the algorithm skeleton in an operation, and defer some steps to subclasses, so that subclasses can define certain specific aspects of the algorithm without changing the structure of the algorithm. Steps
*
*/
abstract class TemplateBase
{
public function Method1()
{
echo "abstract Method1
";
}

public function Method2()
{
echo "abstract Method2
";
}

public function Method3()
{
echo "abstract Method3
";
}

public function doSomeThing()
{
$this->Method1();
$this->Method2();
$this-> Method3();
}
}

class TemplateObject extends TemplateBase
{
}

class TemplateObject1 extends TemplateBase
{
public function Method3 ()
{
echo "TemplateObject1 Method3
";
}
}

class TemplateObject2 extends TemplateBase
{
public function Method2()
{
echo "TemplateObject2 Method2
";
}
}

// Instantiate
$objTemplate = new TemplateObject();
$objTemplate1 = new TemplateObject1();
$objTemplate2 = new TemplateObject2();

$objTemplate->doSomeThing();
$objTemplate1->doSomeThing();
$ objTemplate2->doSomeThing();

AbstractClass (abstract class): defines one or more abstract methods for specific subclasses to implement them; and also implements a template method , to define the skeleton of an algorithm. This template method not only calls the previous abstract method, but also can call other operations, as long as it can complete its mission.

ConcreteClass (concrete class): implements abstract methods in the parent class to complete the steps in the algorithm related to a specific subclass.

According to the above analysis of the definition and the explanation of the examples, it can be seen that the template method is suitable for the following situations:

Implement the unchanged part of an algorithm at one time and make it variable The behavior is left to subclasses to implement.
Common behaviors in each subclass should be extracted and concentrated into a common parent class to avoid code duplication. In fact, this can be said to be a good coding habit.
Control subclass extension. Template methods only call operations at specific points, thus allowing expansion only at those points. For example, the runBare() method above only applies the setUp method before runTest. If you don't want subclasses to modify the framework defined by your template method, you can do it in two ways: first, do not reflect your template method in the API; second, just make your template method final. .
It can be seen that using the template method pattern can extract the public behavior of the code to achieve the purpose of reuse. Moreover, in the template method pattern, the template method of the parent class controls the specific implementation in the subclass. In this way, you don't need to know much about business processes when implementing subclasses.

http://www.bkjia.com/PHPjc/323607.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/323607.htmlTechArticleDue to its own shortcomings, inheritance relationships have been labeled as "evil" by experts. "Use delegation relationships instead of inheritance relationships", "try to use interface implementation instead of abstract class inheritance", etc...