In Java, un campo finale può essere inizializzato da un helper costruttore?

Question

Ho un membro static finale:

private final HashMap<String,String> myMap; 

desidero inizializzare utilizzando un metodo chiamato dal costruttore. Poiché myMap è definitivo, il mio metodo "helper" non è in grado di inizializzarlo direttamente. Certamente ho opzioni:

Potrei implementare il codice di inizializzazione myMap direttamente nel costruttore.

MyConstructor (String someThingNecessary) 
{ 
    myMap = new HashMap<String,String>(); 

    myMap.put("blah","blahblah"); 
    // etc... 

    // other initialization stuff unrelated to myMap 
} 

ho potuto avere il mio metodo di supporto costruire l'HashMap, restituirlo al costruttore, e hanno il costruttore quindi assegnare l'oggetto da myMap.

MyConstructor (String someThingNecessary) 
{ 
    myMap = InitializeMyMap(someThingNecessary); 

    // other initialization stuff unrelated to myMap 
} 

private HashMap<String,String> InitializeMyMap(String someThingNecessary) 
{ 
    HashMap<String,String> initializedMap = new HashMap<String,String>(); 

    initializedMap.put("blah","blahblah"); 
    // etc... 

    return initializedMap; 
} 

Metodo # 2 va bene, però, mi chiedo se c'è qualche modo ho potuto consentire al metodo di supporto per manipolare direttamente myMap. Forse un modificatore che lo indica può essere chiamato solo dal costruttore?

MyConstructor (String someThingNecessary) 
{ 
    InitializeMyMap(someThingNecessary); 

    // other initialization stuff unrelated to myMap 
} 


// helper doesn't work since it can't modify a final member 
private void InitializeMyMap(String someThingNecessary) 
{ 
    myMap = new HashMap<String,String>(); 

    myMap.put("blah","blahblah"); 
    // etc... 
} 

Answer 1

Il metodo n. 2 è la soluzione migliore. Il problema è che se si ha un'assegnazione in un metodo privato non c'è nulla che impedisca l'altro codice nella classe all'esterno del costruttore che lo chiama, il che quindi creerebbe un problema con un tentativo di secondo assegnamento al campo finale.

Java non ha costrutto di un metodo separato che può essere chiamato solo durante la costruzione.

Per completezza, possiamo fare una terza opzione, dove si assegna la mappa in fase di inizializzazione e quindi avere il metodo di supporto riempirlo:

private final HashMap<String, String> myMap = new HashMap<String, String(); 

E poi:

MyConstructor (String someThingNecessary) 
{ 
    initializeMyMap(someThingNecessary); 

    // other initialization stuff unrelated to myMap 
} 


// helper doesn't work since it can't modify a final member 
private void initializeMyMap(String someThingNecessary) 
{ 

    myMap.clear(); 
    myMap.put("blah","blahblah"); 
    // etc... 
    } 

E se si voglio davvero essere confuso puoi usare un inizializzatore invece di un costruttore, ma non dovresti farlo, quindi a meno che tu non abbia davvero bisogno di sapere, non lo espanderò.

Answer 2

L'opzione n. 2 è l'opzione più resuable, perché è possibile condividerla tra tutti i costruttori. Quello di cui avremmo bisogno qui, sono inizializzatori di raccolta di C#. :)

(BTW: # 3 non verrà compilato)

Answer 3

Come circa l'attuazione di un costruttore privato che inizializza il vostro HashMap, e quindi avere il costruttore principale (s) chiamare tale costruttore privato?

Per example--

// Helper function to initialize final HashMap. 
private MyConstructor() 
{ 
    myMap = new HashMap<String,String>(); 
    myMap.put("blah","blah"); 
} 

MyConstructor (String someThingNecessary) 
{ 
    // Initialize the HashMap. 
    this(); 
    // Other initialization code can follow. 
} 

È possibile modificare la firma del costruttore di supporto privato, se necessario (ad esempio, per fornire i dati dei parametri o per effettuare la firma distinta da qualsiasi costruttori pubblici).