SOLID - OCP - TheLazy.Dev

Princípio do aberto/fechado

Entidades de software devem ser abertas para extensão, mas fechadas para modificação.

Se você precisa adicionar uma nova funcionalidade, então é melhor estender do que modificar.

Por exemplo:

Temos uma classe Veiculo que recebe no seu construtor um tipo de veículo e dentro dela o método Ligar() que tem uma sequência de condicionais que verifica o tipo do veículo e realiza a operação adaptada a ele. Sendo assim, toda vez que for adicionado um novo veiculo, nós precisaríamos adicionar uma nova condição ao nosso método. Logo, nossa classe/método está aberta para modificação e estamos quebrando o princípio do aberto/fechado.

    public class Veiculo
    {
        private readonly TipoVeiculoEnum _tipoVeiculo;

        public Veiculo(TipoVeiculoEnum tipoVeiculo)
        {
            _tipoVeiculo = tipoVeiculo;
        }

        public string Nome { get; set; }

        public void Ligar()                             
        {
            if (_tipoVeiculo == TipoVeiculoEnum.Carro)
            {
                Console.WriteLine("Carro pronto para ser dirigido");
            }
            if (_tipoVeiculo == TipoVeiculoEnum.Moto)
            {
                Console.WriteLine("Moto pronta para ser pilotada");
            }
        }
    }

Para um exemplo de um método que utilize a Veiculo, criei uma classe LavaRapido com um método Lavar() que recebe um tipo de Veiculo

    public class LavaRapido
    {
        public void Lavar(Veiculo veiculo)
        {
            Console.WriteLine($"Lavando o veiculo {veiculo.Nome}");
        }
    }

var moto = new Veiculo(TipoVeiculoEnum.Moto);
moto.Ligar();

var lavaRapido = new LavaRapido();
lavaRapido.Lavar(moto);

Solução:

Podemos criar a classe abstrata Veiculo com seu método abstrato Ligar() e para cada novo veiculo que formos adicionando ao nosso projeto, criamos uma classe para ele, herdamos a classe Veiculo e sobrescrevemos o método Ligar() de acordo com as necessidades do veículo.

    public abstract class Veiculo
    {
        public string Nome { get; set; }
        public abstract void Ligar();
    }

    public class Moto : Veiculo
    {
        public override void Ligar()
        {
            Console.WriteLine("Moto pronta para ser pilotada");
        }
    }

    public class Carro : Veiculo
    {
        public override void Ligar()
        {
            Console.WriteLine("Carro pronto para ser dirigido");
        }
    }

O método Lavar() da classe LavaRapido não deixa de funcionar, pois tanto a classe Moto quanto a classe Carro são subtipos de Veiculo.

var moto = new Moto();
var carro = new Carro();
moto.Ligar();
carro.Ligar();

var lavaRapido = new LavaRapido();
lavaRapido.Lavar(moto);
lavaRapido.Lavar(carro);

Blog

SOLID - OCP

Giovanne Barbosa

Join Our Newsletter. No Spam, Only the good stuff.

Related