Newsgroup: it.comp.java
Titolo: scelta di stile o ottimizzazione ?

Ciao a tutti di nuovo,
ho un dubbio su cosa sia meglio e perchè (cioè se è una scelta di stile, 
oppure ha a che fare con l'ottimizzazione... penso al lazy loading)
tra:
class Pippo{
   private ObjectTypeA someObjA;
   private ObjectTypeB someObjB;
   private ObjectTypeC someObjC;
   public Pippo(){
     someObjA = new ObjectTypeA();
     someObjB = new ObjectTypeB();
     someObjC = new ObjectTypeC();
   }
}
oppure
class Pippo{
   private ObjectTypeA someObjA = new ObjectTypeA();
   private ObjectTypeB someObjB = new ObjectTypeB();
   private ObjectTypeC someObjC = new ObjectTypeC();
   public Pippo(){}
}
dove, voglio precisare, nel caso specifico sono sicuro che tutti gli 
oggetti inizializzati sono *indispensabili* al funzionamento della classe.
Oltre al caso specifico, cosa è meglio scegliere tra i due approcci e 
perchè.
grazie,
Matteo

}
Io preferisco questa, perché per me un costruttore deve costruire. Ma
è anche perché sono influenzato dall'uso del C++, in cui non esiste (a
ragione) alternativa.

 oggetti inizializzati sono *indispensabili* al funzionamento della classe.
trattandosi concettualmente di inizializzazione delle variabili la 
modalità corretta è la seconda (quella che ho quotato).
tieni conto che nel ciclo di inizializzazione dell'istanza non ci sono 
solo i costruttori ma anche i blocchi di codice, delimitati da parentesi 
graffe fuori dai metodi, che vengono invocati prima dei costruttori. 
inoltre i costruttori niente vieta siano più di uno.
-- 
? Fino all'anno scorso avevo un solo difetto. Ero presuntuoso.
http://softvalley.blogspot.com
http://www.flickr.com/photos/marko_po/

 perchč.
In sostanza non cambia quasi nulla, specialmente in questo esempio. Io 
personalmente preferisco la seconda.
Tommy 

modalità corretta è la seconda (quella che ho quotato).
Trattandosi "concettualmente" di inizializzazione delle variabili, la
modalità CORRETTA dovrebbe essere la prima, non la seconda. Questo se
proprio si vuol parlare di purezza concettuale.

 proprio si vuol parlare di purezza concettuale.
non sono d'accordo, comunque avevo fatto anche alcune considerazioni 
imho ben sostanziali.


 non sono d'accordo, 
Be', in tutti i linguaggi object-oriented che conosco, l'inizializzazione
di cui parli coincide con la costruzione. E questo perché, sempre
concettualmente, inizializzazione e costruzione vanno di pari passo.
La mia obiezione non č contro le tue "considerazioni ben sostanziali" che
si accordano perň alla natura di Java, nello specifico. Cioč, magari in
Java č meglio fare cosě, ma non (č il mio punto di vista) perché
*concettualmente* č meglio fare cosě.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it


Anche qua inizializzazione e costruzione vanno di pari passo.
I blocchi di inizializazzione e le inizializzazioni delle variabili
vengono sempre eseguiti quando costruisci un oggetto, e quindi se hai
piu' costruttori non devi replicare quella logica di inizializzazione
n volte.


Sulla questione di stile ti hanno gia' risposto...ma il lazy loading
che centra??
Non e' una questione di costruttore. Potresti ottenerlo invece con un
minimo di logica nel getter:
private B b;
public  B getB() {
  if (null == b) {
    b = new B();
  }
  return b;
}
comunque dipende da cosa deve fare questo oggetto (questo codice non
e' thread-safe).

 *concettualmente* č meglio fare cosě.
non capisco cosa intendi dire. in ogni caso, se l'inizializzazione puň 
avvenire in quel modo non vedo perchč si debba deferire al costruttore. 
oltretutto i field in assenza di una inizializzazione esplicita vengono 
comunque inizializzate a dei valori di default, a differenza delle 
variabili locali dove il compilatore ti costringe a inizializzarle 
esplicitamente prima di usarle. quindi non č esattamente la stessa cosa.


 ? Fino all'anno scorso avevo un solo difetto. Ero presuntuoso.http://softvalley.blogspot.comhttp://
www.flickr.com/photos/marko_po/
un po ot, forse.
sono rimasto "shockato" dal concetto di blocco di codice fuori dai
metodi/costruttori all'interno di una classe e ho fatto un paio di
prove su Eclipse x vedere come funzionavano.
come si chiama questa tecnica (quella dell'utilizzo dei blocchi,
intendo)? e soprattutto a cosa serve ?
grazie mille

 intendo)? e soprattutto a cosa serve ?
non è una tecnica. i blocchi non statici vengono eseguiti durante il 
ciclo di creazione dell'oggetto prima del costruttore, nell'ordine in 
cui compaiono (possono essere più di uno).
quelli statici invece durante il caricamento della classe. fra l'altro 
quest'ultimi sono usati anche piuttosto comunemente.
-- 


 oggetti inizializzati sono *indispensabili* al funzionamento della classe.
In tutti e due i casi gli oggetti di tipo ObjectTypeX sono creati e 
allocati nello stesso momento.
Non c'e' nessuna ottimizzazione.
-- 
Andrea Francia
http://www.andreafrancia.it/