Java中的枚举-yiteyi-C++库

枚举用于在编程语言中表示一组命名常量。例如，一副扑克牌中的4套西服可能是4个名为Club、Diamond、Heart和Spade的枚举数，属于名为西服的枚举类型。其他例子包括自然枚举类型（如行星、一周中的几天、颜色、方向等）。

null

当我们在编译时知道所有可能的值时，就会使用枚举，例如菜单上的选项、舍入模式、命令行标志等。枚举类型中的常量集不必保持不变 固定的 永远。

在Java（1.5版）中，枚举用枚举数据类型。Java枚举比 C/C++枚举 .在Java中，我们还可以向其添加变量、方法和构造函数。enum的主要目标是定义我们自己的数据类型（枚举数据类型）。

Java中enum的声明： 枚举声明可以在类外部或类内部完成，但不能在方法内部完成。

JAVA

                         // A simple enum example where enum is declared                       
                         // outside any class (Note enum keyword instead of                       
                         // class keyword)                       
           
                         enum                                     Color {                       
                                                 RED,                       
                                                 GREEN,                       
                                                 BLUE;                       
                         }                       
           
                         public                                     class                                     Test {                       
                                                 // Driver method                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 Color c1 = Color.RED;                       
                                                 System.out.println(c1);                       
                                                 }                       
                         }                       

输出

RED

JAVA

                         // enum declaration inside a class.                       
           
                         public                                     class                                     Test {                       
                                                 enum                                     Color {                       
                                                 RED,                       
                                                 GREEN,                       
                                                 BLUE;                       
                                                 }                       
           
                                                 // Driver method                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 Color c1 = Color.RED;                       
                                                 System.out.println(c1);                       
                                                 }                       
                         }                       

输出

RED

枚举中的第一行应该是常量列表，然后是方法、变量和构造函数等其他内容。
根据 Java命名约定，建议我们用所有大写字母命名常量

enum的要点：

每个枚举都是使用类在内部实现的。

/* internally above enum Color is converted toclass Color{     public static final Color RED = new Color();     public static final Color BLUE = new Color();     public static final Color GREEN = new Color();}*/

每个枚举常量代表一个对象类型为enum。
枚举类型可以作为参数传递给转换声明。

JAVA

                         // A Java program to demonstrate working on enum                       
                         // in switch case (Filename Test. Java)                       
           
                         import                                     java.util.Scanner;                       
           
                         // An Enum class                       
                         enum                                     Day {                       
                                                 SUNDAY,                       
                                                 MONDAY,                       
                                                 TUESDAY,                       
                                                 WEDNESDAY,                       
                                                 THURSDAY,                       
                                                 FRIDAY,                       
                                                 SATURDAY;                       
                         }                       
           
                         // Driver class that contains an object of "day" and                       
                         // main().                       
                         public                                     class                                     Test {                       
                                                 Day day;                       
           
                                                 // Constructor                       
                                                 public                                     Test(Day day) {                                     this                                     .day = day; }                       
           
                                                 // Prints a line about Day using switch                       
                                                 public                                     void                                     dayIsLike()                       
                                                 {                       
                                                 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                                     ;                       
                                                 }                       
                                                 }                       
           
                                                 // Driver method                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 String str =                                     "MONDAY"                                     ;                       
                                                 Test t1 =                                     new                                     Test(Day.valueOf(str));                       
                                                 t1.dayIsLike();                       
                                                 }                       
                         }                       

输出

Mondays are bad.

每个枚举常量都是隐式的 公开静态决赛 .既然是这样 静止的 ，我们可以使用枚举名称访问它。既然是 最终的 ，我们无法创建子枚举。
我们可以申报 main（）方法 在枚举中。因此，我们可以直接从命令提示符调用enum。

JAVA

                         // A Java program to demonstrate that we can have                       
                         // main() inside enum class.                       
           
                         enum                                     Color {                       
                                                 RED,                       
                                                 GREEN,                       
                                                 BLUE;                       
           
                                                 // Driver method                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 Color c1 = Color.RED;                       
                                                 System.out.println(c1);                       
                                                 }                       
                         }                       

输出

RED

枚举和继承：

所有枚举都隐式扩展 JAVA枚举类 .作为一个阶级一 Java中的父对象，因此枚举不能扩展任何其他内容。
toString（）方法 在 JAVA枚举类 ，返回枚举常量名称。
enum可以实现许多接口。

values（）、ordinal（）和valueOf（）方法：

这些方法都存在于内部 JAVAEnum先生 .
values（）方法 可用于返回枚举中存在的所有值。
顺序在枚举中很重要。通过使用 序数（）方法 ，可以找到每个枚举常量索引，就像数组索引一样。
valueOf（）方法 返回指定字符串值的枚举常量（如果存在）。

JAVA

                         // Java program to demonstrate working of values(),                       
                         // ordinal() and valueOf()                       
           
                         enum                                     Color {                       
                                                 RED,                       
                                                 GREEN,                       
                                                 BLUE;                       
                         }                       
           
                         public                                     class                                     Test {                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 // Calling values()                       
                                                 Color arr[] = Color.values();                       
           
                                                 // enum with loop                       
                                                 for                                     (Color col : arr) {                       
                                                 // Calling ordinal() to find index                       
                                                 // of color.                       
                                                 System.out.println(col +                                     " at index "                       
                                                 + col.ordinal());                       
                                                 }                       
           
                                                 // Using valueOf(). Returns an object of                       
                                                 // Color with given constant.                       
                                                 // Uncommenting second line causes exception                       
                                                 // IllegalArgumentException                       
                                                 System.out.println(Color.valueOf(                                     "RED"                                     ));                       
                                                 // System.out.println(Color.valueOf("WHITE"));                       
                                                 }                       
                         }                       

输出

RED at index 0GREEN at index 1BLUE at index 2RED

枚举和构造函数：

enum可以包含一个构造函数，在加载enum类时为每个enum常量分别执行该构造函数。
我们不能显式地创建枚举对象，因此不能直接调用枚举构造函数。

枚举和方法：

enum可以同时包含这两个元素 混凝土 方法和摘要方法。如果一个enum类有一个抽象方法，那么enum类的每个实例都必须实现它

JAVA

                         // Java program to demonstrate that enums can have                       
                         // constructor and concrete methods.                       
           
                         // An enum (Note enum keyword inplace of class keyword)                       
                         enum                                     Color {                       
                                                 RED,                       
                                                 GREEN,                       
                                                 BLUE;                       
           
                                                 // enum constructor called separately for each                       
                                                 // constant                       
                                                 private                                     Color()                       
                                                 {                       
                                                 System.out.println(                                     "Constructor called for : "                       
                                                 +                                     this                                     .toString());                       
                                                 }                       
           
                                                 public                                     void                                     colorInfo()                       
                                                 {                       
                                                 System.out.println(                                     "Universal Color"                                     );                       
                                                 }                       
                         }                       
           
                         public                                     class                                     Test {                       
                                                 // Driver method                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 Color c1 = Color.RED;                       
                                                 System.out.println(c1);                       
                                                 c1.colorInfo();                       
                                                 }                       
                         }                       

输出

Constructor called for : REDConstructor called for : GREENConstructor called for : BLUEREDUniversal Color

下一篇关于enum的文章： Java中具有自定义值的枚举

本文由 高拉夫·米格拉尼 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java