Szerző: Attila

Ez a két, vagy inkább egyként feltett kérdés szinte minden technikai interjú kapcsán előkerül. Miért? Mert nagyon hasznos tud lenni, és átláthatóbb kódot lehet így írni. Na de nézzük meg, hogy mik is ezek! Illetve inkább idézek a saját szavaim helyett, mert nem biztos, hogy ennyire pontosan meg tudnám fogalmazni a definicióját.

Method overloading

Javában a metódusok túlterhelése lehetővé teszi a fejlesztők számára, hogy több metódust definiáljanak ugyanazzal a névvel, de különböző paraméterekkel. Ez a rugalmasság olvashatóbbá és adaptívabbá teszi a kódot, mivel egy metódus különböző variációi különböző argumentumtípusokat vagy -mennyiségeket kezelhetnek. Azonban annak megértése, hogy a Java hogyan választja ki, hogy melyik metódust hívja meg, elengedhetetlen a hibamentes kód írásához.

Egyszerű példa kód

class Calculator {
    void add(int a, int b) {
        System.out.println("add(int, int) called: " + (a + b));
    }

    void add(double a, double b) {
        System.out.println("add(double, double) called: " + (a + b));
    }
}

Mi is történik a fenti példában? Két metódusnak ugyanaz a neve, de a bemenő paraméterinek a típusa különböző, így tehát az lesz használva, ahol egyeznek a paraméterek. Automatizálás során például egy jó példa lehet, ha a metódus integert vagy stringet tud fogadni, és annak megfelelően végrehajtani mondjuk egy kiválasztást. Ilyenkor ugye a bemenő paraméter típusa fogja meghatározni, hogy melyik függvény fut le, és mindkét függvény ugyanarra a névre hallgat.

Method overriding

A metódusok felülírása az objektumorientált programozás (OOP) alapvető koncepciója, amely lehetővé teszi egy alosztály számára, hogy egy olyan metódus specifikus implementációját biztosítsa, amely már definiálva van a szuperosztályában. Kulcsfontosságú szerepet játszik a futásidejű polimorfizmus elérésében Java-ban.

• Öröklődés: A metódusok felülírása csak öröklődés esetén történik, ami azt jelenti, hogy egy alosztály örökli a metódusokat és tulajdonságokat egy szuperosztálytól.
• Ugyanazon metódus szignatúra: Ahhoz, hogy a metódusok felülírása megtörténjen, az alosztályban lévő metódusnak ugyanazzal a névvel, visszatérési típussal és paraméterekkel kell rendelkeznie, mint a szuperosztályban lévő metódusnak.
• Felülírás vs. túlterhelés: A metódusok felülírását nem szabad összekeverni a metódusok túlterhelésével. A túlterhelés azt jelenti, hogy több metódusnak ugyanaz a neve, de paramétereik különböznek, míg a felülírás az alosztályban lévő metódus újradefiniálását jelenti ugyanazzal a szignatúrával.

Egyszerű példa kód

class Animal {
    void sound() {
        System.out.println("This animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("The dog barks");
    }
}

Miért érdemes metódusfelülírást használni?

• Polimorfizmus: A metódusfelülírás lehetővé teszi egy alosztály számára, hogy egy adott metódushoz egy adott implementációt biztosítson, lehetővé téve a polimorfizmust. Ez azt jelenti, hogy ugyanaz a metódushívás eltérően viselkedhet attól függően, hogy melyik objektum hívja meg. Például mind az Animal, mind a Dog objektum meghívhatja a sound() metódust, de az eredmény az objektum típusától függ.
• Dinamikus metódusküldés: Futásidőben a végrehajtandó metódust az objektum típusa határozza meg, nem a hivatkozás típusa. Ezt a folyamatot dinamikus metódusküldésnek vagy futásidejű polimorfizmusnak nevezik.
• Újrafelhasználhatóság és bővíthetőség: A felülírás lehetővé teszi az örökölt metódusok viselkedésének kiterjesztését vagy módosítását. Ez elősegíti a kód újrafelhasználását, mivel az alosztály örökölheti a közös viselkedést, miközben további funkciókat biztosít, vagy szükség szerint felülírja a viselkedést.

class Animal {
    void sound() {
        System.out.println("This animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        super.sound();  // Calls the superclass method
        System.out.println("The dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.sound();  // Calls the overridden method
    }
}

Metódus felülírásának szabályai

• A metódusnak ugyanazzal a szignatúrával kell rendelkeznie, mint a szuperosztályban.
• A metódusnak az eredeti metódust tartalmazó osztály alosztályában kell lennie.
• Az alosztályban lévő metódusnak ugyanolyan vagy könnyebben hozzáférhető hozzáférési módosítóval kell rendelkeznie. Például, ha egy metódus védett a szuperosztályban, akkor nem lehet privát az alosztályban.
• Nem írhatjuk felül a final, static vagy private metódusokat.

Szeretem a Medium leírásait, számomra mindig is könnyen érhető, és nagyon sok témát dolgoznak fel. Csak ajánlani tudom!