Sobrecarga de métodos com recursos de ampliação,autoboxing e var-args

A sobrecarga permite que vários métodos de uma classe(ou em suas subclasses) tenham o mesmo nome, mas com assinatura diferente, isto é, a lista de parâmetros deve ser diferente.

Uma das responsabilidades do compilador é definir qual método sobrecarregado será chamado, e alguns recursos do Java podem causar confusão para programadores, veremos aqui alguns fatores que podem dificultar a sobrecarga

São eles:
Ampliação,
Autoboxing
Var-args

Ampliação:

short a =10;
int b = a;
Neste exemplo a variável “a” que é um short pode ser atribuído a uma variável do tipo int sem problemas, pois houve a ampliação.
Em uma sobrecarga ocorre a mesma coisa, a ampliação é feita automaticamente.

Exemplo:
Tendo os métodos:

static void executar(int a){
 System.out.println(“int”);
}

static void executar(long a){
System.out.println(“long”);
}
static void executar(double a){
System.out.println(“double”);
}

e as váriaveis:
byte b = 10;
long l =10;
float f = 5.0f;

ao executarmos:

executar(b);
executar(l);
executar(f);
Produzirá a saída:
int,long,double

O que utiliza byte será ampliado para int, long executará na versão que tem o long como argumento, e float será ampliado para a versão onde consta double.

Mas e se adicionarmos o autoboxing?

static void executar(Integer a){ 
    System.out.println(“Integer”)
}
static void executar(long a){
   System.out.println(“long”);
}

 int i= 10;

executar(i);

Qual das duas versão sera executada?

O valor será ampliado para o conteiner de long? Ou será efetuado o boxing e executar o método com Integer?

A saída produzirá:
long
Isto porque o autoboxing foi adicionado somente na versão 5 do Java, desta maneira os projetista de Java 5 decidiram que era necessário manter os códigos antigos funcionando corretamente, desta maneira, deixando a prioridade para a ampliação, os códigos anteriores à Java 5 não serão afetados.

E se misturarmos ampliação com Var-args?


 static void executar(int a,int b){ 
    System.out.println(“int , int”)
}
static void executar(int…){
   System.out.println(“long”);
}

 byte i= 10;

executar(i);

Qual será a saída?

A saída é: int, int.

Assim como o autoboxing, o var-args foi adicionado a partir do Java 5 desta maneira a ampliação tem prioridade.

Mas, e se sobrecarregarmos o método com autoboxing e var-args?


static void executar(Integer a,Integer b){ 
    System.out.println(“Integer , Integer”)
}
static void executar(int…){
   System.out.println(“long”);
}

 int i= 10;

executar(i);

Desta maneira a saída produzida será:
Integer, Integer.

Isto é executado pois var-args é um recurso mais abrangente, e é melhor que os recursos mais abrangente seja o ultimo recurso.

Estas regras também são válidas para variáveis de referência, logo é valido executar:


class Animal{}
class Cachorro extends Animal{} 

static void executar(Animal a){ }

Cachorro c = new Cachorro;
executar(c);

Onde o método executar com o objeto Cachorro encontrará uma ocorrência com a versão em que há sua superclasse como argumento.
É importante lembrar que não é possível ampliar um objeto de uma classe wrapper para outra, o exemplo abaixo falhará:


static void executar(Integer x){}

Short a = 10;

Executar(a);

Isto ocorre porque Short não é uma subclasse de Integer, e então falha no teste É-UM.
Mas o exemplo abaixo funcionará normalmente.

static void executar(Object x){}

Short a = 10;

executar(a);

Isto é possível porque Short é subclasse de Object.

Estas são as regras para a execução de sobrecarga com os recursos disponíveis após a versão Java 5.

Baseado no livro SCJP Java 5 de Kathy Sierra.
Editora:Altabook

Desenvolvimento - Java

Leia também