Cómo manejar un inicializador de campo final estático que arroja una excepción comprobada

Question

Me enfrento a un caso de uso en el que me gustaría declarar un campo static final con una declaración de inicializador que se declara arrojar una excepción marcada. Por lo general, se vería así:

public static final ObjectName OBJECT_NAME = new ObjectName("foo:type=bar");

El problema que tengo es que el ObjectName constructor puede lanzar varias excepciones comprobadas, que no importan (porque me conoces mi nombre es válida, y está bien si falla miserablemente en caso de que no lo sea). El compilador de Java no me deja simplemente ignorar este (ya que es una excepción comprobada), y yo preferiría no recurrir a:

 
public static final ObjectName OBJECT_NAME; 
static{ 
    try{ 
     OBJECT_NAME = new ObjectName("foo:type=bar"); 
    }catch(final Exception ex){ 
     throw new RuntimeException("Failed to create ObjectName instance in static block.",ex); 
    } 
} 

Debido bloques estáticos son muy, muy difícil de leer. ¿Alguien tiene una sugerencia sobre cómo manejar este caso de una manera agradable y limpia?

Answer 1

Si no te gustan los bloques estáticos (algunas personas no), entonces una alternativa es usar un método estático. IIRC, Josh Bloch lo recomendó (aparentemente no en Java efectivo en una inspección rápida).

public static final ObjectName OBJECT_NAME = createObjectName("foo:type=bar"); 

private static ObjectName createObjectName(final String name) { 
    try { 
     return new ObjectName(name); 
    } catch (final SomeException exc) { 
     throw new Error(exc); 
    } 
} 

O:

public static final ObjectName OBJECT_NAME = createObjectName(); 

private static ObjectName createObjectName() { 
    try { 
     return new ObjectName("foo:type=bar"); 
    } catch (final SomeException exc) { 
     throw new Error(exc); 
    } 
} 

(Editado:. Corregido segundo ejemplo para regresar de método en lugar de asignar el static)

Answer 2

static bloques no son difíciles de leer. Así que recomendaría esa solución. Sin embargo, puede ajustar su objeto en otro objeto, por ejemplo ObjectNameWrapper que comparte un interface con su ObjectName, y cuyo constructor llama al constructor ObjectName, ocultando todas las excepciones marcadas que se producen. Pero de nuevo, elegiría la opción estática.

Answer 3

Su código es perfectamente válido. No me resulta difícil leer. Otras formas solo lo empeorarían. Para empezar son difíciles de leer, porque la mayoría de ellos no están familiarizados con eso. Simplemente siga las convenciones estándar con respecto al orden de los elementos en el código. P.ej. no coloque inicializadores estáticos a la mitad o en la parte inferior del código y tampoco tenga varios de ellos extendiéndose sobre la clase. Simplemente ponga uno en la parte superior, después de las declaraciones estáticas.