PHP object-oriented three basic features and five basic principles

This article shares with you the three basic features and five basic principles of object-oriented PHP. It has certain reference value. Friends in need can refer to it

The three major characteristics are: Encapsulation, inheritance, polymorphism

The so-called Encapsulation means encapsulating objective things into abstract classes, and classes can Your own data and methods only allow trusted classes or objects to operate, and hide information from untrusted ones.

Encapsulation is one of the characteristics of object-oriented and the main characteristic of object and class concepts. Simply put, a class is a logical entity that encapsulates data and code that operates on this data. Within an object, some code or some data can be private and cannot be accessed by the outside world. In this way, objects provide varying levels of protection for internal data to prevent unrelated parts of the program from accidentally changing or incorrectly using the private parts of the object.

The so-called Inheritance refers to a method that allows an object of a certain type to obtain the properties of an object of another type. It supports the concept of hierarchical classification.

Inheritance refers to the ability to use all the functionality of an existing class and extend these functionality without rewriting the original class. The new class created through inheritance is called a "subclass" or "derived class", and the inherited class is called a "base class", "parent class" or "super class". The process of inheritance is the process from general to special. To achieve inheritance, you can achieve it through "Inheritance" and "Composition". There are two types of ways to implement the concept of inheritance: implementation inheritance and interface inheritance. Implementation inheritance refers to the ability to directly use the properties and methods of the base class without additional coding; interface inheritance refers to the ability to only use the names of properties and methods, but the subclass must provide implementation;

So-called Polymorphism means that the same method of a class instance has different manifestations in different situations.

Polymorphism allows objects with different internal structures to share the same external interface. This means that although the specific operations on different objects are different, they (those operations) can be called in the same way through a common class.

Five Basic Principles

Single Responsibility Principle SRP (Single Responsibility Principle)

means that the function of a class must be single and cannot be all-inclusive. Just like a person, you should not be assigned too much work, otherwise although you will be busy all day long, your efficiency will not be high.

Open-Close Principle OCP (Open-Close Principle)

A module should be open in terms of extensibility and closed in terms of changeability. For example: a network module originally only had server-side functions, but now it needs to add client-side functions.
Then the implementation code of the client-side functions should be able to be added without modifying the server-side function code. This requires that in the design From the beginning, the server and client should be separated and the public parts should be abstracted.

Substitution Principle (the Liskov Substitution Principle LSP)

Subclasses should be able to replace the parent class and appear anywhere the parent class can appear. For example, if the company holds an annual party, all employees can participate in the lottery, so no matter whether they are old employees or new employees,
employees at the headquarters or expatriates, they should be able to participate in the lottery, otherwise the company will not be harmonious.

The Dependency Inversion Principle DIP (the Dependency Inversion Principle DIP) The concrete depends on the abstract, and the upper layer depends on the lower layer.

Assume that B is a lower module than A, but B needs to use the functions of A. At this time, B should not directly use the concrete class in A: Instead, B should define an abstract interface and use it by A. To implement this abstract interface, B only uses this abstract interface: This achieves the purpose of dependency inversion, and B also relieves its dependence on A. In turn, A depends on the abstract interface defined by B. It is difficult to avoid relying on lower-level modules through upper-level modules. If B also directly depends on the implementation of A, then it may cause circular dependencies. A common problem is that when compiling module A, you need to directly include the cpp file of module B, and when compiling B, you also need to directly include the cpp file of A.

The Interface Segregation Principle ISP

Modules should be isolated through abstract interfaces instead of being strongly coupled through specific classes

The above is the detailed content of PHP object-oriented three basic features and five basic principles. For more information, please follow other related articles on the PHP Chinese website!