Java 枚举(enum) 详解7种常见的用法

最新推荐文章于 2023-05-19 09:51:10 发布
最新推荐文章于 2023-05-19 09:51:10 发布
阅读量599 收藏
点赞数
分类专栏： java基础

转自：http://blog.csdn.net/qq_27093465/article/details/52180865
JDK1.5引入了新的类型——枚举。在  Java  中它虽然算个“小”功能，却给我的开发带来了“大”方便。


用法一：常量

在JDK1.5 之前，我们定义常量都是： public static fianl.... 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。 

Java代码 
  1. public enum Color {  
  2.   RED, GREEN, BLANK, YELLOW  
  3. }  

 

用法二：switch

JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。 

Java代码 
  1. enum Signal {  
  2.     GREEN, YELLOW, RED  
  3. }  
  4. public class TrafficLight {  
  5.     Signal color = Signal.RED;  
  6.     public void change() {  
  7.         switch (color) {  
  8.         case RED:  
  9.             color = Signal.GREEN;  
  10.             break;  
  11.         case YELLOW:  
  12.             color = Signal.RED;  
  13.             break;  
  14.         case GREEN:  
  15.             color = Signal.YELLOW;  
  16.             break;  
  17.         }  
  18.     }  
  19. }  

 

用法三：向枚举中添加新方法

如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。 

Java代码 
  1. public enum Color {  
  2.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
  3.     // 成员变量  
  4.     private String name;  
  5.     private int index;  
  6.     // 构造方法  
  7.     private Color(String name, int index) {  
  8.         this.name = name;  
  9.         this.index = index;  
  10.     }  
  11.     // 普通方法  
  12.     public static String getName(int index) {  
  13.         for (Color c : Color.values()) {  
  14.             if (c.getIndex() == index) {  
  15.                 return c.name;  
  16.             }  
  17.         }  
  18.         return null;  
  19.     }  
  20.     // get set 方法  
  21.     public String getName() {  
  22.         return name;  
  23.     }  
  24.     public void setName(String name) {  
  25.         this.name = name;  
  26.     }  
  27.     public int getIndex() {  
  28.         return index;  
  29.     }  
  30.     public void setIndex(int index) {  
  31.         this.index = index;  
  32.     }  
  33. }  

 

用法四：覆盖枚举的方法

下面给出一个toString()方法覆盖的例子。 

Java代码 
  1. public enum Color {  
  2.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
  3.     // 成员变量  
  4.     private String name;  
  5.     private int index;  
  6.     // 构造方法  
  7.     private Color(String name, int index) {  
  8.         this.name = name;  
  9.         this.index = index;  
  10.     }  
  11.     //覆盖方法  
  12.     @Override  
  13.     public String toString() {  
  14.         return this.index+"_"+this.name;  
  15.     }  
  16. }  

 

用法五：实现接口

所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。 

Java代码 
  1. public interface Behaviour {  
  2.     void print();  
  3.     String getInfo();  
  4. }  
  5. public enum Color implements Behaviour{  
  6.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
  7.     // 成员变量  
  8.     private String name;  
  9.     private int index;  
  10.     // 构造方法  
  11.     private Color(String name, int index) {  
  12.         this.name = name;  
  13.         this.index = index;  
  14.     }  
  15. //接口方法  
  16.     @Override  
  17.     public String getInfo() {  
  18.         return this.name;  
  19.     }  
  20.     //接口方法  
  21.     @Override  
  22.     public void print() {  
  23.         System.out.println(this.index+":"+this.name);  
  24.     }  
  25. }  

 

用法六：使用接口组织枚举

 Java代码 

  1. public interface Food {  
  2.     enum Coffee implements Food{  
  3.         BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
  4.     }  
  5.     enum Dessert implements Food{  
  6.         FRUIT, CAKE, GELATO  
  7.     }  
  8. }  

 

用法七：关于枚举集合的使用

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的 key是enum类型，而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述，可以参考JDK文档。

关于枚举的实现细节和原理请参考：

参考资料：《ThinkingInJava》第四版

http://softbeta.iteye.com/blog/1185573

Enum抽象类常见方法

Enum是所有 Java 语言枚举类型的公共基本类（注意Enum是抽象类），以下是它的常见方法：

