Pular para o conteúdo

Herança

Desvendando a Herança no Java: Do Conceito ao Código Impecável

Se você está mergulhando no universo da Programação Orientada a Objetos (POO), fatalmente já esbarrou no conceito de Herança.

Muitos desenvolvedores iniciantes compreendem a teoria, mas travam na hora de aplicar esse conceito na arquitetura de seus sistemas. Afinal, como as classes se comunicam? O que acontece nos bastidores da linguagem Java quando usamos a palavra “extends”? E como lidar com a segurança dos dados nesse processo?

Vamos desmistificar a Herança no Java. Vou traduzir os bastidores dessa estrutura para que você programe não apenas com base em tentativa e erro, mas com domínio arquitetônico. Vamos lá?


O conceito mais elementar ao analisarmos a relação entre uma superclasse (classe mãe) e uma subclasse (classe filha) é validar essa relação através da expressão “é um” (ou “é uma”).

Imagine duas classes: Conta Corrente e Conta Especial. Podemos dizer que uma Conta Especial é uma Conta Corrente? Sim! A frase soa natural, tem lógica e veracidade. Portanto, a herança está validada. Uma Conta Especial é apenas uma versão especializada de uma Conta Corrente. O mesmo vale se dissermos que um Vendedor é um Funcionário.

Por outro lado, tente aplicar a regra entre Vendedor e Notebook. Um Notebook não é um Vendedor, certo? Não há herança aqui. Mas, se dissermos que um Notebook é um Computador (assim como um Desktop também é), a relação volta a fazer sentido.

A herança nada mais é do que a capacidade de criar novas classes a partir de classes já existentes, herdando características genéricas (como peso e altura) e adicionando elementos exclusivos (como o tipo de motor ou um limite de crédito).

No Java, declaramos uma superclasse geralmente com o modificador public, garantindo sua visibilidade no sistema. Para criar a nossa subclasse, utilizamos a palavra reservada extends. Quando escrevemos public class Subclasse extends Superclasse, estamos dizendo ao compilador que a classe filha estende, expande e acrescenta funcionalidades à classe mãe.

Mas aqui entra um conceito implícito fascinante: absolutamente todas as classes em Java têm um ancestral comum.

Se você criar uma classe e não escrever nenhum “extends”, o Java, por padrão, adiciona um extends Object oculto no seu código. A classe Object é a raiz de toda a linguagem. É por isso que, mesmo em uma classe vazia que você acabou de criar, métodos como o equals (usado para comparar objetos, muito comum com Strings) já estão disponíveis. Eles foram herdados desse ancestral supremo.

Quando falamos de herança, um debate clássico de arquitetura vem à tona: o encapsulamento. Sabemos que a subclasse herda todos os membros da superclasse, mas ela não consegue acessar diretamente atributos marcados como private.

A literatura tradicional diz que você deve manter os atributos privados e usar métodos públicos (getters e setters) para acessá-los. Mas será que esse é o único caminho?

Imagine que nossa Conta Corrente tenha os atributos número, titular e saldo como private. A Conta Especial precisaria passar por uma burocracia de getters e setters para acessar dados que, teoricamente, também pertencem a ela. A alternativa inteligente aqui é usar o modificador protected.

O protected permite que a subclasse acesse as propriedades diretamente, sem quebrar a segurança para o resto do sistema. Pense em uma propriedade de senha. Uma senha é um dado sensível e jamais deveria ter um método “get” público. Se ela for private, a subclasse não a acessa. Se for protected, a subclasse pode manipulá-la de forma segura, sem expor o dado ao mundo exterior. A escolha entre private e protected dependerá sempre do bom senso e da arquitetura do seu projeto.

O Efeito Cascata dos Construtores e o “super()”

Seção intitulada “O Efeito Cascata dos Construtores e o “super()””

Aqui está um dos maiores segredos do Java que pega muito desenvolvedor de surpresa.

Imagine que você tem uma classe A. A classe B estende A. E a classe C estende B. Cada uma tem um construtor que imprime seu próprio nome na tela. Se você instanciar apenas a classe C, o que aparece no console? Apenas “Construtor de C”? Não! O Java imprimirá A, depois B, e só então C.

Por que isso acontece? Porque existe uma instrução oculta na primeira linha de todo método construtor: o super().

Enquanto a palavra this invoca elementos da própria classe, o super() chama o construtor da superclasse. E isso gera um efeito cascata de baixo para cima. O construtor de C chama o de B, que chama o de A, que por sua vez chama o construtor de Object! A execução real ocorre de cima para baixo. Isso faz todo o sentido arquitetônico: para construir a especialização, o Java precisa primeiro erguer as fundações (as superclasses).

Atenção: Se a sua superclasse não tiver um construtor padrão vazio (por exemplo, se a Conta Corrente exigir número, titular e saldo para ser criada), o super() oculto falhará. Nesse caso, você é obrigado a criar um construtor na Conta Especial e escrever a chamada explícita, como super(numero, titular, saldo), passando os parâmetros corretos na primeira linha do construtor da subclasse.

Sobrescrita de Métodos e a Ausência de Herança Múltipla

Seção intitulada “Sobrescrita de Métodos e a Ausência de Herança Múltipla”

Vale um adendo rápido: o Java não permite herança múltipla de classes (uma classe não pode ter duas superclasses diretas). Para contornar isso e dar múltiplas capacidades a um objeto, utilizamos as Interfaces.

Mas voltando à herança simples, o que fazemos quando o comportamento herdado não serve para a subclasse? Nós usamos a Sobrescrita de Métodos.

Na Conta Corrente, o método sacar() valida se o saque é menor ou igual ao saldo. Mas a Conta Especial possui um Limite! A lógica original não serve mais. Precisamos reescrever o método sacar() na Conta Especial, mantendo o mesmo nome e argumentos, mas injetando a nova regra de negócio que soma o saldo com o limite.

Em outros casos, queremos apenas adicionar algo à lógica original. No método consultarSaldo(), podemos usar a expressão super.consultarSaldo() dentro da subclasse. Note que aqui não tem parênteses vazios; estamos chamando o método da classe mãe para reaproveitar a string gerada por ela e, logo em seguida, concatenamos a informação do limite. É a reutilização de código em seu estado da arte!

Para encerrar nossa aula, precisamos falar sobre a palavra reservada final, que atua como um verdadeiro guardião na herança. Ela possui dois usos cruciais:

  1. Em métodos: Se você tem um método crítico, como validaSenha(), permitir que uma subclasse o sobrescreva pode criar uma brecha de segurança terrível. Ao declarar o método como public final void validaSenha(), o compilador proíbe qualquer subclasse de alterar essa lógica.
  2. Em classes: Quando uma classe inteira é declarada como final, ela se torna estéril. Nenhuma outra classe pode estendê-la. O maior exemplo disso no Java é a classe String. Por decisões de design e segurança da linguagem, é impossível criar uma subclasse de String.

A herança é muito mais do que apenas usar a palavra “extends”. Trata-se de modelar o mundo real de forma lógica (lembre-se do teste do “é um”), entender como as instâncias são construídas nos bastidores (o efeito cascata do super) e garantir a segurança do seu código escolhendo sabiamente entre private, protected e final. Dominar esses conceitos é o que separa um mero codificador de um verdadeiro Engenheiro de Software.

Agora eu quero saber de você: Durante os seus projetos, você já passou por alguma situação onde ficou em dúvida se deveria usar private com getters/setters ou se deveria abrir mão dessa burocracia usando protected na herança? Como você resolveu? Deixe seu relato nos comentários abaixo e vamos debater!