Vertel me over de regels voor methodenoverbelasting…

Method Overloading in objectgeoriënteerd programmeren maakt het mogelijk om meerdere methoden in één klasse met dezelfde naam te definiëren, maar met verschillende handtekeningen.

Belangrijkste regels voor method overloading:

Verschil in handtekeningen: De handtekening van een methode omvat de naam van de methode en de lijst van types van de parameters in de juiste volgorde. Om als overbelaste methoden te worden beschouwd, moeten hun handtekeningen verschillen.
```
// Voorbeelden van verschillende handtekeningen
void print(int i) { }
void print(String s) { }
void print(int i, String s) { }
void print(String s, int i) { } // Verschillende volgorde van parameters
```

De naam van de methode moet hetzelfde zijn: Overbelaste methoden moeten dezelfde naam hebben.

// Correct voorbeeld van overbelasting
class Example {
    void process(int a) { }
    void process(double b) { }
}

Het retourtype is geen onderdeel van de handtekening: Alleen het wijzigen van het retourtype maakt de methoden niet overbelast. De compiler kan niet onderscheiden welke methode moet worden aangeroepen als de handtekeningen van de parameters hetzelfde zijn.
```
// Geen overbelasting - compileerfout
int calculate() { return 1; }
String calculate() { return "error"; }
```
Toegangsmodifiers en uitzonderingspecificaties beïnvloeden de overbelasting niet: Net als het retourtype, leiden alleen het wijzigen van toegangsmodifiers (public, private, protected, default) of de lijst van geworpen uitzonderingen (throws) niet tot overbelasting.
```
// Geen overbelasting - compileerfout als de handtekeningen van de parameters hetzelfde zijn
public void doSomething() { }
private void doSomething() { }
```

De volgorde van parameters is belangrijk: Het wijzigen van de volgorde van de parameter types maakt de handtekeningen verschillend.

// Het is overbelasting
void setup(int width, int height) { }
void setup(int height, String unit) { } // Verschillend tweede parameter
void setup(String unit, int size) { } // Verschillende types en volgorde van parameters

Het aantal parameters is belangrijk: Verschillende aantallen parameters leiden tot verschillende handtekeningen.
```
// Het is overbelasting
void log(String message) { }
void log(String message, int level) { }
```

Daarom is de sleutel tot method overloading de uniekheid van de methodesignature, die wordt bepaald door de naam en de set (types en volgorde) van de parameters.

Vertel me over de regels voor methodenoverbelasting.