Métodos sobrecarregados permitem o reuso do mesmo nome do método em uma classe, mas com argumentos diferentes (e opcionalmente um tipo de retorno diferente).
Regras para métodos sobrecarregados:
· Métodos sobrecarregados devem mudar a lista de argumentos;
· Métodos sobrecarregados podem mudar o tipo de retorno;
· Métodos sobrecarregados podem mudar o modificador de acesso;
· Métodos sobrecarregados podem declarar novos ou menos exceções;
· Um método pode ser sobrecarregado na mesma classe ou em uma subclasse; nesse ultimo caso, somente se o método for herdado da superclasse.
public class MetSobrecarregados {
public void inserir() throws Exception { }
public void inserir(String nome) { }
protected int inserir(int cod) {
return 0;
}
/* mesmo que tenha mudado o tipo de retorno
* e o modificador de acesso, é necessário
* mudar a lista de argumentos */
private boolean inserir() {
return true;
}
}
Invocando Métodos Sobrecarregados
Quando existem métodos sobrecarregados o compilador irá decidir qual método chamar de acordo com os argumentos passados para o método; por exemplo, se existem dois métodos sobrecarregados, um com dois parâmetros int e outro com dois parâmetros float, o compilador irá optar pelo primeiro se os argumentos forem do tipo int, e pelo segundo se os argumentos forem do tipo float.
public class TestOverload {
public int somar(int x, int y) {
return x + y;
}
public double somar(double x, double y) {
return x + y;
}
public static void main(String[] args) {
TestOverload t = new TestOverload();
int a = 1;
int b = 2;
System.out.println(t.somar(a, b)); //3
System.out.println(t.somar(2.5, 2));//4.5
}
}
Para casos com variáveis de referência como parâmetros em métodos sobrecarregados, ocorrem diferentes situações. Se os objetos de um tipo forem instanciados como esse mesmo tipo, o compilador irá executar os métodos da mesma forma que ocorre com variáveis primárias. Porém, se um objeto estiver instanciado com outro tipo (A a = new B();), o método sobrecarregado que será executado é o que tiver o tipo da referência (A) como parâmetro, e não o que tiver o tipo do objeto (B).
class Forma { }
class Quadrado extends Forma { }
public class TestOverload2 {
void preencher(Forma forma) {
System.out.println("Forma");
}
void preencher(Quadrado quadrado) {
System.out.println("Quadrado");
}
public static void main(String[] args) {
TestOverload2 t = new TestOverload2();
Forma forma = new Forma();
Quadrado quadrado = new Quadrado();
Forma forma2 = new Quadrado();
t.preencher(forma); //imprime Forma
t.preencher(quadrado); //imprime Quadrado
/* irá invocar a versão com o tipo Forma,
* pois, apesar de estar instanciado como
* Quadrado, o que conta é o tipo da
* referência (Forma) e não o tipo do
* objeto (Quadrado) */
t.preencher(forma2); //imprime Forma
}
}
Fonte: SCJP Sun Certifi ed Programmer for Java 6 Study Guide
0 comentários:
Postar um comentário