Newsgroup: it.comp.java
Titolo: Ultimi problemi

Queste sono le mie ultime domande riguardo ai cambiamenti di Java.
class Myclass { 
         static void metodo()  {};
         void metodo2() {
               metodo();
         }
// altro codice a seguire
Ma all'interno di metodo2 chi è che fa la chiamata al metodo di classe?
Quando qualcuno fa un riferimento del genere all'interno di un metodo
istanza io mi aspetto un this implicito. Quando io ho studiato Java avevo
imparato che nel riferirsi ad una variabile di classe o ad un metodo di
classe si poteva solo usare il nome della classe, oppure un oggetto della
classe stessa, indipendentemente dalla classe in cui esso sia definito. Ma
non avevo mai sentito niente a proposito di chiamate solo con il nome del
metodo o della variabile.
Un altra cosa a proposito dei metodi statici. Io avevo imparato che un
metodo statico è sempre final e quindi in una sottoclasse non può essere
definito, eppure il compilatore non mi segnala errore quando lo ridefinisco
e quando scrivo in modo esplicito final nella dichiarazione del metodo.
Le mie ultime due domande: perché il compilatore mi segnala errore quando
uso la variabile array.lenght per esempio in un ciclo for?
Il metodo newAudioClip è stato riscritto come static?
Quello che veramente mi confonde è questo nuovo modo di richiamare le cose
static che, a parer mio, genera solo confusione.
Ad esempio, nel mio vecchio libro di Java si scriveva:
AudioClip variabile = newAudioClip(); // non ho messo argomenti al metodo;
un codice del genere io lo interpreto come una chiamata dall'oggetto applet
corrente (quello che viene aggiunto dal browser), ma se questo è un metodo
static, come lo capisco io a priori.
Io esigo la completa chiarezza in un linguaggio. 
Grazie dell'attenzione.
 
 
 

Nel Java 1.2 la sintassi per riferirsi ad una variabile di classe era
nomeclasse.variabile o (sconsigliatissimo) oggetto.variabile.
Nel Java 2 la sintassi consiste solo nel nome.
Per me questo è un cambiamento in peggio da parte del linguaggio.
Prova a seguire un codice del genere (preso da Java 2):
class Myclass {
         static int a = 10;
         //altro codice
}
class Myclass2 extends Myclass {
        static final int metodo() { 
                return a;
        }
 
       public static void main(String arg[]) {
               System.out.println(metodo());
      }          
}
 
 

 uso la variabile array.lenght per esempio in un ciclo for?
non é array.length ?
                            ^^
Detto questo, secondo me si sarebbe dovuto impedire di poter invocare un
metodo statico a partire da un'instanza. Questo puo' creare confusione nella
lettura del codice o dei bug difficili da trovare: si pensa modificare
un'attributo di un'instanza e invece il cambiamento si propaga a tutte le
instanze passate e future. Consiglio, per chiarezza, di usare sempre i
metodi statici prefissandoli con il nome della classe.
bye
Carlo


...mmm... con questa storia dei "cambiamenti" non ti seguo piu`:
non ti hanno(abbiamo) gia` risposto in molti che e` *solo questione di
gusti* ? Cos'e`, non ti fidi? Il compilatore ti da` errori se scrivi
come ti piace? NO: e allora scrivi come piu` ti piace, e vivi felice...
come tutti!
Evidentemente all'autore del libro che citi ora piace di piu` scrivere
codice in questo modo. Forse in un'edizione precedente adottava un altro
stile. Tu puoi benissimo creartene uno tuo. Anche se la regola generale
(non scritta) e` "essere coerenti", se questo testo non la rispetta non
e` che puoi farne un dramma: se proprio non riesci a seguirlo cambia
testo.
Per quanto mi riguarda continuo ad usare il metodo piu` diffuso:
	NomeClasse.nomeVariabile;	// per le variabili di classe
	nomeVariabile;	// (senza "this.") per le variabili di istanza
de gustibus... !
-- 
Ciao, Matteo                          !!   La chiesa e' vicina, 
                                      /\   ma la strada e' ghiacciata;
mailto:
matteo.mattia
 (at) 
libero.it
   \/   il bar e' lontano,
ICQ UIN : 42966529                    ¡¡   ma camminero' con prudenza.

 Nel Java 2 la sintassi consiste solo nel nome.
No, nessun cambiamento!! In Java2 si deve sempre usare nomeclasse.variabile
o oggetto.variabile se fai appello al metodo da un'ALTRA classe. Se fai
appello a un metodo statico nel codice della classe stessa a cui appartiene
il metodo, allora chiaramente puoi omettere il prefisso.
bye
Carlo

Quando parlavo di lenght intendevo la variabile che possiedono tutti gli
oggetti array.
Secondo quello che avevo imparato:
         String arr[] = new String[10];
         System.out.println(arr.lenght); // stampa 10, ovvero il numero di
elementi
infatti io facevo spesso:
for(int i = 0; i < arr.lenght; ++i) System.out.println(arr[i];
ma adesso il compilatore mi segnala sempre uso improprio della variabile.
Eppure questa tecnica la ritrovo anche in Java 2. 
In questa situazione può ancora andare bene perché io conosco il numero di
elementi, ma quando non lo conosco a priori cosa faccio? 
Questa variabile mi è sempre stata utile e adesso mi trovo un pò spiazzato.
Cmq grazie a tutti quanti per il resto.                                  



infatti io facevo spesso:


Questa variabile mi è sempre stata utile e adesso mi trovo un po
'spiazzato.


E' vero, è length, ho sbagliato io a scrivere sul newsgroup. Ma
indipendentemente da ciò per il compilatore è sempre uso non valido della
variabile.

 ha scritto nel messaggio
news:01c01712$c58d5d00$LocalHost@libero...

mi spiace
+++++++++++++++++
 "Software is like sex: it's better when it's free".
    Linus Torvalds