返回类型 方法名称 方法说明
int compareTo(E o) 比较此枚举与指定对象的顺序
boolean equals(Object other) 当指定对象等于此枚举常量时，返回 true。
Class<?> getDeclaringClass() 返回与此枚举常量的枚举类型相对应的 Class 对象
String name() 返回此枚举常量的名称，在其枚举声明中对其进行声明
int ordinal() 返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）
String toString() 返回枚举常量的名称，它包含在声明中
static<T extends Enum<T>> T static valueOf(Class<T> enumType, String name) 返回带指定名称的指定枚举类型的枚举常量。


[java]  view plain  copy
  1. package com.lxk.enumTest;  
  2.   
  3. /** 
  4.  * Java枚举用法测试 
  5.  * <p> 
  6.  * Created by lxk on 2016/12/15 
  7.  */  
  8. public class EnumTest {  
  9.     public static void main(String[] args) {  
  10.         forEnum();  
  11.         useEnumInJava();  
  12.     }  
  13.   
  14.     /** 
  15.      * 循环枚举,输出ordinal属性；若枚举有内部属性，则也输出。(说的就是我定义的TYPE类型的枚举的typeName属性) 
  16.      */  
  17.     private static void forEnum() {  
  18.         for (SimpleEnum simpleEnum : SimpleEnum.values()) {  
  19.             System.out.println(simpleEnum + "  ordinal  " + simpleEnum.ordinal());  
  20.         }  
  21.         System.out.println("------------------");  
  22.         for (TYPE type : TYPE.values()) {  
  23.             System.out.println("type = " + type + "    type.name = " + type.name() + "   typeName = " + type.getTypeName() + "   ordinal = " + type.ordinal());  
  24.         }  
  25.     }  
  26.   
  27.     /** 
  28.      * 在Java代码使用枚举 
  29.      */  
  30.     private static void useEnumInJava() {  
  31.         String typeName = "f5";  
  32.         TYPE type = TYPE.fromTypeName(typeName);  
  33.         if (TYPE.BALANCE.equals(type)) {  
  34.             System.out.println("根据字符串获得的枚举类型实例跟枚举常量一致");  
  35.         } else {  
  36.             System.out.println("大师兄代码错误");  
  37.         }  
  38.   
  39.     }  
  40.   
  41.     /** 
  42.      * 季节枚举(不带参数的枚举常量)这个是最简单的枚举使用实例 
  43.      * Ordinal 属性，对应的就是排列顺序，从0开始。 
  44.      */  
  45.     private enum SimpleEnum {  
  46.         SPRING,  
  47.         SUMMER,  
  48.         AUTUMN,  
  49.         WINTER  
  50.     }  
  51.   
  52.   
  53.     /** 
  54.      * 常用类型(带参数的枚举常量，这个只是在书上不常见，实际使用还是很多的，看懂这个，使用就不是问题啦。) 
  55.      */  
  56.     private enum TYPE {  
  57.         FIREWALL("firewall"),  
  58.         SECRET("secretMac"),  
  59.         BALANCE("f5");  
  60.   
  61.         private String typeName;  
  62.   
  63.         TYPE(String typeName) {  
  64.             this.typeName = typeName;  
  65.         }  
  66.   
  67.         /** 
  68.          * 根据类型的名称，返回类型的枚举实例。 
  69.          * 
  70.          * @param typeName 类型名称 
  71.          */  
  72.         public static TYPE fromTypeName(String typeName) {  
  73.             for (TYPE type : TYPE.values()) {  
  74.                 if (type.getTypeName().equals(typeName)) {  
  75.                     return type;  
  76.                 }  
  77.             }  
  78.             return null;  
  79.         }  
  80.   
  81.         public String getTypeName() {  
  82.             return this.typeName;  
  83.         }  
  84.     }  
  85. }  

