Guide du débutant sur Java eNum – Pourquoi et pour quoi dois-je utiliser Enum ? Exemples d'énumération Java

Publié: 2019-04-23

Guide du débutant sur Java eNum - Crunchify Tips

Les énumérations sont des listes de constants comme des variables non modifiables. Avez-vous entendu parler du mot- Final keyword ? C'est comme ça.

Lorsque vous avez besoin d'une liste prédéfinie de valeurs qui représentent une sorte de données numériques ou textuelles, vous devez utiliser une énumération. Par exemple, dans une partie d'échecs, vous pourriez représenter les différents types de pièces sous la forme d'une énumération :

1
2
3
4
5
6
7
8
enum ChessPiece {
PAWN ,
ROOK ,
KNIGHT ,
BISHOP ,
QUEEN ,
KING ;
}

Vous devez toujours utiliser des énumérations lorsqu'une variable (en particulier un paramètre de méthode) ne peut en prendre qu'une parmi un petit ensemble de valeurs possibles. Des exemples seraient des choses comme des constantes de type (statut du contrat : "permanent", "intérimaire", "apprenti") ou des drapeaux ("exécuter maintenant", "différer l'exécution").

Si vous utilisez des énumérations au lieu d'entiers (ou de codes de chaîne), vous augmentez la vérification au moment de la compilation et évitez les erreurs de transmission de constantes non valides, et vous documentez les valeurs qu'il est légal d'utiliser.

guide-du-debutant-pour-java-enum-pourquoi-et-pour-quoi-dois-je-utiliser-enum

Exemple Java :

CrunchifyEnumExample.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package com . crunchify . tutorials ;
 
/**
* @author Crunchify.com
*/
 
public class CrunchifyEnumExample {
 
     public enum Company {
         EBAY , PAYPAL , GOOGLE , YAHOO , ATT
     }
 
     Company cName ;
 
     public CrunchifyEnumExample ( Company cName ) {
         this . cName = cName ;
     }
 
     public void companyDetails ( ) {
         switch ( cName ) {
             case EBAY :
                 System . out . println ( "EBAY: Biggest Market Place in the World." ) ;
                 break ;
 
             case PAYPAL :
                 System . out . println ( "PAYPAL: Simplest way to manage Money." ) ;
                 break ;
 
             case GOOGLE :
             case YAHOO :
                 System . out . println ( "YAHOO: 1st Web 2.0 Company." ) ;
                 break ;
 
             default :
                 System . out . println ( "DEFAULT: Google - biggest search giant.. ATT - my carrier provider.." ) ;
                 break ;
         }
     }
 
     public static void main ( String [ ] args ) {
         CrunchifyEnumExample ebay = new CrunchifyEnumExample ( Company . EBAY ) ;
         ebay . companyDetails ( ) ;
         CrunchifyEnumExample paypal = new CrunchifyEnumExample ( Company . PAYPAL ) ;
         paypal . companyDetails ( ) ;
         CrunchifyEnumExample google = new CrunchifyEnumExample ( Company . GOOGLE ) ;
         google . companyDetails ( ) ;
         CrunchifyEnumExample yahoo = new CrunchifyEnumExample ( Company . YAHOO ) ;
         yahoo . companyDetails ( ) ;
         CrunchifyEnumExample att = new CrunchifyEnumExample ( Company . ATT ) ;
         att . companyDetails ( ) ;
     }
}

Sortir:

Java
1
2
3
4
5
6
7
EBAY : Biggest Market Place in the World .
PAYPAL : Simplest way to manage Money .
YAHOO : 1st Web 2.0 Company .
YAHOO : 1st Web 2.0 Company .
DEFAULT : Google - biggest search giant . . ATT - my carrier provider . .
 
Process finished with exit code 0

Quelques points très importants sur Java Enum :

Point-1

Toutes les énumérations étendent implicitement java.lang.Enum . Étant donné que Java ne prend pas en charge l'héritage multiple, une énumération ne peut rien étendre d'autre.

Point-2

Enum in Java are type-safe: Enum a son propre espace de noms. Cela signifie que votre énumération aura un type par exemple "Société" dans l'exemple ci-dessous et vous ne pouvez pas attribuer de valeur autre que celle spécifiée dans Enum Constants.

Java
1
2
3
4
5
6
public enum Company {
EBAY , PAYPAL , GOOGLE , YAHOO , ATT
}
 
Company cName = Company . EBAY ;
cName = 1 ;    // Compilation Error

Point-3

Vous pouvez spécifier des valeurs de constantes enum au moment de la création. MyEnum.values() renvoie un tableau des valeurs de MyEnum.

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com . crunchify . tutorial ;
 
/**
* @author Crunchify.com
*/
 
