Menu

Java Enum: Tutorial sull'enumerazione Java con esempi

java enum java enumeration tutorial with examples

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial elaborerà la classe e il costruttore Java Enum. Impareremo come utilizzare Enum attraverso vari esempi di programmazione Java:

Questa è una classe speciale la cui spiegazione verrà fornita in dettaglio. Verrà fornita una panoramica della classe Java Enum insieme all'elenco dei metodi che supporta.

Programmi sufficienti che implementano i concetti enum di Java e alcune domande frequenti che potrebbero essere poste durante le interviste sono inclusi in questo tutorial per una facile comprensione.

=> Controlla qui per vedere la serie di formazione Java per tutti.

Java Enum

Cosa imparerai:

Enumerazione Java

Un'enumerazione Java non è altro che un elenco di variabili di istanza, metodi o costruttori. Questi sono un gruppo di costanti. Il concetto di enumerazione è stato introdotto in JDK5. La proprietà predefinita di ogni costante di enumerazione è public, static e final.

parola chiave enum

L'enumerazione viene creata utilizzando una parola chiave chiamata ' enum '.

Di seguito è riportata la sintassi con la quale possiamo creare un'enumerazione.

Sintassi:

enum enumerated_type_name
{
enumerator1, enumerator2,… enumeratorN;

}

Nota: enum può essere definito solo all'interno di una classe o interfaccia di primo livello o in un contesto statico. Non dovrebbe essere all'interno di un metodo.

enum Esempio

In questo esempio, inizializzeremo quattro enumeratori, ovvero picche, cuori, quadri e fiori appartenenti a un tipo enumerato chiamato carte.

Quindi, proveremo a stampare ciascuno di questi enumeratori.

/* * created an enumeration called cards * with four enumerators. */ enum cards { spade, club, heart, diamond; } public class A { public static void main(String() args) { /* * stored each of the enumerators in the * reference variables a1,a2,a3,a4 respectively. * note that the new keyword was not used here */ cards a1 = cards.spade; cards a2 = cards.club; cards a3 = cards.heart; cards a4 = cards.diamond; System.out.println('Enumerators are: '+ a1 + ',' + a2 + ',' + a3 + ',' + a4); } }

Produzione:

esempio di parola chiave enum

Classe Enum

Una cosa che devi aver notato nell'esempio sopra (vedi commenti) è che non abbiamo usato un file 'Nuova parola chiave' durante l'istanza. Sebbene le enumerazioni definiscano una classe Enum e anche i costruttori, non usano una nuova parola chiave.

Possiamo usare gli enumeratori definiti allo stesso modo della primitiva. Enum è una classe generica e tutte le enumerazioni ereditano Enum.

Sintassi:

// E è il tipo di enumerazione.

class Enum

Come utilizzare Enum in Java

Vediamo come utilizzare Enum in vari scenari con l'aiuto di esempi Java:

All'interno di una classe

Enum può essere dichiarato all'interno o all'esterno (esempio di parola chiave enum) una classe ma non all'interno di un metodo. Qui, dimostreremo come enum viene dichiarato all'interno di una classe.

Nell'esempio seguente , abbiamo creato un'enumerazione all'interno di una classe e quindi abbiamo recuperato il valore o l'enumeratore con l'aiuto di una variabile di riferimento a1.

public class A { /* * created an enumeration called cards * with four enumerators. */ enum cards { spade, club, heart, diamond; } public static void main(String() args) { /* * stored each of the enumerators in the * reference variables a1. * note that the new keyword was not used here */ cards a1 = cards.heart; System.out.println('Card is: '+ a1); } }

Produzione:

Enum all

Iterazione di Enum attraverso cicli

Qui, discuteremo come possiamo eseguire il ciclo attraverso un enum. Abbiamo dichiarato l'enumerazione con quattro enumeratori (al di fuori di una classe). Quindi abbiamo inizializzato un ciclo per ogni (all'interno di una classe) e abbiamo cercato di recuperare il valore degli enumeratori.

/* * created an enumeration called games * with four enumerators. */ enum games { ludo, Chess, Badminton, Cricket; } public class A { public static void main(String() args) { /* * used forEach loop and stored the value in 'index' * and printed the value of each enumerator */ System.out.println('Using for each loop'); for (games index:games.values()) { System.out.println(index); } } }

Produzione:

Iterazione di cicli

come aprire i file bin su pc

In caso contrario

Nel programma seguente, abbiamo creato un'enumerazione con tre diversi enumeratori e quindi memorizzato l'enumeratore nella variabile di riferimento per uno degli enumeratori specificati.

