O que é abstração na Orientação a Objetos – Parte I

Fala, meus consagrados! Beleza?

A abstração é um dos pilares fundamentais da Programação Orientada a Objetos, ao lado do encapsulamento, da herança e do polimorfismo. Seu principal objetivo é permitir que o desenvolvedor represente, no código, elementos do mundo real de forma simplificada, destacando apenas as características essenciais para o problema que está sendo resolvido e ignorando detalhes que não são relevantes naquele momento.

Em outras palavras, abstrair significa observar uma entidade, identificar aquilo que realmente importa para o sistema e transformar essa visão em classes, atributos e métodos. Por exemplo, ao modelar um sistema de controle acadêmico, uma entidade “Aluno” pode ser representada por atributos como nome, matrícula, curso e situação. Não é necessário representar todos os detalhes da pessoa no mundo real, como altura, cor dos olhos ou preferências pessoais, a menos que essas informações sejam relevantes para o domínio do sistema.

Segundo o material de referência, a abstração permite que os desenvolvedores se concentrem inicialmente no que um objeto é e no que ele faz, antes de decidir como ele será implementado internamente. Isso ajuda a simplificar a complexidade dos sistemas de software e favorece a organização do código.

Na Orientação a Objetos, a abstração é o processo de representar conceitos do mundo real por meio de modelos computacionais. Esses modelos são construídos principalmente com classes e objetos.

A classe funciona como um modelo geral. Ela descreve quais informações um objeto deve possuir e quais comportamentos ele pode executar. O objeto, por sua vez, é uma instância concreta dessa classe.

Por exemplo, considere a classe Carro. Em um sistema, talvez não seja necessário representar todos os componentes internos de um carro, como pistões, válvulas, sensores, sistema de transmissão ou funcionamento detalhado do motor. Pode ser suficiente representar apenas aspectos relevantes, como marca, modelo, velocidade atual, ligar, desligar e acelerar.

public class Carro {
    private String marca;
    private String modelo;
    private int velocidade;

    public void ligar() {
        System.out.println("O carro foi ligado.");
    }

    public void acelerar() {
        velocidade += 10;
        System.out.println(velocidade + " km/h");
    }

    public void desligar() {
        System.out.println("O carro foi desligado.");
    }
}

Nesse exemplo, a classe Carro não mostra todos os detalhes internos de funcionamento do veículo. Ela apresenta uma visão simplificada, adequada ao contexto do sistema. Essa é a essência da abstração.

O uso da abstração começa pela identificação das entidades relevantes do domínio do problema. Em um sistema de biblioteca, por exemplo, entidades como Livro, Usuario, Emprestimo e Bibliotecario podem ser importantes. Em um sistema de vendas, podem aparecer entidades como Cliente, Produto, Pedido e Pagamento.

Depois de identificar essas entidades, o próximo passo é criar classes que representem cada uma delas. Cada classe deve possuir atributos, que representam dados, e métodos, que representam comportamentos.

Veja um exemplo simples:

public class Produto {
    private String nome;
    private double preco;
    private int quantidadeEmEstoque;

    public void atualizarEstoque(int quantidade) {
        quantidadeEmEstoque += quantidade;
    }

    public double calcularValorTotalEmEstoque() {
        return preco * quantidadeEmEstoque;
    }
}

Nesse exemplo, a classe Produto abstrai uma entidade do mundo real. O sistema não precisa saber todos os detalhes físicos ou comerciais do produto, mas apenas os dados e comportamentos necessários para cumprir sua finalidade.

Embora abstração e encapsulamento sejam conceitos diferentes, eles estão fortemente relacionados.

A abstração se preocupa em definir o que uma entidade representa e quais comportamentos ela oferece. O encapsulamento, por sua vez, se preocupa em proteger os detalhes internos dessa entidade, controlando o acesso aos seus atributos e métodos.

No exemplo abaixo, a classe ContaBancaria abstrai uma conta bancária e encapsula o saldo, impedindo acesso direto ao atributo:

public class ContaBancaria {
    private double saldo;

    public void depositar(double valor) {
        if (valor > 0) {
            saldo += valor;
        }
    }

    public void sacar(double valor) {
        if (valor > 0 && valor <= saldo) {
            saldo -= valor;
        }
    }

    public double getSaldo() {
        return saldo;
    }
}

O usuário da classe não precisa saber como o saldo é armazenado internamente. Ele apenas utiliza os métodos disponíveis: depositar(), sacar() e getSaldo(). Assim, a abstração oferece uma visão simplificada da conta, enquanto o encapsulamento protege seus detalhes internos.

Abstração com classes abstratas

Em Java, a abstração pode ser implementada por meio de classes abstratas. Uma classe abstrata é uma classe que não pode ser instanciada diretamente e pode conter métodos abstratos, isto é, métodos sem implementação.

Ela é útil quando se deseja criar um modelo geral para outras classes mais específicas.

public abstract class Funcionario {
    protected String nome;
    protected double salarioBase;

    public abstract double calcularSalario();
}

A classe Funcionario representa uma ideia geral. Porém, o cálculo do salário pode variar conforme o tipo de funcionário. Por isso, o método calcularSalario() é abstrato.

