Convenciones de codificación: enumeraciones de nombres

¿Existe una convención para nombrar enumeraciones en Java?

Mi preferencia es que una enumeración es un tipo. Entonces, por ejemplo, tienes una enumeración

Fruit{Apple,Orange,Banana,Pear, ... }

NetworkConnectionType{LAN,Data_3g,Data_4g, ... }

Me opongo a nombrarlo:

FruitEnum
NetworkConnectionTypeEnum

Entiendo que es fácil elegir qué archivos son enumeraciones, pero entonces también tendrías:

NetworkConnectionClass
FruitClass

Además, ¿hay un buen documento que describa lo mismo para las constantes, dónde declararlas, etc.?

Las enumeraciones son clases y deben seguir las convenciones para las clases. Las instancias de una enumeración son constantes y deben seguir las convenciones para las constantes. Entonces

enum Fruit {APPLE, ORANGE, BANANA, PEAR};

No hay ninguna razón para escribir FruitEnum más que FruitClass. Solo está desperdiciando cuatro (o cinco) caracteres que no agregan información.

El propio Java recomienda este enfoque y se usa en sus ejemplos .

Esto probablemente no me hará muchos nuevos amigos, pero debe agregarse que las personas de C # tienen una directriz diferente: las instancias de enumeración son "Pascal case" (mayúsculas / minúsculas mezcladas). Consulte la discusión sobre stackoverflow y las Pautas de nomenclatura de tipos de enumeración de MSDN .

Como estamos intercambiando datos con un sistema C #, me siento tentado a copiar sus enumeraciones exactamente, ignorando la convención de "las constantes tienen nombres en mayúsculas" de Java. Pensando en ello, no veo mucho valor en estar restringido a mayúsculas para instancias de enumeración. Para algunos propósitos .name () es un atajo útil para obtener una representación legible de una constante enum y un nombre de mayúsculas y minúsculas se vería mejor.

Entonces, sí, me atrevo a cuestionar el valor de la convención de nomenclatura de enumeración Java. El hecho de que "la otra mitad del mundo de la programación" sí usa un estilo diferente me hace pensar que es legítimo dudar de nuestra propia religión.

Como ya se indicó, las instancias de enumeración deben estar en mayúsculas según los documentos en el sitio web de Oracle ( http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html ).

Sin embargo, mientras miraba un tutorial de JavaEE7 en el sitio web de Oracle ( http://www.oracle.com/technetwork/java/javaee/downloads/index.html ), me topé con el tutorial "Librería de Duke" y en una clase ( tutorial\examples\case-studies\dukes-bookstore\src\main\java\javaeetutorial\dukesbookstore\components\AreaComponent.java), Encontré la siguiente definición de enumeración:

private enum PropertyKeys {
    alt, coords, shape, targetImage;
}

Según las convenciones, debería haberse visto así:

public enum PropertyKeys {
    ALT("alt"), COORDS("coords"), SHAPE("shape"), TARGET_IMAGE("targetImage");

    private final String val;

    private PropertyKeys(String val) {
        this.val = val;
    }

    @Override
    public String toString() {
        return val;
    }
}

Parece que incluso los chicos de Oracle a veces intercambian convenciones con conveniencia.

En nuestra base de código; Por lo general, declaramos enumeraciones en la clase a la que pertenecen.

Entonces, para su ejemplo de frutas, tendríamos una clase de frutas, y dentro de eso una enumeración llamada frutas.

Hacer referencia en el código se ve así: Fruit.Fruits.Apple, Fruit.Fruits.Pear etc.

Las constantes siguen la misma línea, donde se definen en la clase para la que son relevantes (algo así como Fruit.ORANGE_BUSHEL_SIZE); o si se aplican en todo el sistema (es decir, un "valor nulo" equivalente para ints) en una clase llamada "ConstantManager" (o equivalente, comoConstantManager.NULL_INT ). (nota al margen; todas nuestras constantes están en mayúsculas)

Como siempre, sus estándares de codificación probablemente difieran de los míos; entonces YMMV.

Todavía son tipos, así que siempre uso las mismas convenciones de nombres que uso para las clases.

Definitivamente frunciría el ceño al poner "Clase" o "Enum" en un nombre. Si tiene tanto a FruitClasscomo a, FruitEnumentonces algo más está mal y necesita nombres más descriptivos. Estoy tratando de pensar en el tipo de código que llevaría a la necesidad de ambos, y parece que debería haber una Fruitclase base con subtipos en lugar de una enumeración. (Sin embargo, eso es solo mi propia especulación, es posible que tenga una situación diferente a la que estoy imaginando).

La mejor referencia que puedo encontrar para nombrar constantes proviene del tutorial Variables :

Si el nombre que elige consta de una sola palabra, deletree esa palabra en minúsculas. Si consta de más de una palabra, escriba en mayúscula la primera letra de cada palabra subsiguiente. Los nombres gearRatio y currentGear son ejemplos principales de esta convención. Si su variable almacena un valor constante, como estático int int NUM_GEARS = 6, la convención cambia ligeramente, capitaliza cada letra y separa las palabras posteriores con el carácter de subrayado. Por convención, el carácter de subrayado nunca se usa en otro lugar.

Si puedo agregar $ 0.02, prefiero usar PascalCase como valores de enumeración en C.

En C, son básicamente globales, y PEER_CONNECTED se vuelve realmente agotador en comparación con PeerConnected.

Un respiro de aire fresco.

Literalmente, me hace respirar más fácilmente.

En Java, es posible usar nombres de enumeración sin formato siempre que los importe de forma estática desde otra clase.

import static pkg.EnumClass.*;

Ahora, puede usar los nombres no calificados, que ya calificó de una manera diferente.

Actualmente estoy (pensando) en portar algún código C a Java y actualmente estoy 'dividido' entre elegir la convención Java (que es más detallada, más larga y más fea) y mi estilo C.

PeerConnected se convertiría en PeerState.CONNECTED, excepto en las instrucciones de cambio, donde está CONECTADO.

Ahora hay mucho que decir sobre la última convención y se ve bien, pero ciertas "frases idiomáticas" como if (s == PeerAvailable)ser if (s == PeerState.AVAILABLE)y nostálgicamente, esto es una pérdida de significado para mí.

Creo que todavía prefiero el estilo Java debido a la claridad, pero me resulta difícil mirar el código de gritos.

Ahora me doy cuenta de que PascalCase ya se usa ampliamente en Java, pero es muy confuso que realmente no lo sea, solo un poco fuera de lugar.

enum MyEnum {VALUE_1,VALUE_2}

es (aproximadamente) como decir

class MyEnum {

    public static final MyEnum VALUE_1 = new MyEnum("VALUE_1");
    public static final MyEnum VALUE_2 = new MyEnum("VALUE_2");

    private final name;

    private MyEnum(String name) {
        this.name = name;
    }

    public String name() { return this.name }
}

así que supongo que las mayúsculas son estrictamente más correctas, pero aún así uso la convención de nombre de clase ya que odio las mayúsculas donde sea