[java]  view plain  copy
  1. package com.lxk.enumTest;  
  2.   
  3. /** 
  4.  * Java枚举用法测试 
  5.  * <p> 
  6.  * Created by lxk on 2016/12/15 
  7.  */  
  8. public class EnumTest {  
  9.     public static void main(String[] args) {  
  10.         forEnum();  
  11.         useEnumInJava();  
  12.     }  
  13.   
  14.     /** 
  15.      * 循环枚举,输出ordinal属性；若枚举有内部属性，则也输出。(说的就是我定义的TYPE类型的枚举的typeName属性) 
  16.      */  
  17.     private static void forEnum() {  
  18.         for (SimpleEnum simpleEnum : SimpleEnum.values()) {  
  19.             System.out.println(simpleEnum + "  ordinal  " + simpleEnum.ordinal());  
  20.         }  
  21.         System.out.println("------------------");  
  22.         for (TYPE type : TYPE.values()) {  
  23.             System.out.println("type = " + type + "    type.name = " + type.name() + "   typeName = " + type.getTypeName() + "   ordinal = " + type.ordinal());  
  24.         }  
  25.     }  
  26.   
  27.     /** 
  28.      * 在Java代码使用枚举 
  29.      */  
  30.     private static void useEnumInJava() {  
  31.         String typeName = "f5";  
  32.         TYPE type = TYPE.fromTypeName(typeName);  
  33.         if (TYPE.BALANCE.equals(type)) {  
  34.             System.out.println("根据字符串获得的枚举类型实例跟枚举常量一致");  
  35.         } else {  
  36.             System.out.println("大师兄代码错误");  
  37.         }  
  38.   
  39.     }  
  40.   
  41.     /** 
  42.      * 季节枚举(不带参数的枚举常量)这个是最简单的枚举使用实例 
  43.      * Ordinal 属性，对应的就是排列顺序，从0开始。 
  44.      */  
  45.     private enum SimpleEnum {  
  46.         SPRING,  
  47.         SUMMER,  
  48.         AUTUMN,  
  49.         WINTER  
  50.     }  
  51.   
  52.   
  53.     /** 
  54.      * 常用类型(带参数的枚举常量，这个只是在书上不常见，实际使用还是很多的，看懂这个，使用就不是问题啦。) 
  55.      */  
  56.     private enum TYPE {  
  57.         FIREWALL("firewall"),  
  58.         SECRET("secretMac"),  
  59.         BALANCE("f5");  
  60.   
  61.         private String typeName;  
  62.   
  63.         TYPE(String typeName) {  
  64.             this.typeName = typeName;  
  65.         }  
  66.   
  67.         /** 
  68.          * 根据类型的名称，返回类型的枚举实例。 
  69.          * 
  70.          * @param typeName 类型名称 
  71.          */  
  72.         public static TYPE fromTypeName(String typeName) {  
  73.             for (TYPE type : TYPE.values()) {  
  74.                 if (type.getTypeName().equals(typeName)) {  
  75.                     return type;  
  76.                 }  
  77.             }  
  78.             return null;  
  79.         }  
  80.   
  81.         public String getTypeName() {  
  82.             return this.typeName;  
  83.         }  
  84.     }  
  85. }  

[java]  view plain  copy
  1. private static void testSwitchCase() {  
  2.     String typeName = "f5";  
  3.     //这几行注释呢，你可以试着三选一，测试一下效果。  
  4.     //String typeName = "firewall";  
  5.     //String typeName = "secretMac";  
  6.     TypeEnum typeEnum = TypeEnum.fromTypeName(typeName);  
  7.     if (typeEnum == null) {  
  8.         return;  
  9.     }  
  10.     switch (typeEnum) {  
  11.         case FIREWALL:  
  12.             System.out.println("枚举名称(即默认自带的属性 name 的值)是：" + typeEnum.name());  
  13.             System.out.println("排序值(默认自带的属性 ordinal 的值)是：" + typeEnum.ordinal());  
  14.             System.out.println("枚举的自定义属性 typeName 的值是：" + typeEnum.getTypeName());  
  15.             break;  
  16.         case SECRET:  
  17.             System.out.println("枚举名称(即默认自带的属性 name 的值)是：" + typeEnum.name());  
  18.             System.out.println("排序值(默认自带的属性 ordinal 的值)是：" + typeEnum.ordinal());  
  19.             System.out.println("枚举的自定义属性 typeName 的值是：" + typeEnum.getTypeName());  
  20.             break;  
  21.         case BALANCE:  
  22.             System.out.println("枚举名称(即默认自带的属性 name 的值)是：" + typeEnum.name());  
  23.             System.out.println("排序值(默认自带的属性 ordinal 的值)是：" + typeEnum.ordinal());  
  24.             System.out.println("枚举的自定义属性 typeName 的值是：" + typeEnum.getTypeName());  
  25.             break;  
  26.         default:  
  27.             System.out.println("default");  
  28.     }  
  29. }  
