Mi az az felülírás (Overriding) a programozásban…

Felülírás (Overriding) — ez lehetővé teszi az alosztály számára, hogy saját megvalósítást adjon egy olyan metódusnak, amely már meghatározásra került a szülőosztályában. A felülírandó metódus szignatúrájának (név, paraméterek száma és típusa) az alosztályban teljes mértékben meg kell egyeznie a szülőosztályban lévő metódus szignatúrájával. A visszatérési típusnak szintén ugyanannak kell lennie, vagy kovariánsnak (altípusnak) kell lennie a szülő metódusának visszatérési típusához.

A felülírás főbb aspektusai:

Öröklődés: A felülírás csak öröklődési viszonyok keretében lehetséges, ahol az alosztály örökli a metódust a szülőosztálytól.
Polimorfizmus: A felülírás az egyik mechanizmusa a futási időben történő polimorfizmusnak (runtime polymorphism). Ez azt jelenti, hogy az objektum tényleges típusától függően, amelyet a szülő típusára mutató hivatkozáson keresztül hívnak meg, a megfelelő metódus implementáció fog végrehajtódni (akár a szülő, akár az alosztályból).
@Override kulcsszó: Néhány nyelvben (pl. Java) az @Override annotációt használják. Ez nem kötelező a felülírás helyes működéséhez, de ajánlott a kód olvashatóságának javítása és fordítási hibák elkerülése érdekében, ha a metódus nem felel meg a felülírás szabályainak.
Hozzáférés a szülő metódusához: A felülírt metóduson belül gyakran szükséges meghívni ugyanannak a metódusnak a szülőosztályból származó implementációját. Ehhez a super kulcsszót használják (pl. super.metod()).

Java példával:

// Szülőosztály
class Animal {
    // Metódus a szülőosztályban
    void makeSound() {
        System.out.println("Az állat hangot ad ki");
    }
}

// Az Animal-ből öröklődő alosztály
class Dog extends Animal {
    // A makeSound() metódus felülírása
    @Override
    void makeSound() {
        System.out.println("Vau vau!");
    }

    // Példa a szülő metódusának hívására
    void eat() {
        System.out.println("A kutya eszik.");
        super.makeSound(); // A szülőosztály metódusának hívása
    }
}

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

        myAnimal.makeSound(); // Kimenet: Az állat hangot ad ki
        myDog.makeSound();   // Kimenet: Vau vau! (A felülírt metódus hívódik)

        Dog specificDog = new Dog();
        specificDog.eat(); // Kimenet: A kutya eszik. 
// Az állat hangot ad ki
    }
}

Python példával:

# Szülőosztály
class Animal:
    # Metódus a szülőosztályban
    def make_sound(self):
        print("Az állat hangot ad ki")

# Az Animal-ből öröklődő alosztály
class Dog(Animal):
    # A make_sound() metódus felülírása
    def make_sound(self):
        print("Vau vau!")

    # Példa a szülő metódusának hívására
    def eat(self):
        print("A kutya eszik.")
        super().make_sound() # A szülőosztály metódusának hívása

# Bemutató
my_animal = Animal()
my_dog = Dog() # Polimorfizmus

my_animal.make_sound() # Kimenet: Az állat hangot ad ki
my_dog.make_sound()   # Kimenet: Vau vau!

specific_dog = Dog()
specific_dog.eat() # Kimenet: A kutya eszik. 
# Az állat hangot ad ki

A felülírás az alapvető osztály viselkedésének alkalmazkodását teszi lehetővé az alosztály sajátosságaihoz, miközben megőrzi az általános interfészt. Ez az objektumorientált tervezés egyik kulcsfontosságú eleme.

Mi az az felülírás (Overriding) a programozásban?