Quando ocorre a sobrescrição de método (Overriding)…

A sobrescrição de método na programação orientada a objetos ocorre quando uma classe filha tem um método com o mesmo nome, assinatura (lista de parâmetros) e tipo de retorno que um método na sua classe pai. Isto permite que a classe filha forneça a sua própria implementação do método herdado.

Condições principais para a sobrescrição:

Herança: A classe filha deve herdar da classe pai.
Assinatura do método: O método que é sobrescrito na classe filha deve ter a mesma assinatura (nome do método e lista de tipos de parâmetros, sua ordem e quantidade) que o método na classe pai. Em algumas linguagens (por exemplo, Java), também é necessário que o tipo de retorno coincida ou seja covariante.
Modificadores de acesso: O modificador de acesso do método sobrescrito na classe filha não pode ser mais restritivo do que no método na classe pai.
Não pode sobrescrever: Métodos estáticos (static), finais (final em Java, sealed em C#) e privados (private) não participam no polimorfismo através da herança.

Exemplo em Java:

// Classe pai
class Animal {
    public void sound() {
        // Implementação padrão
        System.out.println("Animal faz um som");
    }
}

// Classe filha que sobrescreve o método sound()
class Dog extends Animal {
    @Override // Anotação para verificação pelo compilador
    public void sound() {
        // Implementação específica para Dog
        System.out.println("Cão late");
    }
}

class Main {
    public static void main(String[] args) {
        Animal meuAnimal = new Animal();
        Animal meuCaoComoAnimal = new Dog(); // Polimorfismo
        Dog meuCao = new Dog();

        meuAnimal.sound();      // Chama sound() de Animal
        meuCaoComoAnimal.sound(); // Chama o sound() sobrescrito de Dog (graças ao polimorfismo)
        meuCao.sound();         // Chama o sound() sobrescrito de Dog
    }
}

Exemplo em Python:

# Classe pai
class Animal:
    def sound(self):
        # Implementação padrão
        print("Animal faz um som")

# Classe filha que sobrescreve o método sound()
class Dog(Animal):
    def sound(self):
        # Implementação específica para Dog
        print("Cão late")

# Uso
meu_animal = Animal()
meu_caoComoAnimal = Dog() # Polimorfismo
meu_cao = Dog()

meu_animal.sound()       # Chama sound() de Animal
meu_caoComoAnimal.sound()  # Chama o sound() sobrescrito de Dog (graças ao polimorfismo)
meu_cao.sound()          # Chama o sound() sobrescrito de Dog

A sobrescrição é usada para alcançar o polimorfismo em tempo de execução, permitindo realizar ações diferentes dependendo do tipo real do objeto, apesar de usar uma referência à classe pai. Este é um princípio fundamental da programação orientada a objetos para construir sistemas flexíveis e extensíveis.

Quando ocorre a sobrescrição de método (Overriding)?