Newsgroup: it.comp.java
Titolo: <constructor> - c'e' differenza tra...

c'e' differenza nello scrivere:
class Foo {
  MyClass x = new MyClass();
  ...
}
e scrivere
class Foo {
  MyClass x = null;
  public Foo() {
    x = new MyClass();
  }
}
cioe', nel primo caso x viene creato al momento dell'instanziazione di Foo?
e basta?


Credo che dal momento che x non è un campo statico, le due scritture sono
funzionalmente identiche.
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 }
Sì, c'è differenza.
Infatti il primo e il secondo codice producono bytecode diversi.
Invece non c'è differenza tra il primo e il seguente terzo codice:
   class Foo {
     MyClass x;
     public Foo() {
       x = new MyClass();
     }
   }
Il secondo codice è differente dagli altri due (primo e terzo)
perché viene generato un inutile assegnamento
    x = null;
immediatamente seguito da:
    x = new MyClass();
A parte la performance,
dal punto di vista algoritmico non ci sono differenze.
- Dario
I seguenti codici sono invece differenti tra di loro
anche dal punto di vista algoritmico.
   class Foo {
     MyClass x = null;
     public Foo() {
       ...
     }
   }
   class Foo {
     MyClass x;
     public Foo() {
       ...
     }
   }
Lascio all'attento lettore scrivere un piccolissimo
programma di prova che evidenzi la differenza,
cioè che stampi due risultati diversi nei due casi.

 cioč che stampi due risultati diversi nei due casi.
Programmo da un po' in Java, e sono sempre stata convinta (a questo punto
sospetto erroneamente) che i membri dati di una classe in java vengono
automaticamente inizializzati ad un valore di default (ad es. false per i
boolean, 0 per gli int, e - credevo - null per i riferimenti). 
Dalla tua osservazione mi sorge il dubbio che non sia affatto cosě... mi
puoi dire per piacere come stanno le cose?
Grazie,
Claudia
-- 
"sul viale del tramonto il telefonino non prende"

 puoi dire per piacere come stanno le cose?
No. Hai ragione tu.
I membri dati di una classe in java vengono sempre inizializzati
ad un valore default; per esempio i references vengono sempre
inizializzati a null.
Il mio "problemino" non voleva mica dimostare che i membri
non sono inizializzati!
Il mio problema vuole solo far ragionare su cosa significa scrivere
  MyClass x = null;
Non significa inizializzare x a null. Lo fa già Java!
Significa invece aggiungere un assegnamento
ad una variabile già inizializzata.
Ma quando verrà eseguito questo assegnamento?
Le specifiche del linguaggio lo dicono chiaramente!
L'assegnamento NON viene eseguito all'atto della creazione
dell'istanza (quando si crea l'istanza x è inizializzato con null)
ma un po` tanto dopo....
Così io posso scrivere questo semplice programma:
abstract class Super {
  Super() {mystic();}
  void mystic() {}
}
class MyClass{}
class Foo extends Super {
  MyClass x;
  Foo() {System.out.println(x == null);}
  void mystic() {x=new MyClass();}
  public static void main(String[]args) {new Foo();}
}
Questo programma stampa false.
Se però io cambio da:
  MyClass x;
a
  MyClass x = null;
allora il programma stampa true.
La parte interessante della specifica si trova in:
<
http://java.sun.com/docs/books/jls/second_edition/html/execution.doc
.
html#44670>
dove il punto
 4. Execute the instance initializers and instance variable initializers
viene dopo il
 3. explicit or implicit invocation of a superclass constructor
che viene dopo lo
 0. all the instance variables in the new object, including those
    declared in superclasses, are initialized to their default values.
Buon divertimento con Java!
- Dario
Inviato da 
www.mynewsgate.net

 Le specifiche del linguaggio lo dicono chiaramente!
Ma porc@#!!!!!!!!
Non mi ero mai letta questa cosa... e se ci pensi non è molto intuitivo,
avrei pensato che l'inizializzazione dei membri dati venisse eseguita o
*prima* del costruttore, o *dopo*, non a metà fra l'esecuzione del
costruttore della classe base e quella del costruttore della sottoclasse...
in pratica se io scrivo il costruttore di Foo così:
Foo
{
  super();
  System.out....
}
l'inizializzazione si va ad "incastrare" a metà fra le due istruzioni!
Questo mi spiega finalmente un problema che avevo riscontrato qualche mese
fa in un programma!!! Mi ero accorta che eliminando l'inizializzazione si
risolveva, ma non avevo capito il perché...
Che dire, si impara sempre qualcosa di nuovo.
