Fale sobre as regras de sobrecarga de métodos.

A sobrecarga de métodos (Method Overloading) na programação orientada a objetos permite definir vários métodos numa mesma classe com o mesmo nome, mas com assinaturas diferentes.

Regras principais para a sobrecarga de métodos:

Diferença nas assinaturas: A assinatura de um método inclui o nome do método e a lista de tipos dos seus parâmetros na ordem correspondente. Para que os métodos sejam considerados sobrecarregados, suas assinaturas devem ser diferentes.
```
// Exemplos de assinaturas diferentes
void print(int i) { }
void print(String s) { }
void print(int i, String s) { }
void print(String s, int i) { } // Ordem diferente dos parâmetros
```

O nome do método deve ser o mesmo: Os métodos sobrecarregados devem ter o mesmo nome.

// Exemplo correto de sobrecarga
class Example {
    void process(int a) { }
    void process(double b) { }
}

O tipo de retorno não faz parte da assinatura: Alterar apenas o tipo de retorno não torna os métodos sobrecarregados. O compilador não consegue distinguir qual método chamar se as assinaturas dos parâmetros forem iguais.
```
// Não é sobrecarga - erro de compilação
int calculate() { return 1; }
String calculate() { return "error"; }
```
Modificadores de acesso e especificadores de exceções não afetam a sobrecarga: Assim como o tipo de retorno, alterar apenas os modificadores de acesso (public, private, protected, default) ou a lista de exceções lançadas (throws) não leva à sobrecarga.
```
// Não é sobrecarga - erro de compilação se as assinaturas dos parâmetros forem iguais
public void doSomething() { }
private void doSomething() { }
```

A ordem dos parâmetros importa: Alterar a ordem dos tipos de parâmetros torna as assinaturas diferentes.

// É sobrecarga
void setup(int width, int height) { }
void setup(int height, String unit) { } // Difere pelo segundo parâmetro
void setup(String unit, int size) { } // Difere pelo tipo e pela ordem dos parâmetros

A quantidade de parâmetros importa: Quantidades diferentes de parâmetros levam a assinaturas diferentes.
```
// É sobrecarga
void log(String message) { }
void log(String message, int level) { }
```

Assim, o fator chave para a sobrecarga é a singularidade da assinatura do método, que é determinada pelo seu nome e pelo conjunto (tipos e ordem) dos seus parâmetros.