public class CrunchifyEnumExample {
 
public enum Company {
EBAY ( 30 ) , PAYPAL ( 10 ) , GOOGLE ( 15 ) , YAHOO ( 20 ) , ATT ( 25 ) ;
private int value ;
 
private Company ( int value ) {
this . value = value ;
}
}
 
public static void main ( String [ ] args ) {
for ( Company cName : Company . values ( ) ) {
System . out . println ( "Company Value: " + cName . value + " - Company Name: " + cName ) ;
}
}
}

Sortir:

1
2
3
4
5
Company Value : 30 - Company Name : EBAY
Company Value : 10 - Company Name : PAYPAL
Company Value : 15 - Company Name : GOOGLE
Company Value : 20 - Company Name : YAHOO
Company Value : 25 - Company Name : ATT

Point-4

Les constantes Enum sont implicitement statiques et finales et ne peuvent pas être modifiées une fois créées.

Point-5

Enum peut être comparé en toute sécurité en utilisant :

  1. Déclaration de commutation de casse
  2. == Opérateur
  3. Méthode .equals () Veuillez suivre le didacticiel complet.
Java
1
2
3
4
Company eBay = Company . EBAY ;
if ( eBay == Company . EBAY ) {
   log . info ( "enum in java can be compared using ==" ) ;
}

Point-6

Vous ne pouvez pas créer d'instance d'énumérations à l'aide de l'opérateur new en Java car le constructeur d'Enum en Java ne peut être que privé et les constantes Enums ne peuvent être créées qu'à l'intérieur d'Enums lui-même.

Point-7

Une instance d'Enum en Java est créée lorsque des constantes Enum sont d'abord appelées ou référencées dans le code.

Point-8

Une énumération spécifie une liste de valeurs constantes affectées à un type.

Point-9

Une énumération peut être déclarée à l'extérieur ou à l'intérieur d'une classe, mais PAS dans une méthode.

Point-10

Une énumération déclarée en dehors d'une classe ne doit PAS être marquée static, final , abstract, protected ou private

Point-11

Les énumérations peuvent contenir des constructeurs, des méthodes, des variables et des corps de classe constants.

Point-12

Les constantes enum peuvent envoyer des arguments au constructeur enum, en utilisant la syntaxe BIG(8), où le littéral int 8 est passé au constructeur enum.

Point-13

Les constructeurs enum peuvent avoir des arguments et peuvent être surchargés.

Point-14

Les constructeurs enum ne peuvent JAMAIS être invoqués directement dans le code. Ils sont toujours appelés automatiquement lorsqu'une énumération est initialisée.

Point-15

Le point-virgule à la fin d'une déclaration enum est facultatif.

Ceux-ci sont légaux :

  • enum Foo { UN, DEUX, TROIS}
  • enum Foo { UN, DEUX, TROIS} ;

Un autre exemple Java eNUM simple :

enum_data_type - Crunchifier

Les énumérations sont des listes de constantes. Lorsque vous avez besoin d'une liste prédéfinie de valeurs qui représentent une sorte de données numériques ou textuelles, vous devez utiliser une énumération.

Vous devez toujours utiliser des énumérations lorsqu'une variable (en particulier un paramètre de méthode) ne peut en prendre qu'une parmi un petit ensemble de valeurs possibles. Des exemples seraient des choses comme des constantes de type (statut du contrat : "permanent", "intérimaire", "apprenti") ou des drapeaux ("exécuter maintenant", "différer l'exécution").

Si vous utilisez des énumérations au lieu d'entiers (ou de codes de chaîne), vous augmentez la vérification au moment de la compilation et évitez les erreurs de transmission de constantes non valides, et vous documentez les valeurs qu'il est légal d'utiliser.

Entre les deux, une surutilisation des énumérations peut signifier que vos méthodes en font trop (il est souvent préférable d'avoir plusieurs méthodes distinctes, plutôt qu'une méthode qui prend plusieurs drapeaux qui modifient ce qu'elle fait), mais si vous devez utiliser des drapeaux ou des codes de type, les énumérations sont la voie à suivre.

C'est très simple Exemple Java eNum

CrunchifyEnumCompany.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com . crunchify . tutorials ;
 
/**
* @author Crunchify.com
*/
 
public enum CrunchifyEnumCompany {
 
GOOGLE ( "G" ) , YAHOO ( "Y" ) , EBAY ( "E" ) , PAYPAL ( "P" ) ;
 
private String companyLetter ;
 
private CrunchifyEnumCompany ( String s ) {
companyLetter = s ;
}
 
public String getCompanyLetter ( ) {
return companyLetter ;
}
}

CrunchifyEnumExample.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com . crunchify . tutorials ;
 
import com . crunchify . tutorials . CrunchifyEnumCompany ;
 
/**
* @author Crunchify.com
*/
 
public class CrunchifyEnumExample {
 
public static void main ( String [ ] args ) {
System . out . println ( "Get enum value for Comapny 'eBay': "
+ CrunchifyEnumCompany . EBAY . getCompanyLetter ( ) ) ;
}
 
}

Sortir:

1
Get enum value for Comapny 'eBay' : Value : E