Detailed explanation of Liskov Substitution Principle (LSP), the five major principles of object-oriented PHP

This article mainly introduces the Liskov Substitution Principle (LSP) of the five object-oriented principles of PHP. It analyzes the concept and principle of the Liskov Substitution Principle (LSP) in more detail and analyzes the PHP Liskov Substitution Principle in the form of examples. For the simple usage of (LSP), friends who need it can refer to

This article describes the Liskov Substitution Principle (LSP) of the five object-oriented principles of PHP with examples. Share it with everyone for your reference. The details are as follows:

The replacement principle was proposed by Ms. Liskov of the MIT Computer Science Laboratory in an article at the OOPSLA conference in 1987. It mainly elaborates on some principles about inheritance, so It is called Richter substitution principle.

In 2002, Robert C.Martin published a book called "Agile Software Development Principles Patterns and Practices", in which he finally simplified the Liskov substitution principle into one sentence: "Subtypes must be substitutable for their base types” (Subclasses must be able to be replaced by their base types.)

1. Contents of LSP

Liskov Substitution Principle , LSP) definition and main idea are as follows: Because inheritance in object-oriented programming technology is too simple in specific programming, in the design and programming implementation of many systems, we have not seriously and rationally thought about each class in the application system. Whether the inheritance relationship between them is appropriate, whether the derived class can correctly override some methods in its base class, etc. Therefore, abuse of inheritance or incorrect inheritance often occur, which brings a lot of trouble to the later maintenance of the system. This requires us to have a design principle to follow, which is the replacement principle.

LSP points out that subclass types must be able to replace their parent types and appear anywhere where the parent class can appear. It guides us on how to inherit and derive correctly and reuse code reasonably. This principle holds that if a software entity uses a base class, it must apply to its subclasses, and this cannot detect the difference between base class objects and subclass objects at all. Think about it, is it similar to the concept of polymorphism?

2. LSP is mainly based on the design principle of inheritance

Because inheritance and derivation are a major feature of OOP, which can reduce repeated programming implementation of code, thereby realizing the system Code reuse in the application, but how to correctly design inheritance and apply inheritance mechanism rationally?

This is the problem that LSP wants to solve:

How to design inheritance correctly?

How to obtain the best inheritance hierarchy?

How to prevent the designed class hierarchy from falling into a situation that does not comply with OCP principles?

How to comply with this design principle?

1) The methods of the parent class must be implemented or rewritten in the subclass, and the derived class only implements the methods declared in its abstract class, and should not give redundant method definitions or implementations

2) Only parent class objects should be used in client programs instead of subclass objects directly, so that runtime binding (dynamic polymorphism) can be achieved.

If classes A and B violate the design of LSP, the usual approach is to create a new abstract class C as a superclass of the two concrete classes, and move the common behaviors of A and B to C , thus solving the problem that the behaviors of A and B are not completely consistent.

However, PHP's support for LSP is not good. It lacks concepts such as upward transformation and can only be achieved through some tortuous methods. This principle will not be discussed in detail here.

The following is a cache implementation interface, using abstract classes as base classes and following LSP to implement its design.

<?php
abstract class Cache
{
 /**
  * 设置一个缓存变量
  * @param $key 缓存key
  * @param $value 缓存内容
  * @param int $expire 缓存时间(秒)
  * @return boolean 是否缓存成功
  */
 public abstract function set($key, $value, $expire = 60);
 /**
  * 获取一个已经缓存的
  * @param $key 缓存key
  * @return mixed 缓存内容
  */
 public abstract function get($key);
 /**
  * 删除一个已经缓存的变量
  * @param $key 缓存key
  * @return boolean 是否删除成功
  */
 public abstract function del($key);
 /**
  * 删除全部缓存变量
  * @return boolean 是否删除成功
  */
 public abstract function delAll();
 /**
  * 检测是否存在对应的缓存
  * @param $key 缓存key
  * @return boolean 是否存在
  */
 public abstract function has($key);
}

If you now need to implement caching under various mechanisms such as files, memcache, accelerator, etc., you only need to inherit this abstract class and implement its abstract methods.

The code in LSP is not only the function, but also the sign language meaning. Think about it: a white horse can replace a horse, and an ox is also used as a labor force. Can it replace a horse? High heels are also shoes. Is it acceptable for men to wear high heels?

Related recommendations:

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

The inheritance structure of PHP object-oriented Function

Detailed explanation of the interface isolation principle (ISP) of the five major PHP object-oriented principles

The above is the detailed content of Detailed explanation of Liskov Substitution Principle (LSP), the five major principles of object-oriented PHP. For more information, please follow other related articles on the PHP Chinese website!