Newsgroup: it.comp.java
Titolo: Errore strano....... PER ME !

Leggete questo frammento di codice:
public class x {
   static void metodo(byte a, long b) {
      // Blocco di codice
   }
   static void metodo(long a, byte b) {
      // Blocco di codice
   }
   public static void main(String args[]) {
      metodo((byte)1, (byte)2);
   }
}
 Non ho ben capito per quale motivo questo semplice esempio
 da il seguente errore di compilazione:
  x.java:12: reference to metodo is ambiguous, both method metodo(byte,long)
in x
  and method metodo(long,byte) in x match
        metodo((byte)10, (byte)20);
        ^
  1 error
 Se invece di avere dati semplici come byte e long si avesse avuto
(dall'help di VJ++ 6):
  Errore del compilatore J0079
  Ambiguità tra "identificatore" e "identificatore"
  Non è possibile distinguere il metodo corretto da eseguire. Questo errore
si verifica solitamente quando due metodi di cui è stato eseguito
l'overloading hanno un elenco di argomenti correlato e non è possibile
eseguire una chiamata diversa per ciascun metodo. Verificare che la chiamata
del metodo non utilizzi parametri in conflitto con un altro metodo di cui è
stato eseguito l'overloading. Per evitare questo inconveniente, è anche
possibile modificare l'elenco degli argomenti dei due metodi di cui è stato
eseguito l'overloading in modo che abbiano un numero di argomenti diverso e
tipi di dati più specifici in riferimento ai parametri.
  Di seguito è riportato un esempio di questo tipo di errore:
  public class Simple {
     static void method1(Simple2 s2, Simple3 s3) {
        // Blocco di codice
     }
     static void method1(Simple3 s3, Simple2 s2) {
        // Blocco di codice
        }
     public static void main(String args[]) {
        Simple2 s2 = new Simple2();
        method1(s2, s2);
        // Errore: ambiguità tra Simple2 e Simple3
     }
  }
  class Simple2 extends Simple3 {
     // Blocco di codice
  }
  class Simple3 {
     // Blocco di codice
  }
 la cosa mi sarebbe risultata piu' chiara, ma con i primitivi.....
 Sembrerebbe quasi che essi siano oggette "classici" sottoposti alla
gerarchia
 delle classi ? Ma non si era sempre detto che per motivi di efficienza i
tipi
 primitivi erano "diversi"?

 wrote in message 8bdpg2$832$1...@nslave2.tin.it...


   Non è possibile distinguere il metodo corretto da eseguire.[...]
Molto semplice: il compilatore non riesce a decidere quale delle due funzioni
chiamare perchè il costo di conversione per i parametri passati è... uguale. Mi
spiego meglio: a volte passiamo alle funzioni dei parametri che non sono
corretti dal punto di vista del tipo, ad esempio passiamo un char o un long al
posto di un int; in questo caso il compilatore procede ad una conversione di
tipo del parametro prima di passarlo alla funzione. Quando abbiamo una funzione
sovracaricata il compilatore, per decidere quale delle versioni della funzione
vada chiamata, procede al controllo dei parametri passati e alla ricerca della
versione della funzione il cui costo di conversione dei parametri sia il minore
possibile.
Il fatto è che nel tuo caso, il costo di conversione è identico: per la funzione
metodo(byte a, long b) deve convertire (byte)2 in long, mentre il primo
parametro corrisponde perfettamente; per la funzione metodo(long a, byte b) deve
convertire (byte)1, mentre il secondo parametro corrisponde. Ora, se una delle
due avesse avuto ad esempio un 'int' al posto di long, sarebbe stata da
preferire in quanto il costo di conversione di un byte in int è minore che
quello da byte a long (se non mi inganno). In questo caso però entrambe le
funzioni presentano una conversione di tipo identica, e quindi un identico
costo; il compilatore a questo punto ... non sa che pesci pigliare.
Quindi per tua tranquillità i tipi primitivi rimangono tali... "diversi".
Ciao,
 Stefano
----------
"X WindowSSS, teSSSoro mio... lo odieremo per SSSempre"
Bill Gollum
----------