Sobes.tech
Senior

O que é o princípio de substituição de Barbara Liskov (LSP) e como é aplicado no desenvolvimento em Python?

sobes.tech IA

Resposta da IA

O princípio LSP (Princípio da Substituição de Liskov) afirma que objetos de uma classe base (pai) devem poder ser substituídos por objetos de uma subclasse sem alterar a correção do programa. Isso significa que, se a classe B é uma subclasse da classe A, onde se espera um objeto da classe A, pode-se usar com segurança um objeto da classe B.

Aplicação em Python:

  1. Herança sem alterar o comportamento: As subclasses devem ampliar a funcionalidade, não modificá-la ou violá-la.

    # Bom: Square é um Rectangle onde a largura == altura
    class Rectangle:
        def __init__(self, width, height):
            self.width = width
            self.height = height
    
        def area(self):
            return self.width * self.height
    
        def set_width(self, width):
            self.width = width
    
        def set_height(self, height):
            self.height = height
    
    class Square(Rectangle):
        def __init__(self, side):
            super().__init__(side, side)
    
        def set_width(self, width):
            super().set_width(width)
            super().set_height(width)
    
        def set_height(self, height):
            super().set_width(height)
            super().set_height(height)
    
    # Mau: Se set_width e set_height em Square não forem adaptados para Square,
    # o comportamento de area() pode tornar-se ilógico ao usar Square
    # onde se esperava um Rectangle.
    
  2. Assinaturas de métodos iguais: Os métodos nas subclasses devem manter a compatibilidade de assinaturas com os métodos na classe base (quantidade e tipos de argumentos, valor de retorno).

  3. Exceções inesperadas: As subclasses não devem lançar exceções que a classe base não declarou (se isso for possível em Python, que é menos formal do que linguagens com tipagem estrita de exceções, mas o princípio permanece).

  4. Manutenção dos invariantes: As subclasses devem manter os invariantes (condições que sempre devem permanecer verdadeiras) da classe base.

A violação do LSP muitas vezes leva a comportamentos inesperados do programa e dificulta sua manutenção.