En Java, ¿se puede inicializar un campo final desde un ayudante de constructor?

Question

que tienen un miembro no static final:

private final HashMap<String,String> myMap; 

me gustaría inicializarlo utilizando un método llamado por el constructor. Como myMap es final, mi método de "ayuda" no puede inicializarlo directamente. Por supuesto que tengo opciones:

Podría implementar el código de inicialización myMap directamente en el constructor.

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

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

    // other initialization stuff unrelated to myMap 
} 

pude tener mi método de ayuda construir el HashMap, devuélvalo al constructor, y tienen el constructor a continuación, asignar el objeto a myMap. Método

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; 
} 

# 2 está muy bien, sin embargo, me pregunto si hay alguna manera de que pudiera permitir que el método de ayuda para manipular directamente myMap. ¿Tal vez un modificador que indique que solo puede ser llamado por el constructor?

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

Método n. ° 2 es su mejor opción. El problema es que si tienes una asignación en un método privado, no hay nada que impida que otro código en la clase esté fuera del constructor que lo llama, lo que crearía un problema con una segunda asignación intentada al campo final.

Java no tiene ningún constructo de un método separado que solo se pueda invocar durante la construcción.

Para completar, podemos hacer una tercera opción, en la que asignará el mapa en la inicialización y luego tener el método de ayuda llenarlo:

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

Y luego:

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... 
    } 

Y si realmente quiero ser confuso puedes usar un inicializador en lugar de un constructor, pero no deberías hacer eso, así que a menos que realmente necesites saberlo, no ampliaré eso.

Answer 2

La opción n. ° 2 es la opción más resuable, porque puede compartirla entre todos los constructores. Lo que necesitaríamos aquí, son los inicializadores de colección de C#. :)

(Por cierto: # 3 no se compilará)

Answer 3

¿Qué hay de la implementación de un constructor privado que inicializa el HashMap, y luego tener su constructor principal (s) que llame constructor privado?

Por ejemplo-

// 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. 
} 

Usted puede modificar la firma del constructor de ayuda privado, según sea necesario (por ejemplo, para proporcionar datos de parámetros o para hacer la firma distinta de cualquier constructores públicos).