Parla delle regole di sovraccarico dei metodi.

Il sovraccarico di metodi (Method Overloading) nella programmazione orientata agli oggetti consente di definire più metodi in una stessa classe con lo stesso nome, ma con firme diverse.

Le regole principali per il sovraccarico di metodi:

Differenza nelle firme: La firma di un metodo include il nome del metodo e la lista dei tipi dei suoi parametri nell'ordine corrispondente. Perché i metodi siano considerati sovraccarichi, le loro firme devono essere diverse.
```
// Esempi di firme diverse
void print(int i) { }
void print(String s) { }
void print(int i, String s) { }
void print(String s, int i) { } // Ordine diverso dei parametri
```

Il nome del metodo deve essere lo stesso: I metodi sovraccaricati devono avere lo stesso nome.

// Esempio corretto di sovraccarico
class Example {
    void process(int a) { }
    void process(double b) { }
}

Il tipo di ritorno non fa parte della firma: Cambiare solo il tipo di ritorno non rende i metodi sovraccaricati. Il compilatore non può distinguere quale metodo chiamare se le firme dei parametri sono uguali.
```
// Non è sovraccarico - errore di compilazione
int calculate() { return 1; }
String calculate() { return "error"; }
```
I modificatori di accesso e le specifiche delle eccezioni non influenzano il sovraccarico: Analogamente al tipo di ritorno, cambiare solo i modificatori di accesso (public, private, protected, default) o la lista delle eccezioni lanciate (throws) non porta al sovraccarico.
```
// Non è sovraccarico - errore di compilazione se le firme dei parametri sono uguali
public void doSomething() { }
private void doSomething() { }
```

L'ordine dei parametri ha importanza: Cambiare l'ordine dei tipi di parametri rende le firme diverse.

// È sovraccarico
void setup(int width, int height) { }
void setup(int height, String unit) { } // Differente secondo parametro
void setup(String unit, int size) { } // Differente tipo e ordine dei parametri

La quantità di parametri ha importanza: Differenti quantità di parametri portano a firme diverse.
```
// È sovraccarico
void log(String message) { }
void log(String message, int level) { }
```

Dunque, il fattore chiave per il Method Overloading è l'unicità della firma del metodo, che è determinata dal suo nome e dall'insieme (tipi e ordine) dei suoi parametri.