Newsgroup: it.comp.java
Titolo: Info su Costruttori e Tipi.

Buongiorno a tutti:
Chi ritiene di avere le idee chiare potrebbe spiegarmi in modo semplice
il significato ed eventualmente le differenze delle seguenti sintassi
????
Classe Auto:
1) Auto auto = new Auto();
2) auto = new Auto();
3) Auto auto;
Grazie.
Lucilla.
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

1)Auto auto = new Auto();
Dichiari una variabile che si chiama 'auto' ed e' di classe Auto, e
contemporaneamente la inizializzi istanziando un oggetto di classe
Auto.
2)auto = new Auto();
alla variabile 'auto' (gia' dichiarata precedentemente, almeno si
spera...) associ una nuova istanza di classe Auto
3)Auto auto;
Dichiari una variabile di nome 'auto' di classe Auto,
l'inizializzazione di default la mette a 'null', quindi equivale a
Auto auto = null;

 Auto auto = null;
Quindi come la uso ?
Posso utilizzare i campi ed i Metodi della Classe Auto ?
O altro ?
Grazie delle risposte.


 Quindi come la uso ?
La usi associando una nuova istanza (caso 2).
In realtà, il tuo caso 1 equivale al 2 e al 3 messi insieme; cioè
Auto auto = new Auto();
Corrisponde a:
Auto auto; //Definisco che "auto" è un oggetto della classe Auto.
auto = new Auto(); //metto nella variabile "auto" un oggetto della 
classe Auto, ottenuto col new
da qui in poi possono esser usati metodi e campi (accessibili) di auto, 
cioè della classe Auto.
bye
DKano

 
Attenzione alla differenza tra *dichiarare* e *definire*!
Java e' un linguaggio "fortemente tipizzato" quindi *ogni*
variabile che usi *deve* essere stata precedentemente dichiarata.
Il costrutto dichiarativo:
Auto auto;
dice al compilatore: "da questo punto in avanti, l'identificatore auto
puo' essere utilizzato come reference di istanze di tipo Auto".
(Vabbe', non e' esattamente cosi', perche' bisogna considerare l'ambito
  di visibilita' in cui avviene la dichiarazione, ma per lo scopo di questo
  messaggio possiamo ritenere valida l'interpretazione che ne ho dato...)
Ora, attenzione: con quell'istruzione *non* hai creato alcun oggetto,
ma solo uno "strumento" (anzi, *l'unico* strumento!) con il quale
il linguaggio Java ti consente di manipolare oggetti.
Nota che ho evitato appositamente l'uso della parola "variabile", perche'
tale concetto puo' essere fuorviante nel contesto del linguaggio Java: il tuo
identificatore auto *non* potra' *mai* essere un oggetto di tipo Auto,
ma sara' *sempre* e *solo* un riferimento (una sorta di "puntatore", ma anche
qui non bisogna farsi ingannare dal termine!) agli oggetti presenti nella
memoria della JVM.
Passiamo al concetto di definizione...
Per creare istanze di classi si usa il comando new, il quale ritorna
proprio un reference all'oggetto che viene creato.
Con lo statement:
Auto auto = new Auto();
fai *due* operazioni contemporaneamente:
a) *dichiari* che auto e' un reference ad oggetti di tipo Auto
b) *definisci* il valore di auto assegnandovi quello ritornato
    dalla istruzione new
da quel punto in poi, auto puo' essere impiegato per manipolare
l'istanza cui si riferisce, invocandone i metodi e/o utilizzandone
gli attributi.
Ora spero ti sia chiaro che lo statement
auto = new Auto();
e' una istruzione Java valida *solo* se in precedenza (e
nello stesso ambito di visibilita', ma questa e' un'altra storia...)
l'identificatore e' stato dichiarato di tipo Auto (o di un tipo
da cui Auto deriva, ma anche questa e' un'altra storia...)
Ciao!
Roberto

Grazie mille delle risposte anche se non mi e' molto chiaro quando
ha senso usare i casi 2) e 3).
Ciao.


Grazie, questa spiegazione mi e' decisamente + chiara.
Ciao.


per poter 'usare una variabile' (oggetto o tipo base) essa deve :
A) essere dichiarata da qualche parte
B) essere visibile nello scope dove la vuoi usare
C) essere inizializzata a un valore (per i tipi base non e' necessario,
ma e' fortemente consigliato)
Spieghiamo meglio:
A)
Se non dichiari una variabile (ovvero dici come si chiama e di che
tipo/classe e') come fa il compilatore quando vede una roba del genere:
auto = new Auto();
che hai scritto una cosa "giusta" oppure e' un errore?
Se la dichiari prima:
Auto auto;
poi quando fai l'assegnamento il compilatore dira': "ok, la variabile
auto esiste, ed e' del tipo corretto.
se invece vede:
auto = new Casa();
ti dira' che la variabile auto non e' di tipo Casa, e quindi ti segnala
che hai fatto un errore.
Ma se non la dichiari prima la variabile (o al momento stesso) come
cavolo fa il compilatore a capire?
B)
La variabile deve essere "visibile" nel luogo dove la stai usando.
ovvero
se la dichiari così
public void f(){
	Auto auto;
}
e poi la usi così
public void altraFunzione(){
	auto = new Auto();
}
il compilatore ti dira' che la variabile auto dentro il metodo
altraFunzione non esiste, perche' e' stata dichiarata si, ma in un
altra funzione,
e non e' visibile dove la vorresti usare
C)
Quando dichiari una variabile il compilatore riserva un blocco di
memoria per contenerne il valore, e lo associa al nome della variabile.
Ma cosa contiene tale area di memoria?
Risposta.. : boh! qualsiasi cosa...
questo potrebbe essere un problema...
ad esempio (non in java..)
int a;
print(a);
stampa "125" !! (o un altro numero a caso)
perche' in quella zona di memoria c'era dentro quel valore....
quindi sarebbe consigliatissimo inizializzare sempre le variabili.
In java per evitare queste schifezze il compilatore inizializza le
variabili con dei valori di default in automatico al momento della
dichiarazione.
ad esempio per i tipi numerici ci mette 0.
qundi in java
int a;
System.out.println(a);
stampa 0
Per le variabili di tipo oggetto il valore di default e' null.
Il problema e' che se tu non crei un oggetto con la new e non lo associ
alla variabile, non potrai usare la variabile oggetto perche' in
realta' essa e' "vuota" (ovvero null)
per chiamare i metodi essa deve contenere un istanza di classe.
e quindi se fai
Auto a;
a.metodo();
ti da una bella NullPointerException

 ha senso usare i casi 2) e 3).
Esempio stupido:
// Sono importanti gli ambiti di visibilita'!!!
Auto auto;  // Dichiarazione (reference *non* inizializzato, cioe' null)
try
{
    auto = new Auto();  // Definizione: ora il reference "punta" ad un oggetto
    // Da qui in avanti supponiamo possano verificarsi le eccezioni
    auto.sterza();
    ...
    auto.frena();
    // Tutte le altre operazioni che ti pare...
}
catch(Exception e)
{
   // Gestisci le eccezioni
   ...
}
finally
{
   // Un'auto DEVE sempre essere spenta e chiusa!
   // NOTA: il reference auto e' visibile e utilizzabile qui
   // solo se viene dichiarato *fuori* dal blocco try-catch!
   auto.spegni();
   auto.bloccaPortiere();
}
Ciao
Roberto