Newsgroup: it.comp.java
Titolo: Domanda su un codice.

Leggendo alcuni codici mi sono trovato di fronte:
final String[] array = new final String[10];
array[0] = "etichetta";
array[0]  = "label"; // impossibile assegnare un nuovo oggetto stringa 
Che cavolo è sta roba?????
Cosa serve il final dopo = ???? Questa non l'ho mai sentita.

Ciao,

Per prima cosa il secondo final, dopo =, é un errore. Quindi il codice che
stai leggendo non dev'essere molto affidabile.
Comunque una variabile dichiarata final é una costante, alla quale si puo'
assegnare un valore solo una volta. Per esempio:
final String cane;
cane = "Pluto"; /* prima volta, dunque OK */
cane = "Rin tin tin"; /* errore alla compilazione */
final String papero = "Paperino"; /*dichiarazione + inizializzazione */
papero = "Gastone"; /* già inizializzata, quindi errore */
Riflettendo mi sorge comunque un dubbio. Forse che il final dopo new é stato
introdotto con il JDK 1.3?? In effetti puo' essere molto utile nel caso di
array o collezioni che si vogliono veramente costanti. Infatti un semplice:
final String[] array = new final String[10];
rende la referenza array impossibile da riassignare, ma il suo contenuto
puo' ancora tranquillamente cambiare, cosa che puo' creare non pochi
problemi se quel che si desidera é che l'array *e* il suo contenuto sia
final.
Se qualcuno ne sa qualcosa per rapporto a delle novità del JDK1.3 allora mi
piacerebbe avere lumi.
bye
Carlo

Scusami, ma ad una costante deve essere necessariamente specificato un
valore in fase di dichiarazione.
Infatti:
class classe {
         final int a;
}
in questo caso il compilatore segnala errore perché le variabile costante
non è stata inizializzata.
Che poi un baco del compilatore ti permetta di scrivere:
final int a; // creo una zona di memoria etichettata a
a = 10; // faccio riferimento a questa zona in scrittura
quando hai una costante locale è tutta un'altra cosa.
Ad una costante sei obbligato a farvi riferimento solo in lettura, se no
che costante sarebbe.
Ci saranno di certo alcuni motivi perché è stato fatto il jdk1.3.
Cmq grazie per la risposta su final dopo.
 

Quello che dici lo so anch'io.
Ho cominciato il discorso con true = qualsiasi numero diverso da 0 e false
= 0 solo perché il diretto interessato sosteneva l'esatto contrario.
Ammetti anche tu che in molti linguaggi si ragiona in questo modo, anche se
in Java no.
Quando parlavo di C intendevo un codice simile a questo:
     int a = 20;
     int b = 40;
     if(a + 100 + c - 60) {
         /* altro codice a seguire */
Sai che bella condizione.
Saluti.

 che costante sarebbe.
Certo, ma qualsiasi costante deve essere inizializzata, quindi accedi sempre
una volta in scrittura. Semplicemente Java permette di farlo in modo
differito dalla dichiarazione, cosa che in altri linguaggi se mi ricordo
bene non é possibile.
Comunque aspetto ancora lumi da qualcuno in rapporto all'istruzione new
final String[10]. Ho fatto qualche ricerca, ma niente. Mi sono deciso a
scaricare il JDK1.3 quindi semmai potro' testare da me e faro' sapere.
bye
Carlo

Quando parli di attributo di una classe intendevi variabile istanza?
Perché le variabili di classe sono legate alla classe stessa e non
dovrebbero avere a che fare con le sottoclassi. Infatti il compilatore
restituisce errore quando non inizializzo subito un membro static final. Se
è istanza è giusto quello che hai detto, ma con static non credo che
funzioni.
Ciao.

Ciao,

Esatto. Intendevo attributo d'istanza, non mi sono accorto che era ambiguo.
Infatti una variabile static non puo' essere inizializzata in un
costruttore, visto che appartiene alla classe e non ad un'istanza. Per
essere pignolo si puo' comunque fare:
class Test {
    static final String cane;
   static {
         cane = "Pluto";
    }
   ....
}
Inizializzando dunque la costante in un blocco d'inizializzazione static. Mi
sembra che puo' essere utile se l'inizializzazione é particolarmente
complessa, ma francamente non ho mai visto un caso dove fosse veramente
necessaria una tale sottigliezza.
bye
Carlo

Rieccomi.
Ho appena finito di scaricare il JDK1.3 e ho testato l'istruzione
final String array = new final String[10];
Non compila su JDK1.3, come non compilava con JDK1.2.
Ma dove sei andato a pescare il codice che citi?
bye
Carlo

Il codice l'ho preso da:
Java 2 di  Philip Heller, Simon Roberts.
Saluti.