Overriding

O overriding é um dos conceitos fundamentais da programação orientada a objetos em Java. Ele permite que uma subclasse forneça uma implementação específica para um método que já está definido em sua classe base (superclasse). Neste artigo, vamos explorar em detalhes o conceito de overriding em Java, entender como ele funciona e examinar exemplos práticos para ilustrar esses conceitos.

Entendendo o Overriding

Overriding (ou sobrescrita) ocorre quando uma subclasse fornece uma implementação específica para um método que já está definido na sua classe base (superclasse). O método na subclasse deve ter a mesma assinatura (nome, tipo de retorno e tipos de parâmetros) que o método na superclasse. Quando você chama o método na subclasse, a versão da subclasse é executada, substituindo assim a versão da superclasse.

Sintaxe Básica do Overriding

public class Superclasse {
    public void metodo() {
        // Implementação na superclasse
    }
}

public class Subclasse extends Superclasse {
    @Override
    public void metodo() {
        // Implementação na subclasse (sobrescrita do método da superclasse)
    }
}

• @Override: Uma anotação usada para indicar explicitamente que o método está sendo sobrescrito da superclasse. Embora não seja obrigatório, é uma boa prática usar essa anotação para evitar erros de digitação na assinatura do método.

Exemplo Prático de Overriding

Vamos considerar um exemplo com uma classe Animal como superclasse e duas subclasses Cachorro e Gato que sobrescrevem o método fazerSom().

// Superclasse
public class Animal {
    public void fazerSom() {
        System.out.println("Animal faz um som genérico");
    }
}

// Subclasse 1
public class Cachorro extends Animal {
    @Override
    public void fazerSom() {
        System.out.println("Cachorro late");
    }
}

// Subclasse 2
public class Gato extends Animal {
    @Override
    public void fazerSom() {
        System.out.println("Gato mia");
    }
}

// Método principal
public class Main {
    public static void main(String[] args) {
        Animal meuCachorro = new Cachorro();
        Animal meuGato = new Gato();

        meuCachorro.fazerSom(); // Saída: Cachorro late
        meuGato.fazerSom(); // Saída: Gato mia
    }
}

Neste exemplo, o método fazerSom() é sobrescrito nas subclasses Cachorro e Gato, substituindo assim a implementação da superclasse Animal.

Regras para Overriding

1. Nome e Assinatura: O método na subclasse deve ter o mesmo nome, tipo de retorno e lista de parâmetros (em ordem) que o método na superclasse.

2. Modificador de Acesso: O modificador de acesso do método na subclasse não pode ser mais restritivo do que o modificador de acesso do método na superclasse. Por exemplo, se o método na superclasse é público, ele não pode ser privado na subclasse.

3. Exceções: A subclasse não pode lançar exceções que não são permitidas pela superclasse. Se a superclasse não lança uma exceção específica, a subclasse também não pode lançá-la.

O overriding em Java é uma técnica poderosa para personalizar o comportamento de métodos herdados da superclasse. Ele permite que você crie implementações específicas de métodos em subclasses, proporcionando flexibilidade e adaptabilidade ao seu código. Ao compreender e aplicar o overriding corretamente, você pode criar hierarquias de classes robustas e extensíveis em Java.