Princípios SOLID em Java para Iniciantes

Os Princípios SOLID são diretrizes essenciais para desenvolver código flexível e sustentável. No entanto, neste artigo, vamos desmistificar os Princípios SOLID em Java para Iniciantes, proporcionando exemplos práticos para ajudar iniciantes a compreender e aplicar esses conceitos fundamentais.

Princípio da Responsabilidade Única (SRP)

O SRP preconiza que uma classe deve ter apenas uma razão para mudar. Isso implica em dividir responsabilidades. Portanto, vejamos um exemplo:

// Exemplo aplicando SRP
class Pedido {
    void calcularTotal() {
        // Lógica para calcular o total do pedido
    }

    void gerarNotaFiscal() {
        // Lógica para gerar a nota fiscal
    }
}

Princípio Aberto/Fechado (OCP)

O OCP propõe que uma classe deve estar aberta para extensão, mas fechada para modificação. Utilizamos interfaces e herança para alcançar isso, por exemplo:

// Exemplo aplicando OCP
interface Forma {
    double calcularArea();
}

class Quadrado implements Forma {
    double lado;

    Quadrado(double lado) {
        this.lado = lado;
    }

    @Override
    public double calcularArea() {
        return lado * lado;
    }
}

Princípio de Substituição de Liskov (LSP)

O LSP sugere que objetos de uma classe base devem ser substituíveis por objetos de suas subclasses sem afetar a integridade do programa. Vejamos um exemplo:

// Exemplo aplicando LSP
class Retangulo {
    int largura;
    int altura;

    int calcularArea() {
        return largura * altura;
    }
}

class Quadrado extends Retangulo {
    @Override
    void setAltura(int altura) {
        this.altura = altura;
        this.largura = altura;
    }
}

Princípio de Segregação de Interface (ISP)

O ISP preconiza que uma classe não deve ser forçada a implementar interfaces que ela não utiliza. Vamos ver um exemplo:

// Exemplo aplicando ISP
interface Trabalhador {
    void trabalhar();
}

interface Comedor {
    void comer();
}

class Operario implements Trabalhador, Comedor {
    @Override
    public void trabalhar() {
        // Lógica de trabalho
    }

    @Override
    public void comer() {
        // Lógica de comer
    }
}

Princípio da Inversão de Dependência (DIP)

O DIP propõe que módulos de alto nível não devem depender de módulos de baixo nível, ambos devem depender de abstrações. Vejamos um exemplo:

// Exemplo aplicando DIP
interface Logger {
    void log(String mensagem);
}

class ConsoleLogger implements Logger {
    @Override
    public void log(String mensagem) {
        System.out.println("Log no console: " + mensagem);
    }
}

class Aplicacao {
    private final Logger logger;

    Aplicacao(Logger logger) {
        this.logger = logger;
    }

    void executar() {
        // Lógica da aplicação
        logger.log("Executando a aplicação");
    }
}

Conclusão

Entender e aplicar os Princípios SOLID é fundamental para criar código robusto e fácil de manter em Java. Este artigo ofereceu exemplos práticos para ilustrar o SRP, OCP, LSP, ISP e DIP.

Confira a documentação oficial da linguagem Java clicando aqui. Porém, você também pode aprender mais sobre programação clicando aqui.