Qual è l’uso di “enum” in Java?

Così ho esaminato questo tipo di “enum”, e mi sembra un array / ArrayList / List glorificato. Qual è esattamente l’uso di esso?

Enum serve come un tipo di numero fisso di costanti e può essere utilizzato almeno per due cose

costante

 public enum Month { JANUARY, FEBRUARY, ... } 

Questo è molto meglio che creare un gruppo di costanti intere.

creando un singleton

 public enum Singleton { INSTANCE // init }; 

Puoi fare cose molto interessanti con le enumerazioni, guarda qui

Guarda anche la documentazione ufficiale

Si utilizza un enum invece di una class se la class deve avere un numero enumerabile fisso di istanze.

Esempi:

  • DayOfWeek = 7 istanze → enum
  • CardSuit = 4 istanze → enum
  • Singleton = 1 istanza → enum
  • Product = numero variabile di istanze → class
  • User = numero variabile di istanze → class
  • Date = numero variabile di istanze → class

Un tipo enumerato è fondamentalmente un tipo di dati che consente di descrivere ciascun membro di un tipo in un modo più leggibile e affidabile.

Ecco un semplice esempio per spiegare perché:

Supponendo che tu stia scrivendo un metodo che ha qualcosa a che fare con le stagioni:

Il modello int enum

Innanzitutto, hai dichiarato alcune costanti statiche int per rappresentare ogni stagione.

 public static final int SPRING = 0; public static final int SUMMER = 1; public static final int FALL = 2; public static final int WINTER = 2; 

Quindi, hai dichiarato un metodo per stampare il nome della stagione nella console.

 public void printSeason(int seasonCode) { String name = ""; if (seasonCode == SPRING) { name = "Spring"; } else if (seasonCode == SUMMER) { name = "Summer"; } else if (seasonCode == FALL) { name = "Fall"; } else if (seasonCode == WINTER) { name = "Winter"; } System.out.println("It is " + name + " now!"); } 

Quindi, dopo, puoi stampare un nome di stagione come questo.

 printSeason(SPRING); printSeason(WINTER); 

Questo è un modo abbastanza comune (ma cattivo) di fare cose diverse per diversi tipi di membri in una class. Tuttavia, poiché questi codici coinvolgono numeri interi, puoi anche chiamare il metodo in questo modo senza problemi.

 printSeason(0); printSeason(1); 

o anche così

 printSeason(x - y); printSeason(10000); 

Il compilatore non si lamenterà perché queste chiamate al metodo sono valide e il metodo printSeason può ancora funzionare.

Ma qualcosa non è giusto qui. Cosa vuol dire un codice stagionale di 10000 ? Cosa succede se x - y risulta in un numero negativo? Quando il tuo metodo riceve un input che non ha significato e non dovrebbe essere lì, il tuo programma non ne sa nulla.

È ansible risolvere questo problema, ad esempio aggiungendo un ulteriore controllo.

 ... else if (seasonCode == WINTER) { name = "Winter"; } else { throw new IllegalArgumentException(); } System.out.println(name); 

Ora il programma genererà una RunTimeException quando il codice di stagione non è valido. Tuttavia, è ancora necessario decidere come gestire l’eccezione.

A proposito, sono sicuro che hai notato che il codice di FALL e WINTER sono entrambi 2, giusto?

Dovresti avere l’idea ora. Questo modello è fragile. Ti fa scrivere controlli di condizione ovunque. Se stai facendo un gioco e vuoi aggiungere una stagione extra al tuo mondo immaginario, questo schema ti farà andare avanti con tutti i metodi che fanno le cose per stagione, e nella maggior parte dei casi ne dimenticherai alcuni.

Potresti pensare che l’ereditarietà della class sia una buona idea per questo caso. Ma abbiamo solo bisogno di alcuni di loro e non di più.

Questo è quando enum entra in gioco.


Usa il tipo di enum

In Java, i tipi enum sono classi che esportano un’istanza per ciascuna costante di enumerazione tramite un campo finale statico pubblico.

Qui puoi dichiarare quattro costanti di enumerazione: SPRING, SUMMER, FALL, WINTER . Ognuno ha il suo name .

 public enum Season { SPRING("Spring"), SUMMER("Summer"), FALL("Fall"), WINTER("Winter"); private String name; Season(String name) { this.name = name; } public String getName() { return name; } } 

Ora, torniamo al metodo.

 public void printSeason(Season season) { System.out.println("It is " + season.getName() + " now!"); } 

Invece di usare int , ora puoi usare Season come input. Invece di un controllo delle condizioni, puoi dire a Season per darti il ​​suo nome.

Ecco come usi questo metodo ora:

 printSeason(Season.SPRING); printSeason(Season.WINTER); printSeason(Season.WHATEVER); <-- compile error 

Si otterrà un errore in fase di compilazione quando si utilizza un input non corretto, e si è certi di ottenere un riferimento singleton non nullo di Season fintanto che il programma viene compilato.

Quando abbiamo bisogno di una stagione aggiuntiva, aggiungiamo semplicemente un'altra costante in Season e non di più.

 public enum Season { SPRING("Spring"), SUMMER("Summer"), FALL("Fall"), WINTER("Winter"), MYSEASON("My Season"); ... 

Ogni volta che hai bisogno di un insieme fisso di costanti, enum può essere una buona scelta (ma non sempre). È una soluzione più leggibile, più affidabile e più potente.

Un tipo enum è un tipo i cui campi consistono in un insieme fisso di costanti. Esempi comuni includono le direzioni della bussola (valori di NORD, SUD, EST e OVEST) e i giorni della settimana.

 public enum Day { SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY } 

È necessario utilizzare i tipi enum ogni volta che è necessario rappresentare un insieme fisso di costanti. Ciò include tipi di enum naturali come i pianeti nel nostro sistema solare e insiemi di dati in cui si conoscono tutti i valori possibili al momento della compilazione, ad esempio le scelte in un menu, i flag della riga di comando e così via.

Ecco un codice che mostra come utilizzare l’enumerazione del giorno sopra definita:

 public class EnumTest { Day day; public EnumTest(Day day) { this.day = day; } public void tellItLikeItIs() { switch (day) { case MONDAY: System.out.println("Mondays are bad."); break; case FRIDAY: System.out.println("Fridays are better."); break; case SATURDAY: case SUNDAY: System.out.println("Weekends are best."); break; default: System.out.println("Midweek days are so-so."); break; } } public static void main(String[] args) { EnumTest firstDay = new EnumTest(Day.MONDAY); firstDay.tellItLikeItIs(); EnumTest thirdDay = new EnumTest(Day.WEDNESDAY); thirdDay.tellItLikeItIs(); EnumTest fifthDay = new EnumTest(Day.FRIDAY); fifthDay.tellItLikeItIs(); EnumTest sixthDay = new EnumTest(Day.SATURDAY); sixthDay.tellItLikeItIs(); EnumTest seventhDay = new EnumTest(Day.SUNDAY); seventhDay.tellItLikeItIs(); } } 

L’output è:

I lunedì sono cattivi
I giorni infrasettimanali sono così così.
Il venerdì è meglio
I fine settimana sono i migliori
I fine settimana sono i migliori

I tipi di enumerazione del linguaggio di programmazione Java sono molto più potenti delle loro controparti in altre lingue. La dichiarazione enum definisce una class (chiamata tipo enum). Il corpo della class enum può includere metodi e altri campi. Il compilatore aggiunge automaticamente alcuni metodi speciali quando crea un enum. Ad esempio, hanno un metodo di valori statici che restituisce una matrice contenente tutti i valori dell’enumerazione nell’ordine in cui sono dichiarati. Questo metodo è comunemente usato in combinazione con il costrutto for-each per iterare sui valori di un tipo enum. Ad esempio, questo codice dall’esempio di class Planet sotto itera su tutti i pianeti del sistema solare.

 for (Planet p : Planet.values()) { System.out.printf("Your weight on %s is %f%n", p, p.surfaceWeight(mass)); } 

Oltre alle sue proprietà e costruttore, Planet ha metodi che ti permettono di recuperare la gravità e il peso superficiale di un object su ciascun pianeta. Ecco un esempio di programma che prende il tuo peso sulla terra (in qualsiasi unità) e calcola e stampa il tuo peso su tutti i pianeti (nella stessa unità):

 public enum Planet { MERCURY (3.303e+23, 2.4397e6), VENUS (4.869e+24, 6.0518e6), EARTH (5.976e+24, 6.37814e6), MARS (6.421e+23, 3.3972e6), JUPITER (1.9e+27, 7.1492e7), SATURN (5.688e+26, 6.0268e7), URANUS (8.686e+25, 2.5559e7), NEPTUNE (1.024e+26, 2.4746e7); private final double mass; // in kilograms private final double radius; // in meters Planet(double mass, double radius) { this.mass = mass; this.radius = radius; } private double mass() { return mass; } private double radius() { return radius; } // universal gravitational constant (m3 kg-1 s-2) public static final double G = 6.67300E-11; double surfaceGravity() { return G * mass / (radius * radius); } double surfaceWeight(double otherMass) { return otherMass * surfaceGravity(); } public static void main(String[] args) { if (args.length != 1) { System.err.println("Usage: java Planet "); System.exit(-1); } double earthWeight = Double.parseDouble(args[0]); double mass = earthWeight/EARTH.surfaceGravity(); for (Planet p : Planet.values()) System.out.printf("Your weight on %s is %f%n", p, p.surfaceWeight(mass)); } } 

Se esegui Planet.class dalla riga di comando con un argomento di 175, ottieni questo risultato:

$ java Planet 175
Il tuo peso su MERCURY è 66.107583
Il tuo peso su VENUS è 158.374842
Il tuo peso su TERRA è 175,000000
Il tuo peso su MARS è 66.279007
Il tuo peso su JUPITER è 442.847567
Il tuo peso su SATURN è 186,552719
Il tuo peso su URANUS è 158.397260
Il tuo peso su NEPTUNE è 199.207413

Fonte: http://docs.oracle.com/javase/tutorial/java/javaOO/enum.html

un Enum è un tipo sicuro, quindi non è ansible assegnare un nuovo valore al runtime. Inoltre puoi usarlo in una dichiarazione switch (come un int).

Le enumerazioni sono il metodo consigliato per fornire nomi facili da ricordare per un insieme definito di contant (opzionalmente anche con un comportamento limitato).

Dovresti usare le enumerazioni dove altrimenti useresti più costanti di interi statici (ad esempio public static int ROLE_ADMIN = 0 o BLOOD_TYPE_AB = 2 )

I principali vantaggi dell’utilizzo di enumerazioni al posto di questi sono la sicurezza del tipo, la compilazione di avvertimenti / errori nel tentativo di utilizzare valori errati e la fornitura di uno spazio dei nomi per le relative “costanti”. Inoltre sono più facili da usare all’interno di un IDE poiché aiuta anche il completamento del codice.

Le enums linguaggio di programmazione Java sono molto più potenti delle loro controparti in altre lingue, che sono poco più di interi glorificati. La nuova dichiarazione enum definisce una class a tutti gli effetti (doppiato un tipo enum). Oltre a risolvere tutti i problemi ( Not typesafe, No namespace, Brittleness and Printed values are uninformative ) che esiste con il seguente modello Enum int che è stato utilizzato prima di java 5.0:

public static final int SEASON_WINTER = 0;

consente inoltre di aggiungere metodi e campi arbitrari a un tipo di enum, di implementare interfacce arbitrarie e altro ancora. I tipi Enum forniscono implementazioni di alta qualità di tutti i metodi Object. Sono Comparable e Serializable e la forma seriale è progettata per resistere a cambiamenti arbitrari nel tipo enum. Puoi anche usare Enum nel caso di switch .

Leggi l’articolo completo su Java Enum http://docs.oracle.com/javase/1.5.0/docs/guide/language/enums.html per maggiori dettagli.

1) enum è una parola chiave in metodo Object oriented.

2) È usato per scrivere il codice in una riga singola, che non è più di questo.

  public class NAME { public static final String THUNNE = ""; public static final String SHAATA = ""; public static final String THULLU = ""; } -------This can be replaced by-------- enum NAME{THUNNE, SHAATA, THULLU} 

3) La maggior parte degli sviluppatori non usa la parola chiave enum, è solo un metodo alternativo ..