[java]  view plain  copy
  1. package com.lxk.enumTest;  
  2.   
  3. /** 
  4.  * Java枚举用法测试 
  5.  * <p> 
  6.  * Created by lxk on 2016/12/15 
  7.  */  
  8. public class EnumTest {  
  9.     public static void main(String[] args) {  
  10.         forEnum();  
  11.         useEnumInJava();  
  12.     }  
  13.   
  14.     /** 
  15.      * 循环枚举,输出ordinal属性；若枚举有内部属性，则也输出。(说的就是我定义的TYPE类型的枚举的typeName属性) 
  16.      */  
  17.     private static void forEnum() {  
  18.         for (SimpleEnum simpleEnum : SimpleEnum.values()) {  
  19.             System.out.println(simpleEnum + "  ordinal  " + simpleEnum.ordinal());  
  20.         }  
  21.         System.out.println("------------------");  
  22.         for (TYPE type : TYPE.values()) {  
  23.             System.out.println("type = " + type + "    type.name = " + type.name() + "   typeName = " + type.getTypeName() + "   ordinal = " + type.ordinal());  
  24.         }  
  25.     }  
  26.   
  27.     /** 
  28.      * 在Java代码使用枚举 
  29.      */  
  30.     private static void useEnumInJava() {  
  31.         String typeName = "f5";  
  32.         TYPE type = TYPE.fromTypeName(typeName);  
  33.         if (TYPE.BALANCE.equals(type)) {  
  34.             System.out.println("根据字符串获得的枚举类型实例跟枚举常量一致");  
  35.         } else {  
  36.             System.out.println("大师兄代码错误");  
  37.         }  
  38.   
  39.     }  
  40.   
  41.     /** 
  42.      * 季节枚举(不带参数的枚举常量)这个是最简单的枚举使用实例 
  43.      * Ordinal 属性，对应的就是排列顺序，从0开始。 
  44.      */  
  45.     private enum SimpleEnum {  
  46.         SPRING,  
  47.         SUMMER,  
  48.         AUTUMN,  
  49.         WINTER  
  50.     }  
  51.   
  52.   
  53.     /** 
  54.      * 常用类型(带参数的枚举常量，这个只是在书上不常见，实际使用还是很多的，看懂这个，使用就不是问题啦。) 
  55.      */  
  56.     private enum TYPE {  
  57.         FIREWALL("firewall"),  
  58.         SECRET("secretMac"),  
  59.         BALANCE("f5");  
  60.   
  61.         private String typeName;  
  62.   
  63.         TYPE(String typeName) {  
  64.             this.typeName = typeName;  
  65.         }  
  66.   
  67.         /** 
  68.          * 根据类型的名称，返回类型的枚举实例。 
  69.          * 
  70.          * @param typeName 类型名称 
  71.          */  
  72.         public static TYPE fromTypeName(String typeName) {  
  73.             for (TYPE type : TYPE.values()) {  
  74.                 if (type.getTypeName().equals(typeName)) {  
  75.                     return type;  
  76.                 }  
  77.             }  
  78.             return null;  
  79.         }  
  80.   
  81.         public String getTypeName() {  
  82.             return this.typeName;  
  83.         }  
  84.     }  
  85. }  




枚举类型对象之间的值比较，是可以使用==，直接来比较值，是否相等的，不是必须使用equals方法的哟。


