¿Cuándo ocurre la sobrescritura de un método…

La sobrescritura de métodos en programación orientada a objetos ocurre cuando una clase hija tiene un método con el mismo nombre, firma (lista de parámetros) y tipo de retorno que un método en su clase padre. Esto permite que la clase hija proporcione su propia implementación del método heredado.

Condiciones principales para la sobrescritura:

Herencia: La clase hija debe heredar de la clase padre.
Firma del método: El método que se sobrescribe en la clase hija debe tener la misma firma (nombre del método y lista de tipos de parámetros, su orden y cantidad) que el método en la clase padre. En algunos lenguajes (por ejemplo, Java) también se requiere que coincida el tipo de retorno o su covarianza.
Modificadores de acceso: El modificador de acceso del método sobrescrito en la clase hija no puede ser más restrictivo que en el método de la clase padre.
No se puede sobrescribir: Métodos estáticos (static), finales (final en Java, sealed en C#) y privados (private) no participan en el polimorfismo a través de la herencia.

Ejemplo en Java:

// Clase padre
class Animal {
    public void sound() {
        // Implementación por defecto
        System.out.println("Animal hace un sonido");
    }
}

// Clase hija que sobrescribe el método sound()
class Dog extends Animal {
    @Override // Anotación para verificar en compilación
    public void sound() {
        // Implementación específica para Dog
        System.out.println("El perro ladra");
    }
}

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

        miAnimal.sound();      // Llama a sound() de Animal
        miPerroComoAnimal.sound(); // Llama a sound() sobrescrito de Dog (gracias al polimorfismo)
        miPerro.sound();         // Llama a sound() sobrescrito de Dog
    }
}

Ejemplo en Python:

# Clase padre
class Animal:
    def sound(self):
        # Implementación por defecto
        print("Animal hace un sonido")

# Clase hija que sobrescribe el método sound()
class Dog(Animal):
    def sound(self):
        # Implementación específica para Dog
        print("El perro ladra")

# Uso
mi_animal = Animal()
mi_perro_como_animal = Dog() # Polimorfismo
mi_perro = Dog()

mi_animal.sound()       # Llama a sound() de Animal
mi_perro_como_animal.sound()  # Llama a sound() sobrescrito de Dog (gracias al polimorfismo)
mi_perro.sound()          # Llama a sound() sobrescrito de Dog

La sobrescritura se usa para lograr el polimorfismo en tiempo de ejecución, permitiendo realizar diferentes acciones dependiendo del tipo real del objeto, a pesar de usar una referencia a la clase padre. Este es un principio clave de la programación orientada a objetos para construir sistemas flexibles y extensibles.

¿Cuándo ocurre la sobrescritura de un método (Overriding)?