Wanneer vindt het overschrijven van een methode…

Methodenoverschrijving in objectgeoriënteerd programmeren gebeurt wanneer een subklasse een methode heeft met dezelfde naam, dezelfde signatuur (lijst van parameters) en hetzelfde retourtype als een methode in de superklasse. Dit stelt de subklasse in staat om zijn eigen implementatie van de geërfde methode te bieden.

Belangrijke voorwaarden voor overschrijving:

Erfelijkheid: De subklasse moet erven van de superklasse.
Signatuur van de methode: De overschreven methode in de subklasse moet dezelfde signatuur hebben (naam van de methode en lijst van parameter types, hun volgorde en aantal) als de methode in de superklasse. In sommige talen (bijvoorbeeld Java) moet ook het retourtype overeenkomen of covariant zijn.
Toegangsmodificatoren: De toegangsmodifier van de overschreven methode in de subklasse mag niet restrictiever zijn dan die in de superklasse.
Niet overschrijven: Statische (static), finale (final in Java, sealed in C#) en private (private) methoden doen niet mee aan polymorfisme via overerving.

Voorbeeld in Java:

// Superklasse
class Animal {
    public void sound() {
        // Standaard implementatie
        System.out.println("Dier maakt een geluid");
    }
}

// Subklasse die de methode sound() overschrijft
class Dog extends Animal {
    @Override // Annotatie voor controle door de compiler
    public void sound() {
        // Specifieke implementatie voor Dog
        System.out.println("Hond blaft");
    }
}

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

        mijnDier.sound();      // Roept sound() van Animal op
        mijnHondAlsDier.sound(); // Roept de overschreven sound() van Dog op (dankzij polymorfisme)
        mijnHond.sound();       // Roept de overschreven sound() van Dog op
    }
}

Voorbeeld in Python:

# Superklasse
class Animal:
    def sound(self):
        # Standaard implementatie
        print("Dier maakt een geluid")

# Subklasse die de methode sound() overschrijft
class Dog(Animal):
    def sound(self):
        # Specifieke implementatie voor Dog
        print("Hond blaft")

# Gebruik
mijn_dier = Animal()
mijn_hondAlsDier = Dog() # Polymorfisme
mijn_hond = Dog()

mijn_dier.sound()       # Roept sound() van Animal op
mijn_hondAlsDier.sound()  # Roept de overschreven sound() van Dog op (dankzij polymorfisme)
mijn_hond.sound()          # Roept de overschreven sound() van Dog op

Overriding wordt gebruikt om polymorfisme op runtime te bereiken, waardoor verschillende acties kunnen worden uitgevoerd afhankelijk van het werkelijke type van het object, ondanks dat er een verwijzing naar de superklasse wordt gebruikt. Dit is een kernprincipe van objectgeoriënteerd programmeren om flexibele en uitbreidbare systemen te bouwen.

Wanneer vindt het overschrijven van een methode (Overriding) plaats?