Quindi abbiamo avviato il controllo della condizione if in cui abbiamo implementato due condizioni specificate con OR in modo che se una di queste condizioni viene soddisfatta, verrà stampata l'istruzione specificata nella condizione if.

Altrimenti, stamperà l'istruzione specificata nella condizione else.

/* * created an enumeration called players * with three enumerators. */ enum players { sachin, virat, dhoni; } public class A { public static void main(String() args) { /* * stored enumerator in reference variable a1 for * contant dhoni */ players a1 = players.dhoni; /* * Started if statement with OR condition. * If any of these conditions are met then it will * print the statement specified inside if statement */ if(a1 == players.virat || a1 == players.sachin) { System.out.println('Sachin and Virat are greatest batsmen'); } /* * if none of the above condition is met then it will * print the below specified statement */ else { System.out.println('Dhoni is the best Captain'); } } }

Produzione:

output if-else

In Switch Statement

Nel programma seguente, abbiamo creato un'enumerazione con quattro enumeratori. Quindi, abbiamo memorizzato uno degli enumeratori nella variabile di riferimento. Successivamente, abbiamo inizializzato un'istruzione Switch e controllato ciascuno di questi enumeratori.

Al verificarsi di quel particolare enumeratore, stamperà l'istruzione specificata nel caso particolare.

