Open-Closed Principle

OCP é um modo de escrever algoritmo. Invés de implementar um algoritmo diretamente, damos instruções de como esse algoritmo deve ser escrito.

Categoria de Programação

Postado em 14 abril 2022

Atualizado em 14 abril 2022

Visualizações: 443

O princípio aberto-fechado é um modo de escrever código extremamente útil para softwares a longo prazo.

Em inglês, Open/Closed Principe.
Abreviado, OCP.

Softwares estão sujeitos a constantes modificações, seja por adição de novas funcionalidades ou alteração de algoritmo.

Uma empresa que possui softwares nem sempre vai continuar com os mesmos programadores para fazer a manutenção desse software.

Um software que possui um algoritmo mal planejado pode trazer muitos problemas como bugs inesperados e consumo de tempo.

Se usarmos o princípio aberto-fechado é possível diminuir essa dor de cabeça consideravelmente.

O que é OCP?

OCP é um modo de escrever algoritmo. Invés de implementar um algoritmo diretamente, damos instruções de como esse algoritmo deve ser escrito.

Uma vez que uma classe estende uma interface ou uma classe abstrata, essa mesma deverá seguir as regras de implementação de sua extensão.

Um bom exemplo é o vídeo game. A entrada para conectar o controle no console tem que ser compatível com controle que temos em mãos, caso contrário não é possível fazer a conexão.
Por mais que o controle seja customizado, se sua entrada de conexão for compatível com a do console, a sua utilização é possível.

No OCP isso funciona da mesma forma. Essas regras são obrigatórias para podermos ter o objeto funcionando.

Utilização

O código deve estar aberto para extensões e fechado para modificações

Em outras palavras, caso haja a necessidade de adicionar uma nova funcionalidade ao software, a modificação do código já existente é proibido.

A nova funcionalidade deverá ser implementada apenas adicionando código.

Para fazer isso é necessário levar em consideração 4 elementos.

  • Algoritmo: Aplicações no mundo real
  • Interface: Estratégia
  • Contexto: Situação que o algoritmo será executado
  • Cliente: Irá executar o contexto

Na prática

Imagine que temos um software totalmente inovador de entrega de mercadorias. Essas mercadorias podem ser entregues de bicicleta. O código para esse software se baseando no OCP seria:

// Estratégia
interface Locomocao {
    public function processarEntrega();
}

class Bicicleta implements Locomocao {
    public function processarEntrega()
    {
        // Processar entrega
    }
}

// Contexto
class Entrega {
    private $locomocao: Locomocao;
    
    public function __construct(Locomocao $locomocao) {
        $this->locomocao = $locomocao;
    }
    
    public function executar() {
        return $this->locomocao->processarEntrega();
    }
}

// Cliente
class Tela {
    public function iniciarEntrega($meioDeEntrega) {
        if ($meioDeEntrega == 'Bicicleta') {
            $entrega = new Entrega(new Bicicleta());
        }
        
		$response = $entrega->executar();
    }
}

Vamos dizer que esse software foi um grande sucesso. Com isso, entregadores que usam motos também passaram a querer fazer entregas. Logo, entregadores que usam carros também quiseram entrar nessa.

Nesse exemplo é possível observar que teremos que adicionar duas funcionalidades.
Isso é:

  • Algoritmo das entregas de moto
  • Algoritmo das entregas de carro

Com a adição dessas duas funcionalidades adicionaremos duas classes.

...

class Moto implements Locomocao {
    public function processarEntrega() {
        // Processar entrega
    }
}

class Carro implements Locomocao {
    public function processarEntrega() {
        // Processar entrega
    }
}

...

O cliente no final será:

...

// Cliente
class Tela {
    public function iniciarEntrega($meioDeEntrega) {
        if ($meioDeEntrega == 'Bicicleta') {
            $entrega = new Entrega(new Bicicleta());
        }
        
        if ($meioDeEntrega == 'Moto') {
            $entrega = new Entrega(new Moto());
        }
        
        if ($meioDeEntrega == 'Carro') {
            $entrega = new Entrega(new Carro());
        }
        
        $response = $entrega->executar();
    }
}

Conclusão

É possível observar que não houve a necessidade de modificar o algoritmo já existente, esse é o objetivo do OCP.