登录查看更多内容

How can you use the Liskov Substitution Principle to avoid software bugs?

由人工智能和领英社区提供技术支持

The Liskov Substitution Principle (LSP) is one of the five core principles of object-oriented programming (OOP) that guide the design of robust and maintainable software. It states that any subclass or derived class should be able to replace its superclass or base class without breaking the functionality of the program. In other words, the subclasses should honor the contracts and behaviors of their superclasses. By following this principle, you can avoid software bugs that arise from violating the expectations and assumptions of the clients or users of your classes.

此文章中的业界达人

由社区从 8 条内容中精选。了解更多

Marcos Kalinowski

Professor of Software/AI Engineering at the Department of Informatics of PUC-Rio. Coordinator of the ExACTa PUC-Rio…
Luis Miguel Guerrero Gutiérrez

????Software Engineer??|?? Backend C# .NET | ?? MCP Azure AI Engineer | Oracle Cloud Infrastructure (OCI)Associate|…
Andrew Diniz da Costa, D.Sc.

Apple Distinguished Educator, Teacher and Researcher at Pontificia Universidade Católica do Rio de Janeiro

1 What are the benefits of LSP?

LSP helps you achieve two important goals in software engineering: abstraction and polymorphism. Abstraction means hiding the implementation details of a class and exposing only its interface or contract. This way, you can change the internal logic of a class without affecting its clients, as long as you preserve the contract. Polymorphism means using a common interface or superclass to access different subclasses or implementations. This way, you can write generic and flexible code that can handle different types of objects at runtime, without hard-coding their behaviors.

添加您的观点

Luis Miguel Guerrero Gutiérrez

????Software Engineer??|?? Backend C# .NET | ?? MCP Azure AI Engineer | Oracle Cloud Infrastructure (OCI)Associate| MCP Data Engineering | MCP CosmosDB Developer Specialty ??
举报内容
La Abstracción en programación orientada a objetos oculta detalles de implementación y expone solo la interfaz. Cambios internos no afectan a clientes si se mantiene el contrato. El Polimorfismo usa una interfaz común para acceder a diferentes implementaciones. El Protocolo de Servidor de Lenguaje (LSP) facilita la comunicación entre editores y servidores, mejorando la interoperabilidad y eficiencia en el desarrollo de herramientas independientes del editor. Estos conceptos fundamentales en ingeniería de software contribuyen a código más mantenible y flexible.

已翻译

赞
Andrew Diniz da Costa, D.Sc.

Apple Distinguished Educator, Teacher and Researcher at Pontificia Universidade Católica do Rio de Janeiro
举报内容
LSP é um dos princípios do SOLID. Ele garante que subclasses possam ser usadas de maneira transparente no lugar das classes base, mantendo o mesmo comportamento esperado. Isso promove consistência e previsibilidade no código. Além disso, classes derivadas que respeitam o LSP s?o mais fáceis de testar, pois seu comportamento é previsível. Além disso, a manuten??o do código torna-se menos propensa a introduzir erros quando novas subclasses s?o adicionadas. Ao seguir o LSP, os desenvolvedores contribuem para a constru??o de sistemas mais robustos, menos propensos a bugs causados por substitui??es inseguras de objetos. Essa prática também promove a coes?o e a flexibilidade do código.

已翻译

赞
Marcos Kalinowski

Professor of Software/AI Engineering at the Department of Informatics of PUC-Rio. Coordinator of the ExACTa PUC-Rio Lab. CNPq Research Fellow 1D. FAPERJ Scientist of Rio de Janeiro State.
(已编辑)
举报内容
LSP is one of the five SOLID principles of object-oriented programming. It is named after Barbara Liskov, who introduced it in a 1987 paper. It is a very simple principle that relates to strong behavioral subtyping (the parent class should have the same interface as its child classes). This allows you to express your programs referring to the abstraction (the parent class), which in turn is known as the Dependency Inversion Principle (DIP). As a researcher active in software engineering, I have seen several investigations on the benefits and have also conducted some myself. The benefits include code reusability, behavioral consistency, ease of maintenance, facilitating polymorphism, and improving testability.

已翻译

赞
Lalit W.

Software Engineer @360T | MSc Automotive SW Engineering | 5+ Years at Mercedes-Benz, Fiserv, Fraunhofer | Java, Spring, Kubernetes, Azure, Microservices | Seeking Roles in Germany & Europe
举报内容
Moreover,In large-scale software development, the Liskov Substitution Principle (LSP) crucially helps avoid bugs by ensuring subclasses can replace their parent classes seamlessly, maintaining system consistency. This uniformity is vital during system expansion or updates, as it keeps behavior predictable and stable. LSP also promotes software modularity, simplifying independent development, testing, and debugging, crucial for early bug detection. It also aids in clear maintenance by setting defined behavior expectations for system components. Essentially, LSP is a cornerstone in large-scale development, reducing bugs and enhancing team collaboration, ensuring the software remains robust and manageable.

已翻译

赞
Uche Powers

Solution Architect, AI/ML Engineer, Backend Engineer
举报内容
- Simplified testing: Confident that substituting instances of derived classes won't introduce unexpected behavior. - Interchangeability: Developers can use polymorphism effectively. - Facilitates design by contract: defining a clear agreement between classes and clients. subclasses implicitly agree to uphold the contract defined by their base classes, ensuring that they provide compatible behavior.