/* * created an enumeration called players * with four enumerators. */ enum players { sachin, dravid, virat, dhoni; } public class A { public static void main(String() args) { /* * stored enumerator in reference variable a1 for * contant dravid */ players a1 = players.dravid; /* * Started Switch Statement and if the element * matches with a1 then it will print the statement * specified in the case */ switch(a1) { // does not match case sachin: System.out.println('Sachin is best bastman ever'); break; // matches case dravid: System.out.println('Dravid is the best Test Batsman'); break; // does not match case virat: System.out.println('Virat is modern great'); break; // does not match case dhoni: System.out.println('Dhoni is the best captain ever'); break; } } }

Produzione:

Enumerazione nell

Campi e metodi di enumerazione

Enum Field

Questa sezione spiegherà in dettaglio il campo enum. Possiamo aggiungere campi all'enumerazione Java e ogni enumeratore ottiene questi campi. Il valore del campo deve essere assegnato al costruttore dell'enumerazione.

Nella sintassi seguente, possiamo vedere che un'enumerazione è stata definita con tre enumeratori. Accanto a ogni enumeratore, abbiamo definito un campo di tipo int. ( Per esempio. - (3), (2) e (1) rispettivamente).

Questo somma che Java enum ha un costruttore che accetta un int. Questo costruttore imposta il campo int. Quando viene definito un enumeratore, il valore int (specificato per quell'enumeratore) viene passato al costruttore.

Sintassi:

public enum A { /* * calls a contructor with value * defined on the respective enumerator */ Enumerator1(3), Enumerator2(2), Enumerator3(1) /* * semicolon needed for the last enumerator * if there is a method following it. */ ; private final int constant; private A(int constant) { this.constant = constant; } }

Nota: Ad esempio sul campo Enum, fare riferimento alla sezione ' Costruttore Enum '.

Metodi Enum

# 1) nome ()

public final String name () - Restituisce il nome della costante di richiamo (invariato o inalterato).

# 2) è uguale a ()

public final boolean equals (Object other) - Restituisce true se obj e l'oggetto invocante si riferiscono alla stessa costante.

# 3) toString

public String toString () - Restituisce il nome della costante di richiamo. Non corrisponde necessariamente al nome utilizzato nella dichiarazione dell'enumerazione.

# 4) clone

Protetto oggetto finale clone ()
genera CloneNotSupportedException - Ciò significa che l'enumerazione genererà un'eccezione quando si tenta di clonare.

# 5) hashCode ()

public final int hashCode () - Restituisce il codice hash per l'oggetto invocante.

# 6) finalizza ()

protected final void finalize (): la classe enum non può avere metodi finalizzati. Nessun valore restituito.

# 7) compareTo ()

public final int compareTo (E obj): confronta l'enumerazione con l'oggetto specificato obj. Restituisce negativo se l'oggetto è minore dell'oggetto specificato. Restituisce positivo se questo oggetto è maggiore dell'oggetto specificato obj e restituisce zero se l'oggetto specificato è uguale a questo oggetto.

# 8) getDeclaringClass

public final Class getDeclaringClass () - Restituisce il tipo di enumerazione (noto anche come classe dichiarante enum) di cui la costante di richiamo è un membro.

# 9) ordinal (), values ​​() e valueOf ()

Tutti questi metodi fanno parte del pacchetto java.lang.Enum . Il metodo ordinal () restituisce l'ordine della costante di enumerazione in base all'indice della costante.

Il metodo values ​​() restituisce tutti i valori presenti nell'enumerazione. Il metodo valueOf (String) restituisce la costante di enumerazione della stringa di input. Se la stringa specificata non corrisponde alla costante, verrà generata un'eccezione IllegalArgumentException.

Di seguito è riportato l'esempio di programmazione in cui abbiamo utilizzato lo stesso esempio (come esempio di parola chiave enum) e implementato il concetto di tutti e tre i metodi.

/* * created an enumeration called cards * with four enumerators. */ enum cards { spade, club, heart, diamond; } public class A { public static void main(String() args) { /* * created an array arr() which will store the * value of the constants/enumerators declared in the enumeration */ cards arr() = cards.values(); /* * used forEach loop and stored the value in 'type' * and printed the value as well as index with the help of * ordinal() method */ for (cards type:arr) { System.out.println(type + ' occurs at ' + type.ordinal()); } /* * passed heart as an input String which matches with the * constant declared in 'cards' */ System.out.println(cards.valueOf('heart')); } }

Produzione:

ordinal (), values ​​() e valueOf ()

Costruttore Enum

Enum (poiché è anche una classe) supporta il costruttore per passare i dati durante la creazione di enumeratori o noto anche come costanti enum.

La proprietà principale di un costruttore enum è che sono private o private-package. Ciò significa che sono accessibili all'interno di una classe o all'interno di un pacchetto.

Vediamo l'esempio seguente. Qui abbiamo utilizzato sia il metodo che il costruttore. Prima di tutto, abbiamo creato un'enumerazione denominata 'giocatori' che ha cinque enumeratori e il campo.

Quindi, abbiamo un costruttore e un metodo che restituirà il numero di run segnati da ogni giocatore o enumeratore o costante enum.

Successivamente, abbiamo la classe principale in cui abbiamo utilizzato per ogni ciclo con il metodo values ​​() per memorizzare e iterare ogni enumeratore. Inoltre, abbiamo chiamato il metodo per il numero di punti segnati da ogni giocatore.

/* * Created enumeration players with the field. * Declared a constructor and a method to return * the number of runs scored by the players. */ enum players { dravid(10889), sachin(18426), ganguly(11363), virat(11867), dhoni(10773) ; private int runs; /* * Created enumeration players with the field. * Declared a constructor and a method to return * the number of runs scored by the players. */ enum players { dravid(10889), sachin(18426), ganguly(11363), virat(11867), dhoni(10773) ; private int runs; players(int r) { runs = r; } int getRuns() { return runs; } } /* * Used values() method to get the enumerators and a for each loop * to get the number of runs scored by each player */ public class A { public static void main(String args()) { for (players a : players.values()) System.out.println(a + ' has scored ' + a.getRuns() + ' ODI runs'); } }

Produzione:

Output del costruttore

Domande frequenti

D # 1) Qual è la differenza tra Iterator ed Enumeration in Java?

Risposta: Di seguito è riportata la differenza tra Iterator ed Enumeration.

IteratoreEnumerazione
È un cursore generico che viene utilizzato per iterare elementi ed è applicabile a tutta la classe di raccolta.Non è un cursore generico perché è applicabile solo a classi legacy come Enum. Solo autorizzazione di lettura per una classe di raccolta.
Alcuni dei metodi sono hasNext (), next () per l'iterazione.Alcuni dei metodi sono hasMoreElements (), nextElement () per l'iterazione.
Possiamo rimuovere l'elemento in una raccolta usando l'iteratore.Non è possibile rimuovere l'elemento in una raccolta utilizzando Enumeration perché dispone solo dell'autorizzazione di lettura.

D # 2) In che modo Enum supporta l'ereditarietà?

Risposta: Afterall Enum è anche una classe in Java, quindi deve supportare l'ereditarietà che è un principio di base di OOPS. Tutte le enumerazioni estendono la classe java.lang.Enum. Poiché una classe può estendere solo un singolo genitore, la classe Enum non ne estende nessun'altra.

Il toString () che fa parte della classe Enum (spiegato nella sezione Metodo Enum) è sovrascritto nella classe java.lang.Enum.

Conclusione

In questo tutorial, abbiamo discusso le enumerazioni, gli enumeratori, la classe Java Enum e la parola chiave enum con esempi e spiegazioni appropriati ove richiesto. Inoltre, abbiamo fornito una panoramica dei metodi importanti associati alla classe Enum con campo enum.

Sono state fornite informazioni sul costruttore, enum con if-else, switch e loop.

=> Visita qui per imparare Java da zero.

Lettura consigliata

^