Newsgroup: it.comp.java
Titolo: Variabili d'istanza

Che differenza c'è nel definire una variabile d'istanza all'interno o
all'esterno di un costruttore?
Se ad es. ho:
public class Esempio {
    int prova; //dichiaro la variabile d'istanza
public Esempio() {
    prova = 5;
ecc. ecc. .....
OPPURE:
public EsempioBis {
    int provaBis = 3;
public EsempioBis() {
//codice del costruttore...
}
ecc. ecc.
Ecco: perché talvolta si ha a che fare con questi due diversi approcci? Mi
aiutate a capire?
Ciao

 Se ad es. ho:
La differenza è nel controllo sull'inizializzazione. Le variabili definite 
fuori dai costruttori vengono inizializzate prima che il costruttore sia 
invocato. Pertanto, se hai una variabile che deve avere sempre lo stesso 
valore di partenza, indipendentemente dal costruttore invocato, la dovresti 
inizializzare in partenza:
public class A
{
        int var=10;
        public A()
        {..     }
        public A(String s,...)
        {...}
}
in questo modo all'interno dei due costruttori non compare una ripetizione 
di codice. Se il valore della variabile dipende invece da come la classe è 
istanziata, ossia quale costruttore è invocato, allora il codice deve 
trovarsi nel costruttore.
Spero di essere stato chiaro.
Ciao
-- 
Luca Ferrari,
fluc...@libero.it

 ha scritto nel messaggio
news:Of%M9.16238$R45.7...@news2.tin.it...


 Mi rispondo da solo:
...meglio se ti compri un buon libro...
[cut]
-- 
Lucio Benfante
Brainbench MVP for Java 1
http://www.brainbench.com
MyTranscript: 
http://www.brainbench.com/transcript.jsp?pid=167064

 ...meglio se ti compri un buon libro...
Già fatto. Quello che ho scritto io sono testuali parole di un certo Bruce
Eckel. Te lo consiglio vivamente, si intitola "Thinking in Java".
E poi ti volevo dire che è troppo comodo essere arroganti, non rispondere ad
una domanda di un inesperto e criticare senza aiutare. Le cose sono due: o
non sei in grado di farlo (e allora hai perso una buona occasione per stare
zitto) o non vuoi farlo (e allora facevi meglio comunque a startene zitto).
Ciao

 comunque a startene zitto).
Mi spiace, non voleva essere arroganza.  L'intenzione era solo farti
notare che la risposta che ti eri dato da solo non era corretta. Inoltre
la tua domanda e la tua risposta denotavano una certa confusione fra il
termine dichiarazione ed inizializzazione, che e' un'argomento
decisamente di base della programmazione (OO e non), quindi mi sembrava un buon
consiglio quello di suggerirti di cercarlo in un libro (meglio se buono).
Come ultimo appunto (ma qui andiamo sul personale :-)...occhio alla
faccina, il tono e' scherzoso, quindi non arrabbiarti), prima di zittire
qualcuno cerca di capire con chi parli, magari leggendoti i suoi vecchi
post, o andando a cercare le sue informazioni, visto che io non mi
nascondo dietro ad un nickname.
Se dai un'occhiata ai miei (e ce ne sono fin dal '99) vedrai che sono
(quasi) sempre puntuali e ricchi di suggerimenti, nonche' (quando ha senso)
di codice.
Forse questa volta sono stato un po' frettoloso, ma sicuramente non era
mia intenzione essere arrogante, ne' sgarbato.
Inoltre, ti faccio notare, che non e' che gli altri si siano buttati "a
pesce" su questo argomento cosi' interessante..;-)..e che (come dici
nell'altro thread che hai originato) hai posto provocatoriamente per
"stimolarci" (ebbene si'...mi pongo anch'io nell'elenco dei piu'
esperti...perdona l'arroganza :-)).


 esperti...perdona l'arroganza :-)).
Non c'č mica niente di arrogante ad essere esperti in qualcosa (e non lo
metto certamente in dubbio che tu lo sia). Anch'io sono esperto in altre
materie che non hanno a che fare con l'informatica (che resta una mia
passione da dilettante), non c'č assolutamente niente di male.
Ciao

 
Si'...tu avevi detto definizione, io l'ho sostituito con dichiarazione
perche' e' il termine che viene comunemente usato in Java (fra l'altro lo
usa anche Gosling nel sul "The Java Programming Language"...e se non diamo
retta al creatore di Java...:-)).
La differenza fra i due termini e': una definizione (di variabile) indica
al compilatore il tipo ed il nome della variabile e di allocare la memoria
necessaria per contenerla. Una dichiarazione (di variabile) invece indica
al compilatore che da qualche altra parte nel codice e' stata dichiarata
una variabile con un certo tipo e nome e che quindi puo' usarla (ma non
deve allocare memoria, dato che e' gia' stata definita da qualche altra
parte).
Cio' ha senso, ad esempio, in C++, in cui con la parola chiave extern si
possono effettivamente fare delle dichiarazioni. In Java non esiste niente
del genere e quindi non c'e' ambiguita' fra i due termini. Forse
definizione sarebbe il termine piu' corretto, ma dichiarazione e' quello
usato (anche nella Java Language Specification).
Ovviamente Eckel usa il termine definizione, dato che e' sempre molto
pignolo e arriva dal C++ (fra i miei libri ho la traduzione del suo "C++
Inside & Out", che e' del 1992).
Ad ogni modo, sicuramente definizione e inizializzazione non sono la
stessa cosa e la frase di Eckel che abbiamo esaminato prima lo evidenzia.


 stessa cosa e la frase di Eckel che abbiamo esaminato prima lo evidenzia.
Ok, ora ho capito, grazie.
E per quanto riguarda i libri tu cosa mi consigli?
Ho visto in libreria "Java 2 La Guida Completa" di Schildt (Mc Graw Hill) e
mi sembrava fatto bene, tu cosa ne dici?
Ciao

 bene, tu cosa ne dici?
Io di solito per iniziare consiglio "Java 2 - I fondamenti" di Horstmann e
Cornell.
Poi, una volta acquisita familiarita', "The Java Programming Language" di
Arnold, Gosling e Holmes e' d'obbligo.
