Detailed explanation of the five principles of object-oriented PHP: open-closed principle

The content shared with you in this article is a detailed explanation of the open-closed principle of the five object-oriented principles of PHP. It has a certain reference value. Friends in need can refer to it

1. What Is "open-closed"

As the scale of software systems continues to increase, the complexity of software system maintenance and modification continues to increase. This dilemma prompted French engineering academician Bertrand Meyer to The "Open-Close Principle (OCP)" principle was proposed in 1998. The basic idea of ​​this principle is:

Open (Open for extension) module behavior must be open and support expansion. , rather than rigid.

Close (Closed for modification) When extending the functionality of a module, it should not affect or affect existing modules on a large scale.

In other words, developers are required to expand the software functions of the application system without modifying the existing code (source code or binary code) in the system. To sum it up in one sentence: a module should be developed in terms of extensibility and closed in terms of changeability.

From life, the easiest example to think of is the computer. We can easily expand the functions of the computer and only need to connect different devices through the interface.

Open-closed can improve the scalability and maintainability of the system, but this is also relative. It is impossible for a computer to be completely open. Some equipment and functions must remain stable to reduce maintenance difficulties. To implement a new feature, you must upgrade your hardware or change to a higher-performance computer. Take multimedia playback software in computers as an example. As a player, it should have some basic and universal functions, such as opening multimedia files, stopping playback, fast forwarding, volume adjustment, etc. But no matter what player it is, no matter what playback platform it is on, players designed according to this principle should have a unified style and operating habits. No matter which one is used, the author should be able to get started quickly.

Taking the player as an example, first define an abstract interface, the code is as follows.

1. interface process
   {
     public function process();
   }

Then, extend this interface to implement decoding and output functions, as shown below

1. class playerencode implements process
   {
     public function process()
     {
       echo "encode",PHP_EOL;
     }
   }
   class playeroutput implements process
   {
     public function process()
     {
       echo "ouput",PHP_EOL;
     }
   }

The various functions of the player are open here. As long as you follow the agreement and implement the process interface, you can add new functional modules to the player. Only the decoding and output modules are implemented here, and more new modules can be added according to needs.

Next define the player's thread high scheduling manager. Once the player receives a notification (it can be an external click behavior or an internal notify behavior), it will call back the actual thread processing. The code is as follows

1. class playProcess
   {
     private $message = null;
     public function __construct() {}
     public function callback(event $event)
     {
       $this->message = $event->click();
       if($this->message instanceof process)
       {
         $this->message->process();
       }
     }
   }

The specific product has come out. Here we define an MP4 class. This class is relatively closed and defines the event processing logic. The code is as follows

1. class mp4
   {
     public function work()
     {
       $playProcess = new playProcess();
       $playProcess->callback(new event('encode'));
       $playProcess->callback(new event('output'));
     }
   }

The last is the processing class for event sorting. This class is responsible for sorting events and judging user or internal behavior to generate the correct "thread" for The built-in purebred manager scheduling of the player, the code is as follows

1. class event
   {
     private $m;
     public function __construct($me)
     {
       $this->m = $me;
     }
     public function click()
     {
       switch($this->m)
       {
         case 'encode';
           return new playerencode();
           break;
         case 'output':
           return new playeroutput();
           break;
       }
     }
   }

The last code to run

1. $mp4 = new mp4;
   $mp4->work();

The running results are as follows:

encode ouput

1. How to comply with the open-closed principle

The core of realizing open-closed is to program abstractly, not concretely, because abstraction is relatively stable. By letting a class depend on a fixed abstraction, such modifications are closed; through object-oriented inheritance and polymorphism mechanisms, you can inherit the abstract body, change the inherent behavior by overriding its methods, and implement new extension methods. , so it is open to expansion.

1) Apply the ideas of "abstraction" and "encapsulation" in design.

On the one hand, it is necessary to find various possible "variable factors" in the software system and encapsulate them.

On the other hand, a variable factor should not be scattered across multiple different code modules, but should be encapsulated into an object.

2) Apply interface-oriented programming in the implementation of system function programming.

When the requirements change, a new implementation class of this interface can be provided to adapt to the changes.

Interface-oriented programming requires functional classes to implement interfaces and objects to be declared as interface types. In the design mode, the decoration mode obviously uses OCP.

The above is the detailed content of Detailed explanation of the five principles of object-oriented PHP: open-closed principle. For more information, please follow other related articles on the PHP Chinese website!