已翻译

赞

2 How can you apply LSP?

To apply LSP, you should adhere to certain rules and guidelines when designing and implementing your classes and their relationships. For instance, make sure that your subclasses are compatible with their superclasses in terms of their methods, parameters, return types, and exceptions. You should also not change the signature or semantics of a method in a subclass unless you are overriding it to provide a more specific behavior. Additionally, do not add new preconditions or constraints to a method in a subclass that are not present in the superclass. Furthermore, do not remove or weaken the postconditions or guarantees of a method in a subclass that are present in the superclass. Lastly, do not introduce new or stronger invariants or assumptions in a subclass that are not present in the superclass. Following these rules will help ensure that your classes remain consistent with each other.

添加您的观点

Uche Powers

Solution Architect, AI/ML Engineer, Backend Engineer
举报内容
To stick to the Liskov Substitution Principle (LSP), just make sure when you design and create classes and subclasses, they can be swapped without messing up how the program works. Keep it smooth and correct!

已翻译

赞

3 How can you test LSP?

One way to test if your classes follow LSP is to use the substitution test. This test involves replacing a superclass object with a subclass object in any context where the superclass object is expected, and checking if the program still works as intended. For example, if you have a superclass called Animal and a subclass called Dog, you can replace any Animal object with a Dog object in any code that uses Animal methods or properties, and see if the code still behaves correctly. If not, then you have violated LSP.

添加您的观点

Uche Powers

Solution Architect, AI/ML Engineer, Backend Engineer
(已编辑)
举报内容
- Unit Test Test your class and subclass methods individually to ensure they behave as expected and follow the contracts defined by the base class. - Test Substitution Test to ensure that substituting a subclass for the base class doesn't create unexpected behaviors in program #bug

已翻译

赞

4 How can you fix LSP violations?

If you find that your classes violate LSP, you have two main options to fix them: refactoring or redesigning. Refactoring means changing the structure and code of your classes without changing their functionality or behavior. This can involve renaming methods, changing parameters, adding or removing methods, or moving methods to different classes. Redesigning means changing the functionality or behavior of your classes, as well as their structure and code. This can involve creating new classes, deleting old classes, changing inheritance relationships, or using different design patterns.

添加您的观点

5 What are some examples of LSP?

To illustrate LSP, let's look at some examples of classes that follow or violate it. Suppose you have a superclass called Shape and two subclasses called Rectangle and Square. A possible implementation of these classes is:

class Shape:
  def area(self):
    pass
class Rectangle(Shape):
  def __init__(self, length, width):
    self.length = length
    self.width = width
  
  def area(self):
    return self.length * self.width
class Square(Rectangle):
  def __init__(self, side):
    super().__init__(side, side)

This implementation violates LSP, because the Square class inherits from the Rectangle class, but does not behave like a rectangle. For example, if you try to change the length or width of a square object, you will also change the other dimension, which is not expected for a rectangle object. A better implementation would be to make Square inherit from Shape directly, or to use a different design pattern, such as composition or delegation, to reuse the code of Rectangle.

Another example is a superclass called Bird and two subclasses called Duck and Penguin. A possible implementation of these classes is:

class Bird:
  def fly(self):
    print("I can fly")
class Duck(Bird):
  def quack(self):
    print("I can quack")
class Penguin(Bird):
  def fly(self):
    print("I cannot fly")

This implementation also violates LSP, because the Penguin class overrides the fly method of the Bird class, but changes its behavior completely. For example, if you try to call the fly method on a penguin object, you will get a different output than on a duck object, which is not expected for a bird object. A better implementation would be to create a separate interface or abstract class for flying birds, or to use a different design pattern, such as strategy or state, to handle the different behaviors of birds.

添加您的观点

6 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?

添加您的观点

Marcos Kalinowski

Professor of Software/AI Engineering at the Department of Informatics of PUC-Rio. Coordinator of the ExACTa PUC-Rio Lab. CNPq Research Fellow 1D. FAPERJ Scientist of Rio de Janeiro State.
(已编辑)
举报内容
The SOLID principles are strongly related to each other. Ideally, a good programmer should be aware of all five of them. For instance, LSP supports the Open-Closed Principle (OCP), and together, they encourage designs that are open for extension but closed for modification. This means that you can add new functionality without altering existing code. The Single Responsibility Principle (SRP) and the Interface Segregation Principle (ISP) also facilitate LSP, as simpler interfaces will make it easier to adhere the interface of the base class to the interface of the subclasses. As you can see, my comments ended up citing all five SOLID principles because of their natural entanglement and synergy to help write clean code.

已翻译

赞

Software Engineering

+ 关注

给文章评分

我们借助人工智能创建了此文章。您认为这篇文章怎么样？

很棒不太好

举报此文章

查看全部

How can you use the Liskov Substitution Principle to avoid software bugs?

1

2

3

4

5

6

1 What are the benefits of LSP?

2 How can you apply LSP?

3 How can you test LSP?

4 How can you fix LSP violations?

5 What are some examples of LSP?

6 Here’s what else to consider

Software Engineering

给文章评分

感谢您的反馈

更多Software Engineering相关文章

更多相关阅读内容