[java]  view plain  copy
  1. package com.lxk.enumTest;  
  2.   
  3. /** 
  4.  * Java枚举用法测试 
  5.  * <p> 
  6.  * Created by lxk on 2016/12/15 
  7.  */  
  8. public class EnumTest {  
  9.     public static void main(String[] args) {  
  10.         forEnum();  
  11.         useEnumInJava();  
  12.     }  
  13.   
  14.     /** 
  15.      * 循环枚举,输出ordinal属性；若枚举有内部属性，则也输出。(说的就是我定义的TYPE类型的枚举的typeName属性) 
  16.      */  
  17.     private static void forEnum() {  
  18.         for (SimpleEnum simpleEnum : SimpleEnum.values()) {  
  19.             System.out.println(simpleEnum + "  ordinal  " + simpleEnum.ordinal());  
  20.         }  
  21.         System.out.println("------------------");  
  22.         for (TYPE type : TYPE.values()) {  
  23.             System.out.println("type = " + type + "    type.name = " + type.name() + "   typeName = " + type.getTypeName() + "   ordinal = " + type.ordinal());  
  24.         }  
  25.     }  
  26.   
  27.     /** 
  28.      * 在Java代码使用枚举 
  29.      */  
  30.     private static void useEnumInJava() {  
  31.         String typeName = "f5";  
  32.         TYPE type = TYPE.fromTypeName(typeName);  
  33.         if (TYPE.BALANCE.equals(type)) {  
  34.             System.out.println("根据字符串获得的枚举类型实例跟枚举常量一致");  
  35.         } else {  
  36.             System.out.println("大师兄代码错误");  
  37.         }  
  38.   
  39.     }  
  40.   
  41.     /** 
  42.      * 季节枚举(不带参数的枚举常量)这个是最简单的枚举使用实例 
  43.      * Ordinal 属性，对应的就是排列顺序，从0开始。 
  44.      */  
  45.     private enum SimpleEnum {  
  46.         SPRING,  
  47.         SUMMER,  
  48.         AUTUMN,  
  49.         WINTER  
  50.     }  
  51.   
  52.   
  53.     /** 
  54.      * 常用类型(带参数的枚举常量，这个只是在书上不常见，实际使用还是很多的，看懂这个，使用就不是问题啦。) 
  55.      */  
  56.     private enum TYPE {  
  57.         FIREWALL("firewall"),  
  58.         SECRET("secretMac"),  
  59.         BALANCE("f5");  
  60.   
  61.         private String typeName;  
  62.   
  63.         TYPE(String typeName) {  
  64.             this.typeName = typeName;  
  65.         }  
  66.   
  67.         /** 
  68.          * 根据类型的名称，返回类型的枚举实例。 
  69.          * 
  70.          * @param typeName 类型名称 
  71.          */  
  72.         public static TYPE fromTypeName(String typeName) {  
  73.             for (TYPE type : TYPE.values()) {  
  74.                 if (type.getTypeName().equals(typeName)) {  
  75.                     return type;  
  76.                 }  
  77.             }  
  78.             return null;  
  79.         }  
  80.   
  81.         public String getTypeName() {  
  82.             return this.typeName;  
  83.         }  
  84.     }  
  85. }  

先看测试代码：

[java]  view plain  copy
  1. /** 
  2.  * 测试枚举比较,使用equal和== 
  3.  */  
  4. private static void testEnumEqual() {  
  5.     GameEnum s1 = GameEnum.BIG;  
  6.     GameEnum s2 = GameEnum.BIG;  
  7.     GameEnum ss1 = GameEnum.SMALL;  
  8.     System.out.println("s1 == s2：" + (s1 == s2));  
  9.     System.out.println("s1.equals(s2)：" + (s1.equals(s2)));  
  10.   
  11.     System.out.println("s1 == ss1：" + (s1 == ss1));  
  12.     System.out.println("s1.equals(ss1)：" + (s1.equals(ss1)));  
  13. }  
再看使用的枚举代码：

[java]  view plain  copy
  1. /** 
  2.  * Created by lxk on 2017/2/23 
  3.  */  
  4. public enum GameEnum{  
  5.     BIG,  
  6.     SMALL,  
  7.     FATTER  
  8. }  
最后是代码执行的结果图：

结果是：

可以看到，使用== 和使用equals方法的执行结果是一样的。

为什么呢？

可以看下图，因为在Enum类里面，已经重写了equals方法，而方法里面比较就是直接使用==，来比较2个对象的。所以，你在外边直接使用==也是可以的。


