2
respostas

Estou estudando sobre SOLID e queria tirar uma duvida sobre LSP.

Eu fiz um exemplo em Flutter e gostaria de saber se ele estaria cumprindo esse princípio da forma correta.

class Funcionario {
  void salario(){}
}

class FuncionarioComissionado extends Funcionario {
  @override
  void salario() {
    // TODO: implement salario
    super.salario();
  }

  void comissao(){}
}

class Gerente extends FuncionarioComissionado {
  @override
  void salario() {
    // TODO: implement salario
    super.salario();
  }

  @override
  void comissao() {
    // TODO: implement comissao
    super.comissao();
  }
}

class Vendedor extends FuncionarioComissionado {
  @override
  void salario() {
    // TODO: implement salario
    super.salario();
  }

  @override
  void comissao() {
    // TODO: implement comissao
    super.comissao();
  }  
}

class Recepcionista extends Funcionario {
  @override
  void salario() {
    // TODO: implement salario
    super.salario();
  }
}

Como podem ver no exemplo a classe principal Funcionario, inicialmente teria os métodos salario() e comissao() que seria extendida para Recepcionista e Vendedor. Mas caso fosse extendida para a classe Recepcionista, não estaria cumprindo a LSP, pois não faria sentido ter o método de comissão para a classe Recepcionista. Seguindo o princípio LSP, o método comissao() iria para a classe Vendedor, dessa forma mantendo a classe vendedor executando os métodos necessários para ela e a classe Recepcionista executando apenas o que se refere há ela na classe Funcionario com o método salario().

Eu pensei "e se alguém quiser incluir a classe Gerente" como que fica?

Criei então a classe FuncionarioComissionado que extend de Funcionario, recebendo então o método salario() e agregando o método comissao() para essa classe. Assim extendi a classe FuncionarioComissionado para as classes Gerente e Vendedor para que possasm executar os métodos salario() e comissao() e extendi a classe Funcionario para a classe Recepcionista, mantendo o princípio de Liskov.

Minha duvida é... Está correto o que eu fiz ou errei em alguma parte? Esse é o caminho?

2 respostas

Oi Ricardo! Tudo bem?

Primeiro, parabéns por estar se aprofundando nos princípios SOLID! O Princípio da Substituição de Liskov (LSP) é realmente importante para garantir que nossas classes derivadas possam substituir suas classes base sem quebrar a funcionalidade do programa.

Vamos analisar seu código e ver se ele está de acordo com o LSP.

A ideia principal do LSP é que uma subclasse deve ser substituível por sua superclasse sem que o comportamento do programa seja alterado. Ou seja, qualquer instância da subclasse deve poder ser usada no lugar de uma instância da superclasse sem causar problemas.

No seu exemplo, você criou uma hierarquia de classes onde:

  • Funcionario é a classe base.
  • FuncionarioComissionado herda de Funcionario e adiciona o método comissao().
  • Gerente e Vendedor herdam de FuncionarioComissionado.
  • Recepcionista herda diretamente de Funcionario.

Essa estrutura parece estar correta em termos de LSP, pois:

  • FuncionarioComissionado adiciona um comportamento específico (comissao()) que faz sentido para Gerente e Vendedor, mas não para Recepcionista.
  • Recepcionista herda apenas de Funcionario, o que significa que ela não precisa implementar o método comissao(), mantendo a substituibilidade.

No entanto, há um ponto a ser considerado: o uso de super.salario() e super.comissao() nas subclasses. Se a implementação desses métodos na classe base (Funcionario) não fizer nada (como está no seu exemplo), chamá-los nas subclasses pode ser desnecessário e confuso.

Abraços e bons estudos!

Entendi! Com relação a "super.salario()" e "super.comissao()", vem por padrão quando eu implemento os métodos. No momento que eu escrevo o código desses métodos, eu apago esses "super's".

Obrigado pela explicação e fico feliz por ter compreendido bem a ideia.