Practical analysis of PHP Liskov substitution principle

This time I will bring you a practical analysis of the PHP Richter replacement principle. What are the precautions when using the PHP Richter replacement principle? The following is a practical case, let's take a look.

The substitution 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 related to inheritance, so it is called the Liskov 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 ideas are as follows: Since 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 Think about whether the inheritance relationship between various classes in the application system 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 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 , thereby 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.

I believe you have mastered the method after reading the case in this article. For more exciting information, please pay attention to other related articles on the php Chinese website!

Recommended reading:

Bootstrap PHP Detailed explanation of the steps to implement multiple image uploads

PHP Session Detailed explanation of the steps to prevent repeated submission of forms

The above is the detailed content of Practical analysis of PHP Liskov substitution principle. For more information, please follow other related articles on the PHP Chinese website!