[java]  view plain  copy
  1. package com.lxk.enumTest;  
  2.   
  3. /** 
  4.  * Java枚举用法测试 
  5.  * <p> 
  6.  * Created by lxk on 2016/12/15 
  7.  */  
  8. public class EnumTest {  
  9.     public static void main(String[] args) {  
  10.         forEnum();  
  11.         useEnumInJava();  
  12.     }  
  13.   
  14.     /** 
  15.      * 循环枚举,输出ordinal属性；若枚举有内部属性，则也输出。(说的就是我定义的TYPE类型的枚举的typeName属性) 
  16.      */  
  17.     private static void forEnum() {  
  18.         for (SimpleEnum simpleEnum : SimpleEnum.values()) {  
  19.             System.out.println(simpleEnum + "  ordinal  " + simpleEnum.ordinal());  
  20.         }  
  21.         System.out.println("------------------");  
  22.         for (TYPE type : TYPE.values()) {  
  23.             System.out.println("type = " + type + "    type.name = " + type.name() + "   typeName = " + type.getTypeName() + "   ordinal = " + type.ordinal());  
  24.         }  
  25.     }  
  26.   
  27.     /** 
  28.      * 在Java代码使用枚举 
  29.      */  
  30.     private static void useEnumInJava() {  
  31.         String typeName = "f5";  
  32.         TYPE type = TYPE.fromTypeName(typeName);  
  33.         if (TYPE.BALANCE.equals(type)) {  
  34.             System.out.println("根据字符串获得的枚举类型实例跟枚举常量一致");  
  35.         } else {  
  36.             System.out.println("大师兄代码错误");  
  37.         }  
  38.   
  39.     }  
  40.   
  41.     /** 
  42.      * 季节枚举(不带参数的枚举常量)这个是最简单的枚举使用实例 
  43.      * Ordinal 属性，对应的就是排列顺序，从0开始。 
  44.      */  
  45.     private enum SimpleEnum {  
  46.         SPRING,  
  47.         SUMMER,  
  48.         AUTUMN,  
  49.         WINTER  
  50.     }  
  51.   
  52.   
  53.     /** 
  54.      * 常用类型(带参数的枚举常量，这个只是在书上不常见，实际使用还是很多的，看懂这个，使用就不是问题啦。) 
  55.      */  
  56.     private enum TYPE {  
  57.         FIREWALL("firewall"),  
  58.         SECRET("secretMac"),  
  59.         BALANCE("f5");  
  60.   
  61.         private String typeName;  
  62.   
  63.         TYPE(String typeName) {  
  64.             this.typeName = typeName;  
  65.         }  
  66.   
  67.         /** 
  68.          * 根据类型的名称，返回类型的枚举实例。 
  69.          * 
  70.          * @param typeName 类型名称 
  71.          */  
  72.         public static TYPE fromTypeName(String typeName) {  
  73.             for (TYPE type : TYPE.values()) {  
  74.                 if (type.getTypeName().equals(typeName)) {  
  75.                     return type;  
  76.                 }  
  77.             }  
  78.             return null;  
  79.         }  
  80.   
  81.         public String getTypeName() {  
  82.             return this.typeName;  
  83.         }  
  84.     }  
  85. }  
