SOLID: Princípio Aberto-Fechado

Java SOLID

O Princípio Aberto-Fechado (Open-Closed Principle - OCP) é um dos princípios do SOLID, um conjunto de diretrizes para desenvolvimento de software que visam promover a modularidade, extensibilidade e manutenibilidade do código. O OCP estabelece que as entidades do software (classes, módulos, funções, etc.) devem estar abertas para extensão, mas fechadas para modificação direta. Neste artigo, exploraremos em detalhes o Princípio Aberto-Fechado e forneceremos exemplos de sua aplicação.

O que é o Princípio Aberto-Fechado (OCP)?

O Princípio Aberto-Fechado declara que as entidades do software devem ser projetadas de maneira a permitir que novos comportamentos sejam adicionados sem a necessidade de modificar o código existente. Isso significa que, ao estender as funcionalidades do sistema, devemos ser capazes de fazer isso através de adição de novas classes ou módulos, em vez de alterar o código existente.

Vantagens do OCP:

Extensibilidade: O OCP promove a extensibilidade do código, permitindo adicionar novos comportamentos e funcionalidades sem modificar o código existente. Isso facilita a evolução do sistema ao longo do tempo.
Manutenibilidade: Como o código existente não é modificado diretamente, há menos riscos de introduzir erros ou efeitos colaterais. Isso torna o código mais previsível e fácil de manter.
Reutilização: Com um design aberto para extensão, as classes e módulos podem ser reutilizados em diferentes contextos, promovendo um maior nível de modularidade e compartilhamento de código.
Testabilidade: O OCP facilita a realização de testes, já que novas funcionalidades podem ser adicionadas através da criação de novos testes, sem a necessidade de alterar os testes existentes.

Exemplos:

Exemplo de violação do OCP:

 class Shape {
     private String type;
    
     public void draw() {
         if (type.equals("circle")) {
             drawCircle();
         } else if (type.equals("rectangle")) {
             drawRectangle();
         } else if (type.equals("triangle")) {
             drawTriangle();
         }
     }
    
     private void drawCircle() {
         // Desenhar um círculo
     }
    
     private void drawRectangle() {
         // Desenhar um retângulo
     }
    
     private void drawTriangle() {
         // Desenhar um triângulo
     }
 }

Neste exemplo, a classe Shape viola o OCP, pois precisa ser modificada toda vez que um novo tipo de forma (como um hexágono) for adicionado. Isso causa acoplamento excessivo e dificulta a extensibilidade do código.

Exemplo de aplicação do OCP:

 interface Shape {
     void draw();
 }
    
 class Circle implements Shape {
     public void draw() {
         // Desenhar um círculo
     }
 }
    
 class Rectangle implements Shape {
     public void draw() {
         // Desenhar um retângulo
     }
 }
    
 class Triangle implements Shape {
     public void draw() {
         // Desenhar um triângulo
     }
 }

Neste exemplo, o OCP é aplicado corretamente. As formas são representadas por classes separadas que implementam a interface Shape. Ao adicionar um novo tipo de forma, basta criar uma nova classe que implementa a interface Shape e define seu próprio comportamento de desenho. Dessa forma, o código existente não precisa ser modificado, e a extensibilidade é mantida.

Conclusão

O Princípio Aberto-Fechado (OCP) é um princípio fundamental para o desenvolvimento de software modular e extensível. Ele promove a capacidade de estender o sistema sem modificar o código existente, facilitando a manutenção, reutilização e testabilidade do código. Os exemplos de aplicação mostram como é possível criar um código aderente ao OCP, permitindo a adição de novos comportamentos sem alterar o código já existente.

É importante lembrar que o OCP deve ser aplicado juntamente com outros princípios do SOLID para obter um sistema de software robusto, bem projetado e de fácil manutenção ao longo do tempo.

Um grande abraço e até o próximo post!