Mit lehet változtatni túlterhelés esetén?

Amikor egy metódust vagy konstruktor felülterhelünk (overloading), a következőket lehet módosítani:

Paramétertípusok: A paraméterek sorrendje és száma ugyanaz lehet, de legalább egy paramétertípusnak különböznie kell.
```
// Felülterhelés példája paramétertípus szerint
void print(int i) { }
void print(String s) { }
```
Paraméterek száma: Ugyanazzal a névvel rendelkező, de különböző számú paraméterrel rendelkező metódusok vagy konstruktorok.
```
// Felülterhelés példája paraméterek száma szerint
void calculate(int a) { }
void calculate(int a, int b) { }
```
Paraméterek sorrendje (különböző típusok esetén): Ha több paraméter van, és azok típusai különböznek, a sorrend megváltoztatása egyedi aláírást hoz létre.
```
// Felülterhelés példája paraméterek sorrendje szerint (különböző típusok)
void process(int a, String s) { }
void process(String s, int a) { }
```

Amit NEM SZABAD módosítani overload esetén:

Visszatérési típus: A felülterhelt metódusok különböző visszatérési típusokkal rendelkezhetnek, de ez nem elég. A visszatérési típus figyelmen kívül marad a metódus aláírásának meghatározásakor.
```
// Ez nem overload
int getValue() { return 0; }
String getValue() { return ""; }
```
Hozzáférési módosítók: public, private, protected, default nem befolyásolják az overload lehetőségét.
Egyéb módosítók: static, final, abstract stb. szintén nem befolyásolják az overload-t.

Példa, ami szemlélteti, hogy a csak a visszatérési típus módosítása nem elég:

class Example {
    // Megengedett
    void sum(int a, int b) { }

    // Paramétertípus szerint overload
    void sum(double a, double b) { }

    // Nem megengedett, csak a visszatérési típus változott
    // int sum(int a, int b) { return a + b; }
}

Összefoglalva, az overload esetén a kulcs az, hogy a metódus vagy konstruktor aláírása egyedi legyen, amit a név, a paraméterek száma és típusa, valamint azok sorrendje határoz meg.