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

Fala, meus consagrados! Beleza?

Aqui no blog, temos a parte I sobre a abstração. Relembrando, 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.

Vamos continuar nosso estudo sobre abstração!

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.

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("R$ " + valor + " no cartão.");
    }
}
public class PagamentoPix implements Pagamento {
    @Override
    public void processarPagamento(double valor) {
        System.out.println("R$ " + valor + " 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.

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.

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.

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.

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