Tecnologia #20 - Crie códigos limpos e de fácil manutenção

Escrito por Raviel Chausse Silveira .

O SOLID é um acrônimo que se refere a cinco princípios da programação orientada a objetos que foram apresentados por Robert C. Martin em 2000. Esses princípios foram criados com o objetivo de ajudar os desenvolvedores a escreverem códigos mais legíveis, sustentáveis e de fácil manutenção. 

História do SOLID 

Antes do SOLID, a programação orientada a objetos estava ganhando popularidade, mas muitos desenvolvedores não sabiam como aplicar os conceitos de OO (Orientação a Objetos) de forma efetiva e acabavam escrevendo códigos confusos e difíceis de entender. Foi aí que Robert C. Martin, também conhecido como Uncle Bob, criou o SOLID como uma forma de guiar os desenvolvedores na criação de código limpo e de qualidade. 

Os cinco princípios SOLID são: 

• Single Responsibility Principle (SRP) - Princípio da Responsabilidade Única; 

• Open-Closed Principle (OCP) - Princípio Aberto-Fechado; 
• Liskov Substitution Principle (LSP) - Princípio da Substituição de Liskov; 
• Interface Segregation Principle (ISP) - Princípio da Segregação de Interfaces; 
• Dependency Inversion Principle (DIP) - Princípio da Inversão de Dependência. 

Ao seguir estes princípios do SOLID, desenvolvedores conseguem resolver vários problemas comuns que encontramos ao escrever um código orientado a objetos. Alguns desses problemas incluem: 

• Código difícil de entender e manter: ao seguir o SRP, o código é dividido em classes e métodos menores e mais especializados, tornando mais fácil o entendimento sobre o que cada um faz e a correção de bugs;   
• Dificuldade em adicionar novos recursos: o OCP torna o código mais flexível, permitindo que novos recursos sejam adicionados sem que seja preciso modificar o código já existente;   
• Classes filhas que não funcionam corretamente: o LSP garante que as classes filhas possam ser substituídas por suas classes pai sem afetar o funcionamento do programa;   
• Interfaces excessivamente grandes: o ISP incentiva a criação de interfaces menores e mais especializadas, tornando mais fácil para as classes implementá-las e reduzindo a quantidade de códigos duplicados;   

• Código acoplado e difícil de testar: o DIP incentiva a criação de interfaces entre as classes, o que reduz o acoplamento e torna o código mais fácil de testar. Os princípios SOLID ajudam a reduzir o acoplamento, separando as responsabilidades das classes e tornando-as mais independentes. 

Exemplos práticos de uso do SOLID 

Os princípios SOLID podem ser aplicados em uma variedade de linguagens de programação e projetos. Alguns exemplos práticos de como usar os princípios SOLID incluem: 

Usando o SRP para dividir uma classe grande em classes menores e mais especializadas: Suponha que você esteja criando uma classe para enviar e-mails. Ao invés de incluir toda a lógica para gerar o conteúdo do e-mail e enviar o e-mail na mesma classe, você pode criar uma classe separada para gerar o conteúdo e outra classe para enviar o e-mail. Dessa forma, cada classe terá uma única responsabilidade, o que tornará o código mais fácil de entender e modificar. 

Usando o OCP para criar uma interface genérica para lidar com diferentes tipos de arquivos, permitindo que novos tipos de arquivos possam ser adicionados sem modificar o código já existente: Suponha que você esteja criando uma aplicação para gerenciar um inventário de produtos. Ao invés de escrever código para cada tipo de produto (por exemplo, roupas, eletrônicos, alimentos), você pode criar uma interface genérica para gerenciar qualquer tipo de produto. Em seguida, você pode criar classes separadas para cada tipo de produto que implementam essa interface. Dessa forma, você pode adicionar novos tipos de produtos sem precisar modificar o código existente. 

Usando o LSP para garantir que as classes filhas possam ser substituídas por suas classes pai sem afetar o funcionamento do programa: Suponha que você tenha uma classe "Retângulo" e uma classe "Quadrado", onde a classe "Quadrado" herda da classe "Retângulo". Se você definir o comprimento e a largura do quadrado como atributos separados, isso pode criar problemas quando você tentar calcular a área do quadrado. Ao invés disso, você pode criar uma classe "Figura" que tem métodos para calcular a área e a circunferência. Em seguida, você pode criar classes separadas para retângulos e quadrados, ambas implementando a interface "Figura". Dessa forma, o princípio LSP é respeitado e o cálculo da área do quadrado funcionará corretamente. 

Usando o ISP para criar interfaces menores e mais especializadas que reduzem a quantidade de código duplicado e tornam mais fácil para as classes implementá-las: Suponha que você esteja criando uma interface para um sistema de pagamento. Ao invés de criar uma interface genérica que abrange todos os métodos de pagamento possíveis, você pode criar interfaces separadas para cada método de pagamento (por exemplo, cartão de crédito, PayPal, transferência bancária). Dessa forma, as classes que implementam cada interface só precisam implementar os métodos relevantes para aquele método de pagamento, tornando o código mais coeso e com menos acoplamento. 

Usando o DIP para criar uma camada de abstração que permite que diferentes partes do código possam ser testadas independentemente: Suponha que você esteja criando uma classe para gerenciar uma conexão com um banco de dados. Ao invés de criar uma classe que dependa diretamente de um driver de banco de dados específico, você pode criar uma interface genérica para gerenciar a conexão com o banco de dados e usar a inversão de dependência para permitir que diferentes drivers de banco de dados sejam usados sem modificar o código existente. 

Os princípios SOLID são uma ferramenta essencial para garantir um código orientado a objetos de alta qualidade, fácil de entender e de manter. Ao aplicar esses princípios, você pode resolver problemas comuns na programação orientada a objetos, como acoplamento excessivo e dificuldade em adicionar novos recursos. Eles também são amplamente aplicáveis a diversos projetos e linguagens de programação, resultando em um código mais modular, coeso e escalável que pode ser atualizado com facilidade. Em resumo, os princípios SOLID permitem criar código mais limpo e de qualidade, que será mais fácil de manter e atualizar ao longo do tempo.