Cuéntame sobre las reglas de sobrecarga de métodos…

La sobrecarga de métodos (Method Overloading) en programación orientada a objetos permite definir varios métodos en una misma clase con el mismo nombre, pero con diferentes firmas.

Reglas principales para la sobrecarga de métodos:

Diferencia en las firmas: La firma de un método incluye el nombre del método y la lista de tipos de sus parámetros en el orden correspondiente. Para que los métodos se consideren sobrecargados, sus firmas deben ser diferentes.
```
// Ejemplos de firmas diferentes
void print(int i) { }
void print(String s) { }
void print(int i, String s) { }
void print(String s, int i) { } // Diferente orden de parámetros
```

El nombre del método debe ser el mismo: Los métodos sobrecargados deben tener el mismo nombre.

// Ejemplo correcto de sobrecarga
class Example {
    void process(int a) { }
    void process(double b) { }
}

El tipo de valor de retorno no forma parte de la firma: Cambiar solo el tipo de retorno no hace que los métodos estén sobrecargados. El compilador no podrá distinguir qué método llamar si las firmas de los parámetros son iguales.
```
// No es sobrecarga - error de compilación
int calculate() { return 1; }
String calculate() { return "error"; }
```
Los modificadores de acceso y los especificadores de excepciones no afectan la sobrecarga: De manera similar al tipo de retorno, cambiar solo los modificadores de acceso (public, private, protected, default) o la lista de excepciones lanzadas (throws) no conduce a la sobrecarga.
```
// No es sobrecarga - error de compilación si las firmas de los parámetros son iguales
public void doSomething() { }
private void doSomething() { }
```

El orden de los parámetros importa: Cambiar el orden de los tipos de los parámetros hace que las firmas sean diferentes.

// Es sobrecarga
void setup(int width, int height) { }
void setup(int height, String unit) { } // Diferente segundo parámetro
void setup(String unit, int size) { } // Diferente tipo y orden de parámetros

La cantidad de parámetros importa: Diferentes cantidades de parámetros conducen a firmas diferentes.
```
// Es sobrecarga
void log(String message) { }
void log(String message, int level) { }
```

Por lo tanto, el factor clave para la sobrecarga es la singularidad de la firma del método, que se determina por su nombre y el conjunto (tipos y orden) de sus parámetros.

Cuéntame sobre las reglas de sobrecarga de métodos.