Encapsulation, inheritance, understanding of polymorphism

Encapsulation, inheritance, polymorphic understanding

1. Encapsulation

That is, encapsulating objective things into abstract Class, and the class can allow its own data and methods to be operated only by trusted classes or objects, and hide information from untrusted ones. Encapsulation is one of the characteristics of object-oriented and the main characteristic of the concepts of objects and classes. 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.

2. 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 it without having to rewrite 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;

3. Polymorphism

means that the same method of a class instance has different manifestations in different situations. Polymorphism enables 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 added without modifying the server-side function code. This is It is required that at the beginning of the design, the server and the client should be separated, and the public 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: 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,

, or whether they are headquarters employees or expatriate employees, 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

Recommended tutorials: "
PHP Tutorial" "Java"

The above is the detailed content of Encapsulation, inheritance, understanding of polymorphism. For more information, please follow other related articles on the PHP Chinese website!