Newsgroup: it.comp.java
Titolo: Piccolo problema

Salve, sapete dirmi perché mi da errore?
public class prova {
 class Base {
  public void metodo (String s) {
   System.out.println (s);
  }
 }
 public static void main (String args []) {
  Base obj = new Base (); <--- Dice che non si puņ chiamare in un contesto
statico... ma allora come lo chiamo questo metodo?
  obj.metodo ("Ciao");
 }
}
--
Luigi
http://web.tiscali.it/luigi_web
byte...@hotmail.com
ICQ 46240443


Prova cosě....
public class prova  {
 class Base {
  public void metodo (String s) {
   System.out.println (s);
  }
 }
 public static void main (String args []) {
  prova p=new prova();
  p.usaBase();
 }
 public void usaBase()  {
 Base obj=new Base();
 obj.metodo("ciao");
}
}

 Prova così....


Qui devo prima istanziare la classe principale (quella con il nome del file)
e poi chiamare un metodo che a sua volta definisce un'oggetto della mia
classe e chiama un metodo di essa?
Grazie


 ha scritto nel messaggio
news:vgcK7.129586$sq5.6...@news.infostrada.it...


No, lo stiamo facendo all'università (domani il prof spiega cosa sono gli
int, le String, i tipi di dato primitivi insomma (a parte String)) è
diventata un'espressione! :)    ma io studio per i fatti miei e praticamente
volevo provare se l'overload dei metodi funzionava anche tra scope diversi,
precisamente tra classe base e classe derivata, ma mi sa che non è permesso
questo... almeno in C++ non lo è, però pensandoci bene in Java ci sono tutti
i metodi virtuali.... vediamo se mi puoi aiutare (consideralo un test per la
certificazione :)
/* Pseudo codice */
Se io ho un'oggetto della classe derivata tipo
Derived obj = new Derived();
e ho due classi così composte:
class Base {
    int Pippo (int x) {};
}
class Derived extends Base{
    String Pippo (String s) {};
}
Una chiamata simile
obj.Pippo(5);
è lecità?
Ovviamente se obj fosse un'istanza di "Base" sarebbe corretto grazie al
polimorfismo (giusto?). Ma in questo caso mi sa che non posso... che ne
pensi?
Grazie
Luigi


certo che è lecita... in questo caso non si parla di overriding ma di
overloading "verticale"...
nel senso che tu in Derived hai tutti i metodi di Base.
Se il compilatore mentre scrivessi il codice ti RI-scrivesse (dopo l'
"extends Base") all'interno
automaticamente tutti i metodi di Base (magari senza permetterti di
cambiarli) in Derived
e poi aggiungessi il nuovo metodo Pippo? Come lo chiameresti? Overloading,
no?
Bhè il concetto è quello, solo che devi "immaginare" (sapere) sempre cosa ti
porti dietro.
Ciao.
cut cut...

Grazie, poi ho provato e mi sono accorto che la chiamata è lecita, e non è
vero se invece obj è di tipo Base e chiamo Pippo (String). Ma non dovrebbe
entrare in gioco il polimorfismo?
Ciao


 entrare in gioco il polimorfismo?
infatti entra in gioco...ma ricordati che java ha lo smistamento dinamico
dei metodi, pertanto puoi fare:
Base obj= new Base();
Derived Dobj = new Derived();
obj=Dobj();
((Derived) obj).Pippo("ciao!"); /*dici al compilatore che sul tuo oggetto
devi richiamare i metodi delle sue sottoclassi*/
((Derived) obj).Pippo(2);
mi raccomando.... vale la regola che un riferimento ad un oggetto (o meglio
un riferimento ad interfaccia) può essere assegnato ad un riferimento di
un'oggetto che si trova nel sottoalbero della gerarchia di cui lui è radice.
In quel modo java runtime si va a cercare i metodi dell'oggetto, che nel
nostro caso sono: o il nuovo metodo con parametro String (overloading
"verticale") oppure un overriding di quello con int (quindi Java permette di
usare sempre i metodi più aggiornati con questa modalità di accesso ai
metodi, non credi?).

 ha scritto nel messaggio
news:kXeK7.131619$sq5.6...@news.infostrada.it...


Mi permetto di dissentire anche questa volta : pure in questo caso si parla
di overloading e non di overriding.
Overloading significa che il metodo ha lo stesso nome ma la 'firma'
(signature) del metodo è differente. In questo modo la chiamata al metodo
corretto viene risolta in base al tipo di  parametri passati, esattamente
come se si trattasse di metodi differenti.
Overriding si verifica invece quando nella classe derivata dichiara un
metodo con la stessa firma della classe base, in questo modo il
comportamento del metodo viene ridefinito (override) e non sarà possibile
chiamare l'implementazione del metodo definito nella classe base su
un'istanza della classe derivata; nell'altro caso (quello precedente) ci
saranno invece due metodi differenti che potrai richiamare con parametri
diversi (overload) sulle istanze della classe derivata.
Inoltre se la firma del metodo è differente, il metodo può restituire un
tipo di oggetto differente senza che ciò provochi problemi in compilazione.
Regards.
Luigi

 wrote in message
9tek76$c6u$1...@lacerta.tiscalinet.it...
