Convenzione in java - "nuovo" al di fuori del costruttore/metodo?

Question

Domanda semplice. Un amico della mente ha scritto il codice simile a questo (che è solo per spiegare la mia domanda, non è utile a tutti ....)

class Example{ 
    private int[] tab = new int[10]; 
    public Example() { 
     for(int i = 0 ; i < 10 ; i++) 
      tab[i] = (int)(Math.random()*100); 
     for(int i = 0 ; i < 10 ; i++) 
      System.out.println(tab[i]); 
    } 
    public static void main(String[] arg) { 
     Example ex = new Example(); 
    } 
} 

Gli ho detto che dovrebbe mettere la new all'interno del costruttore

Quando mi chiede perché, non so cosa rispondere: non ho avuto un argomento preciso se non "è meglio così". Per come lo imparo, puoi inizializzare le variabili con tipi di base (int, double ...) ma per gli array dovresti farlo nel costruttore.

Quindi:

• è davvero meglio?
• Ci sono dei buoni motivi: convenzione, stile?
• Cambia qualcosa come meno/più memoria utilizzata?

Non sto considerando il caso in cui il numero di elementi può variare. Sarà SEMPRE 10

Answer 1

• è davvero meglio?

Non proprio, IMO.

• c'è qualche buona ragione: convenzione? stile ?

Ci possono essere motivi validi per scegliere un modo sopra l'altro è quando si dispone di più costruttori, o quando i valori iniziali dipendono argomenti del costruttore; per esempio.

private int[] tab; 

public Example(int size) { 
    tab = new int[size]; 
    for (int i = 0; i < size; i++) 
     tab[i] = (int) (Math.random() * 100); 
} 

o

private int[] tab = new int[10]; 

public Example(int initial) { 
    for (int i = 0; i < 10; i++) 
     tab[i] = initial; 
} 

public Example() { 
    for (int i = 0; i < 10; i++) 
     tab[i] = (int) (Math.random() * 100); 
} 

A parte questo (e nel tuo esempio) non ci sono regole generali su questo. È una questione di gusti personali.

• cambia qualcosa come meno/più memoria utilizzata?

Nel tuo esempio non farà differenza. In generale, potrebbe esserci una piccola differenza nelle dimensioni del codice o nelle prestazioni, ma non vale la pena preoccuparsi.

In breve, non penso che il tuo suggerimento per il tuo amico abbia una base razionale.

Il modo in cui l'ho imparato, è possibile inizializzare le variabili con tipi di base (int, double ...) ma per gli array dovresti farlo nel costruttore.

Dovresti disimparare che ... o almeno riconoscere che è solo una preferenza personale.

Answer 2

In realtà preferisco usare il metodo esterno. Se ha aggiunto un costruttore e aveva

private int[] foo = new int[10]; 

public Example() { } 

public Example(int somethVar) { } 

Quindi entrambi i costruttori avrebbero un array foo pronto per l'uso. Vedi this article poiché il compilatore Java è abbastanza intelligente da copiare solo quella roba nel costruttore, quindi non è affatto meglio.

Answer 3

Non sono a conoscenza di vantaggi funzionali/prestazionali di un metodo o dell'altro. Ma ecco alcuni pensieri perché l'inizializzazione della variabile immediatamente può essere migliore.

1. Se si dispone di tre diversi costruttori, non si desidera inserire new int[10]; in ciascuno, giusto?
2. Leggibilità. Quando vedo la variabile usata nel codice, posso fare "ctrl-clic" nel mio IDE e vedere sia il tipo che il valore di esso. Non devo cercare un posto dove è stato inizializzato.

Answer 4

mi piace per inizializzare le mie variabili di istanza non statici nel costruttore,

fare questo rende più facile per gli altri a riconoscere che la strategia viene seguita quando il costruttore si correva.

Ogni nuovo oggetto avrà la propria istanza tab, quindi nel tuo esempio non importa se la classe rimane la stessa.

L'unica volta che uso un costruttore è quando ho bisogno di passare i parametri che si applica a tutto l'oggetto e non ad un metodo specifico, ad esempio:

public class Authenticate{ 
    private String usrname; 
    private String password; 
    public Authenticate(String usernameParam,String passwordParam){ 
     this.usrname = usernameParam; 
     this.password = passwordParam; 
    } 

    public void login(){ 
     //TODO put some code here to authenticate against some server using some technology. 
    } 

    public String getDepartment(){ 
     //Get the department where the username and password variable would be necessary if 
     //login hasn't been called. 
    } 
} 

Answer 5

Questo è destinata probabilmente ad essere una domanda stupida e quindi essere votati, ma ... perché il tuo amico non usa un blocco di inizializzazione per, sai, l'inizializzazione?

Capisco perfettamente il motivo per cui non vuole metterlo nel costruttore perché potrebbe non essere il costruttore e ripetendo all'infinito il codice di inizializzazione in ogni costruttore è ovviamente male durante l'utilizzo di un costruttore no-arg e basandosi su le chiamate automatiche a this() possono essere snervanti.

Quindi ...

Ecco il codice che userei io:

class Example{ 
    private int[] tab; 

    { tab = new int[10]; } 

    public Example() { 
     for(int i = 0 ; i < 10 ; i++) 
      tab[i] = (int)(Math.random()*100); 
     for(int i = 0 ; i < 10 ; i++) 
      System.out.println(tab[i]); 
    } 
    public static void main(String[] arg) { 
     Example ex = new Example(); 
    } 
} 

mi piacerebbe anche approssimativamente usare quella struttura: dichiarare i miei soci privati, mettere nel blocco di inizializzazione, dichiarare la mia costruttori, dichiara il resto dei miei metodi.