Convenzioni di codifica - Enumerazione dei nomi

Esiste una convenzione per nominare le enumerazioni in Java?

La mia preferenza è che un enum sia un tipo. Quindi, per esempio, hai un enum

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

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

Sono contrario a nominarlo:

FruitEnum
NetworkConnectionTypeEnum

Capisco che è facile scegliere quali file sono enum, ma poi avresti anche:

NetworkConnectionClass
FruitClass

Inoltre, esiste un buon documento che descrive lo stesso per le costanti, dove dichiararle, ecc.?

Gli enum sono classi e dovrebbero seguire le convenzioni per le classi. Le istanze di un enum sono costanti e dovrebbero seguire le convenzioni per le costanti. Così

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

Non c'è motivo per scrivere FruitEnum non più di FruitClass. Stai solo sprecando quattro (o cinque) personaggi che non aggiungono informazioni.

Java stesso raccomanda questo approccio ed è usato nei loro esempi .

Questo probabilmente non mi farà molti nuovi amici, ma va aggiunto che le persone C # hanno una linea guida diversa: le istanze enum sono "maiuscole" (maiuscole / minuscole miste). Vedere la discussione StackOverflow e MSDN Enumeration Type Naming Guidelines .

Mentre stiamo scambiando dati con un sistema C #, sono tentato di copiare esattamente i loro enum, ignorando la convenzione "le costanti hanno nomi maiuscoli". Pensandoci, non vedo molto valore nell'essere limitato alle maiuscole per le istanze enum. Per alcuni scopi .name () è una pratica scorciatoia per ottenere una rappresentazione leggibile di una costante enum e un nome di caso misto sembrerebbe più bello.

Quindi, sì, oso mettere in discussione il valore della convenzione di denominazione enum Java. Il fatto che "l'altra metà del mondo della programmazione" usi davvero uno stile diverso mi fa pensare che sia legittimo dubitare della nostra religione.

Come già detto, le istanze di enum devono essere maiuscole in base ai documenti sul sito Web Oracle ( http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html ).

Tuttavia, mentre guardavo un tutorial JavaEE7 sul sito Web Oracle ( http://www.oracle.com/technetwork/java/javaee/downloads/index.html ), mi sono imbattuto nel tutorial "Duke's bookstore" e in una classe ( tutorial\examples\case-studies\dukes-bookstore\src\main\java\javaeetutorial\dukesbookstore\components\AreaComponent.java), Ho trovato la seguente definizione enum:

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

Secondo le convenzioni, avrebbe dovuto apparire come:

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

Quindi sembra che persino i ragazzi di Oracle a volte negoziano convenzioni con comodità.

Nel nostro codebase; in genere dichiariamo enum nella classe a cui appartengono.

Quindi, per il tuo esempio di frutta, avremmo una lezione di frutta e al suo interno un Enum chiamato frutta.

Fare riferimento nel codice è simile al seguente: Fruit.Fruits.Apple, Fruit.Fruits.Pear ecc.

Le costanti seguono la stessa linea, dove vengono definite nella classe in cui sono rilevanti (quindi qualcosa del genere Fruit.ORANGE_BUSHEL_SIZE ); o se applicano a livello di sistema (cioè un "valore nullo" equivalente per gli inte) in una classe denominata "ConstantManager" (o equivalente; comeConstantManager.NULL_INT ) (nota a margine; tutte le nostre costanti sono in maiuscolo)

Come sempre, i tuoi standard di codifica probabilmente differiscono dai miei; quindi YMMV.

Sono ancora tipi, quindi uso sempre le stesse convenzioni di denominazione che uso per le lezioni.

Deciderei di mettere "Class" o "Enum" in un nome. Se hai sia a FruitClassche a FruitEnumallora qualcos'altro è sbagliato e hai bisogno di nomi più descrittivi. Sto cercando di pensare al tipo di codice che porterebbe alla necessità di entrambi, e sembra che ci dovrebbe essere unFruit classe base con sottotipi invece di un enum. (Questa è solo la mia speculazione però, potresti avere una situazione diversa da quella che sto immaginando.)

Il miglior riferimento che posso trovare per la denominazione delle costanti viene dal tutorial Variabili :

Se il nome che scegli è composto da una sola parola, scrivi quella parola in tutte le lettere minuscole. Se è composto da più di una parola, scrivere in maiuscolo la prima lettera di ogni parola successiva. I nomi gearRatio e currentGear sono esempi primi di questa convenzione. Se la variabile memorizza un valore costante, come int finale statico NUM_GEARS = 6, la convenzione cambia leggermente, capitalizzando ogni lettera e separando le parole successive con il carattere di sottolineatura. Per convenzione, il carattere di sottolineatura non viene mai utilizzato altrove.

Se posso aggiungere $ 0,02, preferisco usare PascalCase come valori enum in C.

In C, sono sostanzialmente globali e PEER_CONNECTED diventa davvero stancante rispetto a PeerConnected.

Respiro d'aria fresca.

Letteralmente, mi fa respirare più facilmente.

In Java, è possibile utilizzare nomi di enum non elaborati purché vengano importati staticamente da un'altra classe.

import static pkg.EnumClass.*;

Ora puoi usare i nomi non qualificati che hai già qualificato in un altro modo.

Attualmente (sto pensando) al porting del codice C su Java e attualmente "diviso" tra la scelta della convenzione Java (che è più dettagliata, più lunga e più brutta) e il mio stile C.

PeerConnected diventerebbe PeerState.CONNECTED tranne che nelle istruzioni switch, dove è CONNECTED.

Ora c'è molto da dire per quest'ultima convenzione e sembra carino ma certe "frasi idiomatiche" come if (s == PeerAvailable)diventare simili if (s == PeerState.AVAILABLE)e nostalgicamente, questa è una perdita di significato per me.

Penso di preferire ancora lo stile Java per chiarezza, ma faccio fatica a guardare il codice urlante.

Ora mi rendo conto che PascalCase è già ampiamente utilizzato in Java, ma molto confuso non sarebbe davvero, solo un po 'fuori posto.

enum MyEnum {VALUE_1,VALUE_2}

è (approssimativamente) come dire

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

quindi immagino che tutto in maiuscolo sia strettamente più corretto, ma utilizzo comunque la convenzione sui nomi di classe poiché odio tutti i maiuscoli ovunque