Cadence_D
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 枚举总结
许诗宇的博客
12-03 1377
目录 什么是枚举 枚举语法 枚举的创建与使用样例 声明枚举 枚举类 EnumMap 与 EnumSet EnumMap 类 EnumSet 类 枚举的7种用法 用法一：常量 用法二：switch 用法三：向枚举中添加新方法 用法四：覆盖枚举的方法 用法五：实现接口 用法六：使用接口组织枚举 用法七：关于枚举集合的使用 枚举类的底层实现 Enum基础源码 创建过程 枚举底层结构 静态代码块 编译器添加的values方法 编译器添加的valueOf方法 生成的内.
Java的枚举enum示例详解
08-25
主要给大家介绍了关于Java的枚举enum的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Java具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Java枚举类型enum的详解及使用
08-30
主要介绍了Java枚举类型enum的详解及使用的相关资料,需要的朋友可以参考下
Java（enum）枚举用法详解
09-01
本篇文章主要介绍了Java 枚举用法详解，枚举的好处：可以将常量组织起来，统一进行管理。有兴趣的可以一起来了解一下。
Java~枚举的使用
qq_58284486的博客
04-06 5024
目录 枚举的定义 枚举的使用 values()的使用 ordinal()的使用 valueOf()的使用 compareTo()的使用 枚举的优缺点 枚举的定义 枚举是JDK1.5以后引入的。主要用途：将一组常量组织起来，在引入枚举之前表示一组常量通常是使用定义常量的方式： public static final int RED = 1; public static final int GREEN = 2; public static final in...
Java的枚举类型用法介绍
热门推荐
吴名氏的博客
05-19 9万+
Java的枚举类型用法介绍
Java枚举详解
Java后端技术栈
12-05 8447
枚举是一个被命名的整型常数的集合，用于声明一组带标识符的常数。枚举在曰常生活中很常见，例如一个人的性别只能是“男”或者“女”，一周的星期只能是 7 天中的一个等。类似这种当一个变量有几种固定可能的取值时，就可以将它定义为枚举类型。 在 JDK 1.5 之前没有枚举类型，那时候一般用接口常量来替代。而使用 Java 枚举类型 enum 可以更贴近地表示这种常量。声明枚举 声明枚举时必须使用 enum 关键字，然后定义枚举的名称、可访问性、基础类型和成员等。枚举声明的语法如下： enum-modifier
Java -枚举的使用
ryy1999的博客
04-20 2907
枚举常量更简单安全。枚举具有内置方法 ，代码更优雅缺点：3. 不可继承，无法扩展,【从构造的方法的私有性就能看出来】1、枚举 将常量组织起来统一进行管理，更简单安全。2、枚举本身就是一个类，其构造方法默认为私有的，且都是默认继承于 java.lang.Enum3、 枚举可以避免反射和序列化问题：枚举类非常安全！4、不可继承，无法扩展。5、枚举具有内置方法 ，代码更优雅。
【Enum】枚举在 Java 中的常用用法
sco5282的博客
08-05 4956
相信大家通过前面几篇关于“枚举”的博文的学习，大大地提升了对枚举的认识。仅仅地知道枚举的原理不行啊，还得知道怎么去使用它。那么，下面就简单地介绍下枚举的常用用法吧~~
java枚举（enum）使用详解
u011250186的博客
10-14 7102
java枚举（enum）使用详解
Java枚举(enum) 详解7种常见的用法
09-01
主要介绍了Java枚举(enum) 详解7种常见的用法,具有一定的参考价值，有需要的可以了解一下。
java 中枚举类enum的values()方法的详解
08-29
主要介绍了java 中枚举类enum的values()方法的详解的相关资料,希望通过本文大家能够掌握这部分内容，需要的朋友可以参考下
java 枚举(enum) 详解（学习资料）
最新发布
06-17
java 枚举(enum) 详解（学习资料）； java 枚举(enum) 详解（学习资料）； java 枚举(enum) 详解（学习资料）； java 枚举(enum) 详解（学习资料）；
高阶Java-Java枚举类型 enum 应用详解
03-17
NULL 博文链接：https://janeky.iteye.com/blog/463611
javaenum(枚举)使用详解+总结.pdf
01-11
javaenum(枚举)使用详解+总结.pdf
详解Java中的迭代迭代器Iterator与枚举器Enumeration
09-02
Iterator与Enumeration分别是实现迭代器和枚举器类的接口,下面就带大家来详解Java中的迭代迭代器Iterator与枚举器Enumeration,以及它们之间的区别.
Mybatis-Plus通用枚举的使用详解
09-07
主要介绍了Mybatis-Plus通用枚举的使用详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
mybatis中实现枚举自动转换方法详解
08-29
在使用mybatis的时候经常会遇到枚举类型的转换，下面这篇文章主要给大家介绍了关于mybatis中实现枚举自动转换的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或工作具有一定的参考学习价值，需要的朋友们...
java枚举类型enum用法
06-13
Java的枚举类型（enum）是一种特殊的数据类型，用于定义常量集合。它们可以作为一组常量来使用，这些常量可以用作方法参数、变量或返回值。 以下是Java枚举类型的一些用法： 1. 定义枚举类型：使用关键字enum定义枚举类型。 ```java enum Color { RED, BLUE, GREEN } ``` 2. 声明枚举类型变量：使用枚举类型名和枚举常量名来声明枚举类型变量。 ```java Color c = Color.RED; ``` 3. 遍历枚举类型：使用枚举类型的values()方法来遍历枚举类型。 ```java for (Color c : Color.values()) { System.out.println(c); } ``` 4. 枚举类型常量的属性和方法：枚举类型常量可以有自己的属性和方法。 ```java enum Color { RED("红色"), BLUE("蓝色"), GREEN("绿色"); private String name; private Color(String name) { this.name = name; } public String getName() { return name; } } Color c = Color.RED; System.out.println(c.getName()); // 输出：红色 ``` 枚举类型在Java中是非常有用的，它们可以提高代码的可读性和可维护性，避免了使用魔术数字等不可控的常量。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值