Os 4 Pilares da POO

0:00 / 0:00

Programação orientada a objetos organiza código em torno de classes e objetos. Os quatro pilares ajudam a entender como esses objetos protegem dados, reaproveitam estrutura, trocam implementação sem quebrar uso e escondem detalhes que não precisam aparecer o tempo todo.

Visão geral

Pilar	Ideia central	Pergunta prática
Encapsulamento	Proteger o estado interno do objeto.	Quem pode mexer nesse dado?
Herança	Reaproveitar estrutura de uma classe base.	Que comportamento vem pronto da classe mãe?
Polimorfismo	Usar objetos diferentes pelo mesmo contrato.	Posso chamar do mesmo jeito e deixar cada classe responder à sua maneira?
Abstração	Mostrar o essencial e esconder detalhe interno.	O que eu preciso saber para usar isso?

Encapsulamento — proteção do estado

Encapsular é não deixar qualquer parte do sistema mexer diretamente nos dados internos de um objeto. O objeto guarda seus atributos e expõe métodos controlados para leitura ou alteração.

public class Produto {
    private double preco;

    public void setPreco(double preco) {
        if (preco < 0) {
            throw new IllegalArgumentException("Preço não pode ser negativo");
        }
        this.preco = preco;
    }

    public double getPreco() {
        return preco;
    }
}

O atributo preco fica private. Quem está fora da classe não altera o preço diretamente; precisa passar por setPreco(), onde a regra de validação mora.

Herança — reaproveitar uma base

Herança permite criar uma classe que aproveita atributos e métodos de outra. Em Java, isso aparece com extends.

public class DepartamentoHome extends AppsRootAction {
    @Override
    public Effect execute() throws Exception {
        return render();
    }
}

DepartamentoHome herda recursos de AppsRootAction. Isso significa que a classe filha não precisa reinventar tudo: ela recebe uma base pronta e escreve apenas a parte específica dela.

Herança deve ser usada quando existe uma relação de tipo: a filha é uma versão especializada da classe mãe.

Polimorfismo — mesmo contrato, respostas diferentes

Polimorfismo é poder tratar objetos diferentes por uma interface ou classe comum, chamando o mesmo método, enquanto cada objeto executa sua própria versão.

public abstract class Acao {
    public abstract void executar();
}

public class SalvarProduto extends Acao {
    @Override
    public void executar() {
        System.out.println("Salvando produto");
    }
}

public class ExcluirProduto extends Acao {
    @Override
    public void executar() {
        System.out.println("Excluindo produto");
    }
}

O código pode chamar executar() sem saber se a ação concreta salva, exclui ou faz outra coisa. O contrato é o mesmo; a implementação muda conforme o objeto real.

Abstração — esconder o detalhe que não importa agora

Abstração é escolher o que aparece para quem usa uma classe. Ela mostra um jeito simples de usar algo e esconde a mecânica interna.

public class ProdutoModel {
    public void salvar(Produto produto) {
        validar(produto);
        gravarNoBanco(produto);
    }

    private void validar(Produto produto) {
        // regras internas
    }

    private void gravarNoBanco(Produto produto) {
        // detalhe interno de persistência
    }
}

Quem chama salvar(produto) não precisa saber cada detalhe de validação e gravação naquele momento. A classe oferece uma operação clara e deixa o miolo protegido.

Como diferenciar os pilares

Encapsulamento: controla acesso ao estado interno.
Herança: reaproveita uma base comum.
Polimorfismo: permite chamar pelo mesmo contrato e receber comportamentos diferentes.
Abstração: deixa visível só o necessário para usar uma peça.

Na prática, eles costumam aparecer juntos. Uma classe pode encapsular dados, herdar uma base, implementar um método polimórfico e ainda esconder detalhes por abstração.

Onde isso aparece no projeto

No XTtreinamento e no Jasap, esses pilares aparecem de forma bem concreta:

private, getters e setters em Beans ajudam no encapsulamento.
extends AppsRootAction, extends AppsRootDAO e extends PnlManager são exemplos de herança.
execute() em várias Actions mostra polimorfismo: o framework chama o mesmo método, mas cada Action responde de um jeito.
getFactory().departamento().produtoModel() abstrai a criação e acesso a objetos especializados.

Lição geral

Os quatro pilares não são decoração teórica. Eles são lentes para ler código Java com menos ruído.

Quando encontrar uma classe, pergunte: o que ela protege, de quem ela herda, qual contrato ela cumpre e quais detalhes ela esconde? Só essa leitura já torna o código bem mais navegável.