Wat is overriding in programmeren?

Method Overriding (Method Overriding) is de mogelijkheid voor een subclass om een eigen implementatie van een methode te bieden die al is gedefinieerd in de superclass. De handtekening van de overschreven methode (naam, aantal en types van parameters) in de subclass moet volledig overeenkomen met die in de superclass. Het retourtype moet ook hetzelfde zijn of covariante (subtype) van het retourtype van de methode in de superclass.

Belangrijke aspecten van overriding:

• Erfelijkheid: Overriding is alleen mogelijk in de context van erfrelaties, waarbij de subclass een methode erft van de superklasse.
• Polymorfisme: Overriding is een van de mechanismen voor de implementatie van runtime polymorfisme. Dit betekent dat, afhankelijk van het werkelijke type van het object, dat via een referentie naar het type van de ouder wordt opgeroepen, de juiste methode-implementatie wordt uitgevoerd (of die van de ouder of die van de kindklasse).
• Sleutelwoord @Override: In sommige talen (bijvoorbeeld Java) wordt de annotatie @Override gebruikt. Het is niet verplicht voor correcte werking van overriding, maar wordt aanbevolen om de leesbaarheid van de code te verbeteren en compileerfouten te voorkomen als de methode niet aan de regels voldoet.
• Toegang tot de oudermethode: Binnen de overschreven methode in de subclass is het vaak nodig om de implementatie van dezelfde methode uit de ouderklasse aan te roepen. Hiervoor wordt het sleutelwoord super gebruikt (bijvoorbeeld super.methode()).

Voorbeeld in Java:

// Ouderklasse
class Animal {
    // Methode in de ouderklasse
    void makeSound() {
        System.out.println("Het dier maakt een geluid");
    }
}

// Subklasse die van Animal erft
class Dog extends Animal {
    // Overriding van de makeSound() methode
    @Override
    void makeSound() {
        System.out.println("Waf waf!");
    }

    // Voorbeeld van het aanroepen van de oudermethode
    void eat() {
        System.out.println("De hond is aan het eten.");
        super.makeSound(); // Roept de methode uit de ouderklasse aan
    }
}

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

        myAnimal.makeSound(); // Output: Het dier maakt een geluid
        myDog.makeSound();   // Output: Waf waf! (Aangeroepen overschreven methode)

        Dog specificDog = new Dog();
        specificDog.eat(); // Output: De hond is aan het eten. 
                          // Het dier maakt een geluid
    }
}

Voorbeeld in Python:

# Ouderklasse
class Animal:
    # Methode in de ouderklasse
    def make_sound(self):
        print("Het dier maakt een geluid")

# Subklasse die van Animal erft
class Dog(Animal):
    # Overriding van de make_sound() methode
    def make_sound(self):
        print("Waf waf!")

    # Voorbeeld van het aanroepen van de oudermethode
    def eat(self):
        print("De hond is aan het eten.")
        super().make_sound() # Roept de methode uit de ouderklasse aan

# Demonstratie
my_animal = Animal()
my_dog = Dog() # Polymorfisme

my_animal.make_sound() # Output: Het dier maakt een geluid
my_dog.make_sound()   # Output: Waf waf!

specific_dog = Dog()
specific_dog.eat() # Output: De hond is aan het eten. 
                      # Het dier maakt een geluid

Overriding wordt gebruikt om het gedrag van de basisklasse aan te passen aan de specificaties van de subclass, terwijl de algemene interface behouden blijft. Het is een kernonderdeel van objectgeoriënteerd ontwerp.