Detailed introduction to the six principles of design patterns

Single Responsibility Principle

Definition: Do not have more than one reason for a class change. In layman's terms, a class is only responsible for one responsibility.

Richter Substitution Principle

Definition 1: If For every object o1 of type T1, there is an object o2 of type T2, so that all programs P defined with T1 will be replaced by o2 when all objects o1

## , the behavior of program P does not change, then type T2 is a subtype of type T1.

Definition 2: All references to the base class must be able to transparently use objects of its subclasses. That is to say, wherever a base class can appear, a subclass can definitely appear

.

#The Liskov substitution principle is generally speaking: a subclass can extend the functions of the parent class, but it cannot change the original functions of the parent class. It contains the following 4 levels of meaning:

1). Subclasses can implement abstract methods of the parent class, but cannot override non-abstract methods of the parent class.

2). Subclasses can add their own unique methods.

3). When the method of the subclass overrides the method of the parent class, the preconditions of the method (i.e. the formal parameters of the method) must More relaxed input parameters than the parent class method.

#4). When a method of a subclass implements an abstract method of a parent class, the postconditions of the method (i.e., the return value of the method) are more stringent than those of the parent class.

Dependency Inversion Principle

Definition: High-level modules do not You should rely on lower-level modules, both of which should rely on their abstractions; abstractions should not rely on details; details should rely on abstractions.

The core idea of ​​the dependency inversion principle is: programming for the interface.

There are three ways to deliver dependencies: 1. Interface delivery, 2. Constructor method delivery, 3. Setter method delivery.

In actual programming, we generally need to do the following three points:

1). Try to use low-level modules as much as possible There must be an abstract class or interface, or both.

#2). The declared type of variable should be an abstract class or interface as much as possible.

3). Follow the Liskov substitution principle when using to inherit .

##Interface isolation principle

Definition: The client does not Should rely on interfaces it does not need; a class's dependence on another class should be based on the smallest interface.

Should provide clients with individual interfaces as small as possible instead of providing a large total interface.

#1). It is better to use multiple specialized interfaces than to use a single general interface.

#2). The dependence of one class on another class should be based on the smallest interface.

#3). An interface represents a role, and different roles should not be assigned to one interface. Unrelated interfaces are merged together to form a bloated big

interface, which is a pollution to roles and interfaces.

4). "Clients should not be forced to rely on methods they do not use. The interface belongs to the client, not the class hierarchy in which it resides."

This is very clear. To put it more simply, don’t force customers to use methods they don’t use. If you force users to use methods they don’t use, then this

Some customers will face changes caused by changes in these unused methods.

Dimit Principle

Definition: an object Knowledge of other objects should be kept to a minimum.

Obviously, the interface isolation principle and the generalized Dimit principle are restrictions on the communication between one software entity and other software entities. The broad Demeter principle requires

to limit the width and depth of communication as much as possible. What the interface isolation principle limits is the width of communication, that is, communication should be as narrow as possible.

Demit's Law, also known as the least-known principle, was first proposed in 1987 by Ian Holland of Northeastern University in the United States. In layman's terms, the less a class knows about the classes it depends on, the better. In other words, for the dependent class, no matter how complex the logic is, try to encapsulate the logic

inside the class. Except for the provided public method, it is not exposed to the outside world. leak any information. There is a simpler definition of Demeter's Law: Only communicate with friends who are directly

. First, let’s explain what a direct friend is: each object will have a coupling relationship with other objects. As long as there is a coupling relationship between two objects, we will say that these two The objects are friends. There are many ways of coupling, such as dependency, association, combination, aggregation, etc. Among them, we call classes that appear in member variables, method parameters, and method return values ​​​​as direct friends, while classes that appear in local variables are not direct friends. In other words, it is best not for unfamiliar classes

to appear inside the class as local variables.

Open-Closed Principle

A software entity should be open to extension , closed for modification.

Principles of combination/aggregation reuse

Try your best Use combination/aggregation instead of inheritance to achieve reuse.

The above is the detailed content of Detailed introduction to the six principles of design patterns. For more information, please follow other related articles on the PHP Chinese website!