Sobrecarga e Sobrescrita

Estamos ai pessoal...

Voltando a falar de certificação, como no final do mês estarei indo a Recife fazer a prova, vou tentar escrever esse mês alguns post´s sobre alguns temas que são abortados e criam dúvidas para quem esta estudando para a certificação SCJP ou para quem estuda Java diariamente.

Nesse post vou escrever sobre sobrescrita e sobrecarga de métodos. Espero ajudar alguns e desculpe-me se escrever algo errado. Vamos lá.

Sobrescrita
Sempre que uma classe que herde os métodos da sua superclasse, poderá sobrescrever esse método, lembrando que métodos marcados como final não são herdados.

Exemplo:
public class Animal {
public void andar(){
System.out.println(“pessoa andando”);
}
}
public class Cavalo extends Animal{
public void andar(){
System.out.println(“Cavalo andando”);
}
}
utilizando o código abaixo:
Animal a = new Animal(); aparecerá: pessoa andando
Animal b = new Cavalo(); aparecerá: Cavalo andando

O benefício da sobrescrita é a definição de métodos específicos para as classes mais especificas. Continuando. É possível um método sobrescrito chamar o método da sua superclasse, através da palavra reservada: super. Utilizando o exemplo passado, temos:
public class Cavalo extends Animal{
public void andar(){
super.andar();
System.out.println(“Cavalo andando”);
}
}


Algumas observações sobre a sobrescrita, utilizando o método andar de Animal.
* Na sobrescrita, não é possível tonar o modificador mais restrito. Ex: private void andar(){}
* Na sobrescrita, não é possível lançar novas exceções checadas: Ex: public void andar() throws IOException{}
* Quando existir uma alteração de argumentos, não é uma sobrescrita e sim uma sobrecarga. Ex: private void andar(String comida){}
* Na sobrescrita, não é possível fazer uma alteração no tipo de retorno. Ex: public String andar(){}

Sobrecarga

Com a utilização da sobrecarga é possível fazer uso do mesmo nome de um método outras vezes, mas com a alteração dos argumentos. Exemplo:

public class Test {
public static void calcular(int x, int y){
System.out.println(“dois numeros: ” + (x+ y));
}

public static void calcular(int x, int y, int z){
System.out.println(“tres numeros: ” + (x+ y+ z));
}

public static void main(String [] args){
int a = 10;
int b = 20;
int c = 30;

calcular(b,c); // mostra: dois numeros: 50
calcular(b,c,a); // mostra: tres numeros: 60
}
}


Algumas observações sobrecarga, utilizando o método calcular citado acima.

* Métodos sobrecarregados DEVEM alterar a lista de argumentos: Ex: public static void calcular(int x, int y, int z, int a){}
* Métodos sobrecarregados PODEM alterar o tipo de retorno: public static int calcular(int x, int y){}
* Métodos sobrecarregados PODEM alterar o modificador de acesso: private static int calcular(int x, int y){}
* Métodos sobrecarregados PODEM lançar novas exceções verificadas ou mais abrangentes : public static int calcular(int x, int y) throws IOException{}


Vou postar uma tabela que tem no livro da Kathy, essa tabela é bastante interessante.

Métodos sobrecarregados Métodos sobrescritos
Lista de argumentos Deve ser alterada Não deve ser alterada
Tipo de retorno Pode ser alterado Não deve ser alterado
Exceções Podem ser alteradas Podem ser reduzidas ou eliminadas
Acesso Pode ser alterado Não deve se tornar mais restritivo
Chamadas O tipo de referência O tipo do objeto



Bom, é isso. Espero ter ajuda e qualquer dúvida, sugestão ou criticas são bem vindas.


obs. Minha fonte de referencia foi o livro da Kathy Sierra, que é um ÓTIMO livro para preparatório para a certificação.



Até a próxima.