Erzählen Sie mir von den Regeln der…

Method Overloading (Method Overloading) in der objektorientierten Programmierung ermöglicht es, mehrere Methoden in einer Klasse mit demselben Namen, aber unterschiedlichen Signaturen zu definieren.

Hauptregeln für die Method Overloading:

Unterschiede in den Signaturen: Die Signatur einer Methode umfasst den Methodennamen und die Liste der Parametertypen in der entsprechenden Reihenfolge. Damit Methoden als überladen gelten, müssen ihre Signaturen unterschiedlich sein.
```
// Beispiele für unterschiedliche Signaturen
void print(int i) { }
void print(String s) { }
void print(int i, String s) { }
void print(String s, int i) { } // Unterschiedliche Parameterreihenfolge
```

Der Methodename muss gleich sein: Überladene Methoden müssen denselben Namen haben.

// Korrektes Beispiel für Überladung
class Example {
    void process(int a) { }
    void process(double b) { }
}

Der Rückgabetyp ist kein Teil der Signatur: Nur den Rückgabetyp zu ändern, macht die Methoden nicht überladen. Der Compiler kann nicht unterscheiden, welche Methode aufgerufen werden soll, wenn die Signaturen der Parameter gleich sind.
```
// Keine Überladung - Compilerfehler
int calculate() { return 1; }
String calculate() { return "error"; }
```
Zugriffsmodifikatoren und Ausnahmespezifikationen beeinflussen die Überladung nicht: Ebenso wie der Rückgabetyp beeinflussen nur die Modifikatoren (public, private, protected, default) oder die Liste der geworfenen Ausnahmen (throws) die Überladung nicht.
```
// Keine Überladung - Compilerfehler, wenn die Signaturen der Parameter gleich sind
public void doSomething() { }
private void doSomething() { }
```

Die Reihenfolge der Parameter ist bedeutend: Die Änderung der Reihenfolge der Parametertypen macht die Signaturen unterschiedlich.

// Es ist eine Überladung
void setup(int width, int height) { }
void setup(int height, String unit) { } // Unterschiedlicher zweiter Parameter
void setup(String unit, int size) { } // Unterschiedlicher Typ und Reihenfolge der Parameter

Die Anzahl der Parameter ist bedeutend: Unterschiedliche Parameteranzahlen führen zu unterschiedlichen Signaturen.
```
// Es ist eine Überladung
void log(String message) { }
void log(String message, int level) { }
```

Daher ist der Schlüsselfaktor für die Method Overloading die Einzigartigkeit der Methodensignatur, die durch den Namen und die Menge (Typen und Reihenfolge) der Parameter bestimmt wird.

Erzählen Sie mir von den Regeln der Methodenüberladung.