Polimorfismo

9 respostas
S

Olá,

certificação não é um de meus objetivos (ainda), por isso não sei se esta mensagem está dentro dos objetivos deste fórum, mas achei a questão ( de um tópico do gd comp.lang.java, recomendo uma leitura diária das discussões) interessante:

public class CDummy
{
  public static void main(String args[])
  {
    printIt(null);
  }

  static void printIt(String str) {System.out.println("String: " + str);}

  static void printIt(Object obj) {System.out.println("Object: " + obj);}
}

Na instrução printIt(null), qual método printIt será executado, ou ocorre um erro?
Por que?

bob

9 Respostas

D

Eu acho que vai dar erro

pq qdo o main executar o printIt, ele não vai saber qual o tipo de argumento, portanto não saberá qual metodo chamar…

R

Acho que erro não dá não…

Acho que ambos metodos são iguais, pq vc pode ter uma String, ou vc pode ter um Object de String…

Acho

Se tivesse apenas um método, qualquer um dos dois do código, ele imprimiria normal, agora entre os dois, eu não sei qual realmente ele imprime…

Flw

F

Acho que imprime o primeiro (“String: null”).
Não dá erro pq String é um Object e o compilador procura o mais específico (String).
Só acho que isso não é Polimorfismo, certo? É apenas sobrecarga de nomes!
T+
Fabiano B. Ruy

M

acho q vai dar erro de runtime!

R

“fabianoruy”:
o compilador procura o mais específico (String).
Fabiano B. Ruy

Eu não sabia que ele procurava o mais específico, se ele procura o mais específico, ele vai imprimir “String:null”.

F

É, eu já havia caido nessa!
Se fossem duas classes de hierarquias diferentes (tipo String e Integer), daria erro de compilação!
O tal do compilador é bom mesmo!
T+
Fabiano B. Ruy

R

estranhom não sei pq ele imprime String: null…

R
Porque quando  métodos de nomes iguais, porém com atributos diferentes, em tempo de execução ele sempre assumirá o método mais específico, conforme foi dito.
É uma regra que eu acho meio sem sentido, facílimo de confudir-se e sem muito propósito.

Porque quando há métodos de nomes iguais, porém com atributos diferentes, em tempo de execução ele sempre assumirá o método mais específico, conforme foi dito.
É uma regra que eu acho meio sem sentido, facílimo de confudir-se e sem muito propósito.

S

“fabianoruy”:
Acho que imprime o primeiro (“String: null”).
Não dá erro pq String é um Object e o compilador procura o mais específico (String).

Bingo


Só acho que isso não é Polimorfismo, certo?

Provavelmente! Coisa de rookie! :oops:

é isso mesmo?

A resposta:

[quote]There is a rule in the JLS about this. In the case of two or more
possible methods matching, the one that is selected is the one whose
parameter types most closely match the argument types in the method
call. In the case of the argument being null without a typecast, the
method with the most specific parameter types is selected.
In your code, String is more specific than Object, because String is a
subclass of Object. So therefore the compiler chooses printIt(String).
If you had two methods whose parameter types were equally specific,
for example printIt(String) and printIt(List), you would get a compiler
error. Likewise if you had two methods with two parameters, and neither
had both more specific than the other. For example printIt(Object,
String) and printIt(String, Object).


/-- Joona Palaste ([email removido]) ------------- Finland --------
http://www.helsinki.fi/~palaste --------------------- rules! --------//quote

Criado 22 de setembro de 2004
Ultima resposta 22 de set. de 2004
Respostas 9
Participantes 7