Sobrecarga - Overloading¶

Introdução¶

Sobrecarga de métodos / method overloading = conceito de definir vários métodos com o mesmo nome em uma classe, mas com diferentes assinaturas - diferentes parâmetros
- mesma classe, assinaturas diferentes
A sobrecarga permite que um método execute diferentes tarefas dependendo do número ou tipo dos argumentos passados, sem a necessidade de criar nomes diferentes para cada variação do método
a sobrecarga de métodos é útil quando se quer oferecer a mesma funcionalidade (nome do método) para diferentes tipos ou quantidades de argumentos
a sobrecarga ajuda a tornar o código mais legível e reutilizável, oferecendo flexibilidade para que os métodos executem a mesma ação com diferentes tipos de entrada

public class Calculadora {
    // Método soma com 2 parâmetros
    public int soma(int a, int b) {
        return a + b;
    }

    // Método soma com 3 parâmetros (sobrecarga)
    public int soma(int a, int b, int c) {
        return a + b + c;
    }

    // Método soma com parâmetros de tipo diferente (sobrecarga)
    public double soma(double a, double b) {
        return a + b;
    }
}

no exemplo, o método soma é sobrecarregado três vezes:
1. Com dois parâmetros inteiros
2. Com três parâmetros inteiros
3. Com dois parâmetros de tipo double
cada versão do método soma tem o mesmo nome, mas assinaturas diferentes = número e tipo dos parâmetros

Regras para criar métodos sobrecarregados¶

Nome do método = deve ser o mesmo para todos os métodos sobrecarregados
Número de parâmetros = deve ser diferente. É necessário ter uma variação no número de argumentos para que a sobrecarga funcione
- exemplo válido = soma(int, int) e soma(int, int, int)
Tipo de parâmetros = pode ser diferente entre os métodos sobrecarregados.
- exemplo válido = soma(int, int) e soma(double, double)
Ordem dos parâmetros = também pode ser diferente. A ordem dos tipos de parâmetros pode variar, mas isso é suficiente para distinguir a sobrecarga.
- exemplo válido = soma(int, double) e soma(double, int)
Não é possível sobrecarregar métodos apenas pelo tipo de retorno = o tipo de retorno não é considerado na assinatura do método - ou seja, dois métodos não podem ter o mesmo nome e o mesmo número de parâmetros com apenas o tipo de retorno diferente

// não se considera sobrecarga
// métodos possuem a mesma assinatura, diferença somente no tipo de retorno
public int soma(int a, int b) { return a + b; }
public double soma(int a, int b) { return a + b; }

public class Imprimir {
    // Método com um parâmetro
    public void imprimir(String texto) {
        System.out.println(texto);
    }

    // Método com dois parâmetros (sobrecarga)
    public void imprimir(String texto, int repeticoes) {
        for (int i = 0; i < repeticoes; i++) {
            System.out.println(texto);
        }
    }

    // Método com tipo diferente (sobrecarga)
    public void imprimir(int numero) {
        System.out.println("Número: " + numero);
    }
}

No exemplo, o método imprimir é sobrecarregado de três formas diferentes
1. Com um parâmetro do tipo String
2. Com dois parâmetros: um String e um int
3. Com um parâmetro do tipo int

Exercícios¶

Questões¶

A sobrecarga de métodos ocorre quando dois ou mais métodos têm o mesmo nome, mas diferentes tipos ou números de parâmetros.
Em Java, é possível sobrecarregar um método alterando apenas o tipo de retorno.
Os métodos sobrecarregados devem ter a mesma assinatura, mas podem diferir na implementação interna.
A sobrecarga de métodos permite que você defina múltiplos métodos com o mesmo nome, desde que cada um tenha uma lista de parâmetros diferente.
Em Java, a sobrecarga de métodos pode ser feita apenas alterando o tipo de parâmetro de entrada.
A sobrecarga de métodos não é uma forma de polimorfismo em Java.
É possível sobrecarregar métodos com base no número de parâmetros e no tipo de parâmetros.
Um método sobrecarregado pode ser chamado com argumentos que correspondem a qualquer uma das assinaturas dos métodos sobrecarregados.
Não é possível sobrecarregar um método em Java se o tipo de retorno for diferente.
Em Java, dois métodos com o mesmo nome podem ser sobrecarregados se tiverem a mesma lista de parâmetros, desde que um tenha o modificador static e o outro não.
O compilador de Java resolve a sobrecarga de métodos com base no tipo, número e ordem dos parâmetros.
A sobrecarga de métodos em Java pode ser feita por alteração apenas do modificador de acesso.
Um método sobrecarregado pode ter implementações diferentes, mas deve sempre ter a mesma assinatura.
Métodos sobrecarregados são escolhidos pelo compilador em tempo de compilação com base nos argumentos passados.
A sobrecarga de métodos pode ser usada para definir métodos que fazem coisas completamente diferentes, mas com o mesmo nome.

Gabarito¶

Verdadeiro: a sobrecarga de métodos ocorre quando métodos com o mesmo nome têm diferentes parâmetros (número ou tipo). Eles podem ter a mesma implementação ou não.
Falso: não é possível sobrecarregar um método apenas alterando o tipo de retorno. A sobrecarga depende das diferenças nos parâmetros (tipo, número ou ordem).
Falso: métodos sobrecarregados precisam ter diferentes assinaturas, ou seja, parâmetros diferentes. A implementação interna pode variar, mas isso não é o critério principal da sobrecarga.
Verdadeiro: você pode definir múltiplos métodos com o mesmo nome, desde que os parâmetros (número ou tipo) sejam diferentes, permitindo a sobrecarga.
Falso: a sobrecarga não pode ser feita apenas com base no tipo de parâmetro. A sobrecarga também pode ocorrer com base no número de parâmetros.
Verdadeiro: a sobrecarga não é considerada polimorfismo, pois não envolve o comportamento dinâmico dos objetos, mas sim a escolha de qual versão de um método será chamada em tempo de compilação.
Verdadeiro: a sobrecarga pode ocorrer tanto pelo número de parâmetros quanto pelo tipo dos parâmetros, desde que a assinatura do método (nome + parâmetros) seja diferente.
Verdadeiro: quando você chama um método sobrecarregado, o compilador escolhe qual método será invocado com base nos argumentos passados.
Falso: a sobrecarga não depende do tipo de retorno. Métodos com o mesmo nome podem ter diferentes tipos de retorno, mas a sobrecarga depende dos parâmetros.
Falso: a sobrecarga não pode ser feita com base apenas no modificador static. A sobrecarga depende da diferença nos parâmetros, não no modificador de acesso ou static.
Verdadeiro: o compilador escolhe qual versão do método será chamada com base na correspondência dos tipos, número e ordem dos parâmetros.
Falso: a sobrecarga não pode ser feita apenas com o modificador de acesso. A alteração dos parâmetros é o que caracteriza a sobrecarga.
Falso: métodos sobrecarregados devem ter assinaturas diferentes. Não é necessário que a implementação seja a mesma.
Verdadeiro: o compilador resolve qual método sobrecarregado chamar em tempo de compilação, com base nos argumentos fornecidos no momento da chamada.
Falso: métodos sobrecarregados devem ter implementações que sejam logicamente relacionadas, pois o nome do método deve indicar um propósito comum. Caso contrário, seria melhor nomear os métodos de forma diferente.