Detailed explanation of the open-closed principle (OCP) of the five object-oriented principles of PHP

This article mainly introduces the open-closed principle (OCP), the five major principles of object-oriented PHP, and briefly analyzes the concepts, principles, usage methods and related precautions of PHP object-oriented open-closed principle (OCP). What is needed Friends can refer to

. The examples in this article describe the open-closed principle (OCP) of the five object-oriented principles of PHP. Share it with everyone for your reference, the details are as follows:

1. What is "open-closed"

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

Open (Open for extension) The behavior of the module must be open and support extension, 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.

interface process
{
  public function process();
}

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

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

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

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

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

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

The running results are as follows:

encode ouput

##2. How to comply with the open-closed principle

The core of realizing open-closed is to program abstractly rather than concretely, because abstraction is relatively stable. By making 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 requirements change, a new implementation class of this interface can be provided to adapt to the change.

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.

Related recommendations:

Some keywords used in PHP object-oriented

Detailed explanation of the differences between private, protected and public in PHP object-oriented

##

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