Error al establecer un valor nulo predeterminado para el campo de una anotación

¿Por qué recibo un error "El valor del atributo debe ser constante"? ¿No es nula constante ???

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface SomeInterface {
    Class<? extends Foo> bar() default null;// this doesn't compile
}

No sé por qué, pero el JLS es muy claro:

 Discussion

 Note that null is not a legal element value for any element type. 

Y la definición de un elemento predeterminado es:

     DefaultValue:
         default ElementValue

Desafortunadamente, sigo encontrando que las nuevas funciones del lenguaje (Enums y ahora Anotaciones) tienen mensajes de error del compilador muy inútiles cuando no cumples con las especificaciones del lenguaje.

EDITAR: Un poco de búsqueda en Google encontró lo siguiente en el JSR-308, donde argumentan a favor de permitir nulos en esta situación:

Observamos algunas posibles objeciones a la propuesta.

La propuesta no hace posible nada que no fuera posible antes.

El valor especial definido por el programador proporciona una mejor documentación que nulo, lo que podría significar "ninguno", "no inicializado", nulo en sí, etc.

La propuesta es más propensa a errores. Es mucho más fácil olvidar la comprobación de un valor nulo que olvidar la comprobación de un valor explícito.

La propuesta puede hacer que el modismo estándar sea más detallado. Actualmente, solo los usuarios de una anotación necesitan verificar sus valores especiales. Con la propuesta, muchas herramientas que procesan anotaciones tendrán que verificar si el valor de un campo es nulo para que no arrojen una excepción de puntero nulo.

Creo que solo los dos últimos puntos son relevantes para "por qué no hacerlo en primer lugar". El último punto ciertamente trae a colación un buen punto: un procesador de anotaciones nunca tiene que preocuparse de que obtendrán un valor nulo en un valor de anotación. Tiendo a ver eso como más trabajo de los procesadores de anotaciones y otro código de marco similar tener que hacer ese tipo de verificación para que el código de los desarrolladores sea más claro en lugar de al revés, pero ciertamente haría difícil justificar el cambio.

Prueba esto

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface SomeInterface {
    Class bar() default void.class;
}

No requiere una nueva clase y ya es una palabra clave en Java que no significa nada.

Parecería que esto es ilegal, aunque el JLS es muy confuso al respecto.

Arruiné mi memoria para intentar pensar en una anotación existente que tuviera un atributo de clase para una anotación, y recordé esta de la API de JAXB:

@Retention(RUNTIME) @Target({PACKAGE,FIELD,METHOD,TYPE,PARAMETER})        
public @interface XmlJavaTypeAdapter {
    Class type() default DEFAULT.class;

    static final class DEFAULT {}    
}

Puede ver cómo han tenido que definir una clase estática ficticia para mantener el equivalente a un valor nulo.

Desagradable.

Parece que hay otra forma de hacerlo.

Esto tampoco me gusta, pero podría funcionar.

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface SomeInterface {
    Class<? extends Foo>[] bar() default {};
}

Entonces, básicamente, creas una matriz vacía en su lugar. Esto parece permitir un valor predeterminado.

Class<? extends Foo> bar() default null;// this doesn't compile

Como se mencionó, la especificación del lenguaje Java no permite valores nulos en los valores predeterminados de las anotaciones.

Lo que suelo hacer es definir DEFAULT_VALUEconstantes en la parte superior de la definición de la anotación. Algo como:

public @interface MyAnnotation {
    public static final String DEFAULT_PREFIX = "__class-name-here__ default";
    ...
    public String prefix() default DEFAULT_PREFIX;
}

Luego en mi código hago algo como:

if (myAnnotation.prefix().equals(MyAnnotation.DEFAULT_PREFIX)) { ... }

En su caso con una clase, simplemente definiría una clase de marcador. Desafortunadamente, no puede tener una constante para esto, por lo que debe hacer algo como:

public @interface MyAnnotation {
    public static Class<? extends Foo> DEFAULT_BAR = DefaultBar.class;
    ...
    Class<? extends Foo> bar() default DEFAULT_BAR;
}

Su DefaultFooclase sería solo una implementación vacía para que el código pueda hacer:

if (myAnnotation.bar() == MyAnnotation.DEFAULT_BAR) { ... }

Espero que esto ayude.

Ese mensaje de error es confuso, pero no, el nullliteral no es una expresión constante, como se define en la especificación del lenguaje Java, aquí .

Además, la especificación del lenguaje Java dice

Es un error en tiempo de compilación si el tipo de elemento no es acorde (§9.7) con el valor predeterminado especificado.

Y para explicar lo que eso significa

Es un error en tiempo de compilación si el tipo de elemento no es acorde con el valor del elemento. Un tipo de elemento T es proporcional a un valor de elemento V si y solo si se cumple una de las siguientes condiciones:

• Tes un tipo de matriz E[]y:
  • [...]
• Tno es un tipo de matriz y el tipo de Vasignación es compatible (§5.2) con T, y :
  • Si Tes un tipo primitivo o String, entonces Ves una expresión constante (§15.28).
  • Si Tes Classo una invocación de Class(§4.5), entonces Ves un literal de clase (§15.8.2).
  • Si Tes un tipo de enumeración (§8.9), entonces Ves una constante de enumeración (§8.9.1).
  • V no es nulo .

Entonces, aquí, su tipo de elemento Class<? extends Foo>,, no es acorde con el valor predeterminado, porque ese valor es null.

Como han dicho otros, hay una regla que dice que nulo no es un valor predeterminado válido en Java.

Si tiene un número limitado de valores posibles que puede tener el campo , entonces una opción para solucionar esto es hacer que el tipo de campo sea una enumeración personalizada que a su vez contenga una asignación a nulo. Por ejemplo, imagina que tengo la siguiente anotación para la que quiero un valor nulo predeterminado:

public @interface MyAnnotation {
   Class<?> value() default null;
}

Como hemos establecido, esto no está permitido. Lo que podemos hacer en cambio es definir una enumeración:

public enum MyClassEnum {
    NULL(null),
    MY_CLASS1(MyClass1.class),
    MY_CLASS2(MyClass2.class),
    ;

    public final Class<?> myClass;

    MyClassEnum(Class<?> aClass) {
        myClass = aClass;
    }
}

y cambie la anotación como tal:

public @interface MyAnnotation {
  MyClassEnum value() default MyClassEnum.NULL;
}

La principal desventaja de esto (además de tener que enumerar sus posibles valores) es que ahora ha envuelto su valor en una enumeración, por lo que deberá invocar la propiedad / captador en la enumeración para obtener el valor.