¿Debería declararse un" registrador final estático " en mayúsculas?

Para agregar más valor a la respuesta de crunchdog, la Java Coding Style Guide establece esto en el párrafo 3.3 Field Naming

Los nombres de los campos que se usan como constantes deben estar todos en mayúsculas, con guiones bajos separando las palabras. Se consideran constantes las siguientes:

1. Todos los tipos primitivos static final (Recuerde que todos los campos de interfaz son inherentemente static final).
2. Todos los tipos de referencia de objeto static final que nunca son seguido de ". " (punto).
3. Todos los arreglos static final que nunca son seguidos por "[" (punto).

Ejemplos:

MIN_VALUE, MAX_BUFFER_SIZE, OPTIONS_FILE_NAME

Siguiendo esta convención, logger es una referencia de objeto static final como se indica en el punto 2, pero debido a que es seguido de "." cada vez que lo usa, no puede considerarse como una constante y, por lo tanto, debe ser en minúsculas.

From effective java, 2nd ed.,

La única excepción a la regla anterior se refiere a " campos constantes," cuyos nombres deben consistir en una o más palabras en mayúsculas separadas por el carácter de subrayado, por ejemplo, VALUES o NEGATIVE_INFINITY. A el campo constante es un campo final estático cuyo valor es inmutable . Si a el campo final estático tiene un tipo primitivo o un tipo de referencia inmutable (Ítem 15), entonces es un campo constante. Por ejemplo, constantes de enumeración son campos constantes. Si un campo final estático tiene una referencia mutable tipo, todavía puede ser un campo constante si el objeto referenciado es inmutable.

En resumen, constant == static final, más si es una referencia (vs.un tipo simple), inmutabilidad.

Mirando el registrador slf4j, http://www.slf4j.org/api/org/slf4j/Logger.html

Es inmutable. Por otro lado, el registrador de JULIO es mutable. El log4j logger también es mutable. Así que para ser correcto, si está usando log4j o JUL, debería ser "logger", y si está usando slf4j, debería ser LOGGER.

Tenga en cuenta que la página slf4j javadocs enlazada anteriormente tiene un ejemplo donde usan "logger", no "LOGGER".

Estas son, por supuesto, solo convenciones y no reglas. Si está usando slf4j y desea usar "logger" porque está acostumbrado a eso de otros frameworks, o si es más fácil de escribir, o para legibilidad, adelante.

Me gusta la toma de Google en él (Google Java Style )

Cada constante es un campo final estático, pero no todos los campos finales estáticos son constantes. Antes de elegir el caso constante, considere si el campo realmente se siente como una constante. Por ejemplo, si cualquiera de los estados observables de esa instancia puede cambiar, es casi seguro que no es una constante. La mera intención de nunca mutar el objeto generalmente no es suficiente.

Ejemplos:

// Constants
static final int NUMBER = 5;
static final ImmutableList<String> NAMES = ImmutableList.of("Ed", "Ann");
static final Joiner COMMA_JOINER = Joiner.on(',');  // because Joiner is immutable
static final SomeMutableType[] EMPTY_ARRAY = {};
enum SomeEnum { ENUM_CONSTANT }

// Not constants
static String nonFinal = "non-final";
final String nonStatic = "non-static";
static final Set<String> mutableCollection = new HashSet<String>();
static final ImmutableSet<SomeMutableType> mutableElements = ImmutableSet.of(mutable);
static final Logger logger = Logger.getLogger(MyClass.getName());
static final String[] nonEmptyArray = {"these", "can", "change"};

Si está utilizando una herramienta automatizada para verificar sus estándares de codificación y viola dichos estándares, entonces debe arreglarse. Si estás usando un estándar externo, arregla el código.

La convención en Sun Java es mayúscula para constantes estáticas públicas. Obviamente, un registrador no es constante, sino que representa una cosa mutable( de lo contrario no tendría sentido llamar a métodos en él con la esperanza de que algo suceda); no hay un estándar específico para final no constante campo.

Si google esto, puede encontrar que en algunos casos, los registradores no se definen como static final. Agregue un poco de copy-n-paste rápido a esto, y esto podría explicarlo.

Usamos LOGGER en todo nuestro código, y esto corresponde a nuestra convención de nomenclatura (y nuestro CheckStyle está contento con ello).

Incluso vamos más allá, aprovechando la estricta convención de nomenclatura en Eclipse. Creamos una nueva clase con una plantilla de código de:

    // private static final Logger LOGGER = Logger.getLogger(${enclosing_type}.class);

Se comenta el registrador fuera, ya que inicialmente no lo necesitamos. Pero si lo necesitamos más tarde, simplemente lo descomentamos.

Luego en el código, usamos plantillas de código que esperan que este registrador esté presente. Ejemplo con la plantilla try-catch:

    try {
      ${cursor} or some other template
    } catch (Exception t) {
      LOGGER.error("${methodName} ${method parameters}", t);
    }

Tenemos algunas plantillas más que lo usan.

La convención estricta nos permite ser más productivos y coherentes con las plantillas de código.

Personalmente creo que se ve muy grande en mayúsculas. Además, dado que es una clase que no está directamente relacionada con el comportamiento de la clase, no veo un problema importante en usar logger en lugar de LOGGER. Pero si vas a ser estrictamente pedante, entonces usa LOGGER.

No olvides que PMD respetará un comentario con

// NOPMD

En él. Esto hará que PMD omita la línea de sus comprobaciones, esto le permitirá elegir el estilo que desee.

Normalmente las constantes están en mayúsculas.

Los registradores, sin embargo, no deben ser estáticos, sino buscar cada "nuevo" de la clase contenedora si se usa la fachada slf4j. Esto evita algunos problemas desagradables de classloader en contenedores web, además de que permite que el marco del registrador haga cosas especiales dependiendo del contexto de invocación.

Si sus estándares de codificación - si tiene alguno - dicen que debe ser mayúscula entonces sí.

No veo ninguna razón estricta para una forma u otra. Creo que depende totalmente de sus gustos personales resp. los estándares de codificación de su empresa.

POR cierto: Prefiero "LOGGER"; -)