O que é sobreposição (Overriding) na programação…

A sobrescrita de método (Overriding) é a capacidade de uma subclasse fornecer a sua própria implementação de um método que já está definido na sua classe pai. A assinatura do método sobrescrito (nome, quantidade e tipos de parâmetros) na subclasse deve corresponder exatamente à assinatura do método na classe pai. O tipo de valor de retorno também deve ser o mesmo ou ser covariante (subtipo) do tipo de retorno do método na classe pai.

Principais aspetos da sobrescrita:

Herança: A sobrescrita só é possível no contexto de relações de herança, onde a subclasse herda um método da superclasse.
Polimorfismo: A sobrescrita é um dos mecanismos de implementação do polimorfismo em tempo de execução (runtime polymorphism). Isto significa que, dependendo do tipo real do objeto, chamado através de uma referência ao tipo pai, será executada a implementação correspondente do método (seja do pai ou do filho).
Palavra-chave @Override: Em algumas linguagens (por exemplo, Java), usa-se a anotação @Override. Não é obrigatória para que a sobrescrita funcione corretamente, mas é recomendada para melhorar a legibilidade do código e prevenir erros de compilação se o método não cumprir as regras de sobrescrita.
Acesso ao método do pai: Dentro do método sobrescrito na subclasse, muitas vezes é necessário chamar a implementação do mesmo método na classe pai. Para isso, usa-se a palavra-chave super (por exemplo, super.método()).

Exemplo em Java:

// Classe pai
class Animal {
    // Método na classe pai
    void makeSound() {
        System.out.println("O animal faz um som");
    }
}

// Classe filha que herda de Animal
class Dog extends Animal {
    // Sobrescrita do método makeSound()
    @Override
    void makeSound() {
        System.out.println("Au au!");
    }

    // Exemplo de chamada ao método do pai
    void eat() {
        System.out.println("O cão está a comer.");
        super.makeSound(); // Chama o método da classe pai
    }
}

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

        myAnimal.makeSound(); // Vai imprimir: O animal faz um som
        myDog.makeSound();   // Vai imprimir: Au au! (Chamada ao método sobrescrito)

        Dog specificDog = new Dog();
        specificDog.eat(); // Vai imprimir: O cão está a comer. 
                          // O animal faz um som
    }
}

Exemplo em Python:

# Classe pai
class Animal:
    # Método na classe pai
    def make_sound(self):
        print("O animal faz um som")

# Classe filha que herda de Animal
class Dog(Animal):
    # Sobrescrita do método make_sound()
    def make_sound(self):
        print("Au au!")

    # Exemplo de chamada ao método do pai
    def eat(self):
        print("O cão está a comer.")
        super().make_sound() # Chama o método da classe pai

# Demonstração
my_animal = Animal()
my_dog = Dog() # Polimorfismo

my_animal.make_sound() # Vai imprimir: O animal faz um som
my_dog.make_sound()   # Vai imprimir: Au au!

specific_dog = Dog()
specific_dog.eat() # Vai imprimir: O cão está a comer. 
                      # O animal faz um som

A sobrescrita é usada para adaptar o comportamento da classe base às especificidades da subclasse, mantendo a interface geral. É um elemento chave do design orientado a objetos.

O que é sobreposição (Overriding) na programação?