Three major features of php object-oriented

Object-oriented came into being when there were many problems with structured design methods. The basic strategy of structured design method to solve problems is to examine the problem domain from a functional perspective. Below we will introduce to you the three major object-oriented features of PHP.

Recommended tutorial: PHP video tutorial

##The three major features are: encapsulation and inheritance , Polymorphism

Encapsulation

The so-called encapsulation is to encapsulate objective things into abstract classes, and classes You can only allow trusted classes or objects to operate your data and methods, 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.

Inheritance

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 Classification concept.

Inheritance refers to the ability to use all the functions of an existing class and extend these functions 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 a base class without additional coding; interface inheritance refers to the ability to use only the names of properties and methods, but subclasses must provide implementations;

Polymorphism

The so-called polymorphism means that the same method of a class instance has different manifestations in different situations.

The polymorphism mechanism 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 PrincipleSRP(Single Responsibility Principle)

It 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 should be open in terms of changeability is closed. 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 function should be able to be added without modifying the server function code. This requires that the server and client should be separated at the beginning of the design, and the common parts should be abstracted. .

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 and all employees can participate in the lottery, then no matter whether they are old employees or new employees, whether they are headquarters employees or expatriate employees, they should be able to participate in the lottery, otherwise the company will not be harmonious.

Substitution Principle (the Liskov Substitution Principle LSP)

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 A should implement this abstract interface. B only uses this abstract interface: This achieves the purpose of dependency inversion. B It also removes the 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 rather than through specific classes. Couple it

The above is the detailed content of Three major features of php object-oriented. For more information, please follow other related articles on the PHP Chinese website!