Parlez-moi des règles de surcharge de méthodes.

La surcharge de méthodes (Method Overloading) en programmation orientée objet permet de définir plusieurs méthodes dans une même classe avec le même nom, mais avec des signatures différentes.

Les règles principales pour la surcharge de méthodes :

Différence de signatures : La signature d'une méthode inclut le nom de la méthode et la liste des types de ses paramètres dans le bon ordre. Pour que les méthodes soient considérées comme surchargées, leurs signatures doivent être différentes.
```
// Exemples de signatures différentes
void print(int i) { }
void print(String s) { }
void print(int i, String s) { }
void print(String s, int i) { } // Ordre différent des paramètres
```

Le nom de la méthode doit être le même : Les méthodes surchargées doivent avoir le même nom.

// Exemple correct de surcharge
class Example {
    void process(int a) { }
    void process(double b) { }
}

Le type de retour n'est pas une partie de la signature : Changer uniquement le type de retour ne rend pas les méthodes surchargées. Le compilateur ne pourra pas distinguer quelle méthode appeler si les signatures des paramètres sont identiques.
```
// Ce n'est pas une surcharge - erreur de compilation
int calculate() { return 1; }
String calculate() { return "error"; }
```
Les modificateurs d'accès et les spécificateurs d'exceptions n'affectent pas la surcharge : De même que le type de retour, changer uniquement les modificateurs d'accès (public, private, protected, default) ou la liste des exceptions levées (throws) ne conduit pas à la surcharge.
```
// Ce n'est pas une surcharge - erreur de compilation si les signatures des paramètres sont identiques
public void doSomething() { }
private void doSomething() { }
```

L'ordre des paramètres a de l'importance : Changer l'ordre des types de paramètres rend les signatures différentes.

// C'est une surcharge
void setup(int width, int height) { }
void setup(int height, String unit) { } // Différent deuxième paramètre
void setup(String unit, int size) { } // Différent type et ordre des paramètres

Le nombre de paramètres a de l'importance : Des nombres différents de paramètres conduisent à des signatures différentes.
```
// C'est une surcharge
void log(String message) { }
void log(String message, int level) { }
```

Ainsi, le facteur clé pour la surcharge est l'unicité de la signature de la méthode, qui est déterminée par son nom et l'ensemble (types et ordre) de ses paramètres.