public class Gerente extends Funcionario {
    private double bonus;

    @Override
    public double calcularSalario() {
        return salarioBase + bonus;
    }
}
public class Vendedor extends Funcionario {
    private double comissao;

    @Override
    public double calcularSalario() {
        return salarioBase + comissao;
    }
}

Aqui, Funcionario abstrai características comuns, enquanto Gerente e Vendedor implementam comportamentos específicos.

Abstração com interfaces

Outra forma de aplicar abstração em Java é por meio de interfaces. Uma interface define um contrato que deve ser seguido pelas classes que a implementam.

public interface Pagamento {
    void processarPagamento(double valor);
}

Diferentes classes podem implementar essa interface de maneiras distintas:

public class PagamentoCartao implements Pagamento {
    @Override
    public void processarPagamento(double valor) {
        System.out.println("Pagamento de R$ " + valor + " realizado no cartão.");
    }
}
public class PagamentoPix implements Pagamento {
    @Override
    public void processarPagamento(double valor) {
        System.out.println("Pagamento de R$ " + valor + " realizado via Pix.");
    }
}

Nesse caso, a interface Pagamento abstrai o comportamento de pagamento. O sistema pode trabalhar com diferentes formas de pagamento sem depender diretamente dos detalhes de cada implementação.

Benefícios da abstração

A abstração traz vários benefícios ao desenvolvimento de software. Um dos principais é a simplificação da complexidade. Sistemas reais podem ser muito grandes e difíceis de compreender. A abstração permite dividir essa complexidade em partes menores, mais claras e mais fáceis de manipular.

Outro benefício é a reutilização de código. Quando uma classe ou interface representa bem um conceito, ela pode ser reaproveitada em diferentes partes do sistema ou até em outros projetos.

A abstração também melhora a manutenibilidade. Como os detalhes internos ficam separados da visão externa do objeto, torna-se mais fácil alterar a implementação sem impactar diretamente outras partes do sistema.

Além disso, a abstração favorece a modelagem do mundo real, pois aproxima o código dos conceitos existentes no domínio do problema. Isso facilita a comunicação entre desenvolvedores, analistas, usuários e demais envolvidos no projeto.

Exemplo prático: sistema de controle de estudos

Considere um sistema para controle de estudos. Algumas entidades relevantes poderiam ser:

• Aluno;
• Curso;
• Aula;
• PlanoDeEstudo;
• Atividade;
• Progresso.

A classe Curso, por exemplo, poderia ser modelada da seguinte forma:

public class Curso {
    private String nome;
    private int cargaHoraria;
    private String situacao;

    public void iniciarCurso() {
        situacao = "Iniciado";
    }

    public void concluirCurso() {
        situacao = "Concluído";
    }

    public boolean estaConcluido() {
        return situacao.equals("Concluído");
    }
}

Essa classe não representa todos os detalhes possíveis de um curso real. Ela representa apenas os elementos necessários para o sistema de controle de estudos. Portanto, trata-se de uma abstração.

Abstração em diferentes níveis

A abstração pode ocorrer em vários níveis. No nível mais básico, temos atributos e métodos de uma classe. Em um nível mais alto, temos classes que representam entidades do domínio. Em sistemas maiores, também podemos abstrair módulos, camadas, componentes e serviços.

Por exemplo, em uma aplicação web, pode haver uma camada de controle, uma camada de serviço e uma camada de acesso a dados. Cada camada abstrai uma responsabilidade específica do sistema:

• a camada de controle recebe requisições;
• a camada de serviço executa regras de negócio;
• a camada de persistência acessa o banco de dados.

Essa organização torna o sistema mais compreensível, modular e escalável.

Abstração e evolução do software

Uma boa abstração não surge necessariamente perfeita desde o início. Conforme o sistema evolui, novas regras de negócio aparecem, novos requisitos são descobertos e algumas decisões precisam ser revistas.

Por isso, a abstração deve ser refinada continuamente. Classes podem ser divididas, métodos podem ser reorganizados, interfaces podem ser criadas e responsabilidades podem ser redistribuídas. Esse processo faz parte da evolução natural do software.

Uma abstração mal feita pode gerar classes genéricas demais, acoplamento excessivo ou dificuldade de manutenção. Por outro lado, uma abstração bem construída torna o sistema mais flexível, compreensível e preparado para mudanças.

Conclusão

A abstração é um dos conceitos mais importantes da Orientação a Objetos porque permite representar problemas complexos de forma mais simples, organizada e próxima do mundo real. Ela ajuda o desenvolvedor a focar nos aspectos essenciais de uma entidade, deixando detalhes internos ou irrelevantes em segundo plano.

Por meio da abstração, criamos classes, objetos, métodos, classes abstratas e interfaces que representam conceitos importantes do domínio do problema. Isso favorece a clareza do código, a reutilização, a manutenção, a colaboração entre equipes e a evolução do sistema.

Em síntese, abstrair é transformar a complexidade do mundo real em modelos compreensíveis e úteis para o software. Quanto melhor for a abstração, mais claro, flexível e sustentável será o sistema desenvolvido.

Espero que tenham gostado! 

Forte abraço e até a próxima jornada!

Professor Rogerão Araújo