Java 枚举7常见种用法

最新推荐文章于 2022-07-07 11:15:12 发布

piaopiaopiaopiaopiao

最新推荐文章于 2022-07-07 11:15:12 发布

阅读量665

点赞数

分类专栏： java

java 专栏收录该内容

68 篇文章 0 订阅

订阅专栏

DK1.5引入了新的类型——枚举。在 Java 中它虽然算个“小”功能，却给我的开发带来了“大”方便。

用法一：常量

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

[java]view plaincopy 
      
 public enum Color {  
   RED, GREEN, BLANK, YELLOW  
 }  

用法二：switch

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

[java]view plaincopy 
      
 enum Signal {  
     GREEN, YELLOW, RED  
 }  
 public class TrafficLight {  
     Signal color = Signal.RED;  
     public void change() {  
         switch (color) {  
         case RED:  
             color = Signal.GREEN;  
             break;  
         case YELLOW:  
             color = Signal.RED;  
             break;  
         case GREEN:  
             color = Signal.YELLOW;  
             break;  
         }  
     }  
 }  

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

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

[java]view plaincopy 
    
 public enum Color {  
     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
     // 成员变量  
     private String name;  
     private int index;  
     // 构造方法  
     private Color(String name, int index) {  
         this.name = name;  
         this.index = index;  
     }  
     // 普通方法  
     public static String getName(int index) {  
         for (Color c : Color.values()) {  
             if (c.getIndex() == index) {  
                 return c.name;  
             }  
         }  
         return null;  
     }  
     // get set 方法  
     public String getName() {  
         return name;  
     }  
     public void setName(String name) {  
         this.name = name;  
     }  
     public int getIndex() {  
         return index;  
     }  
     public void setIndex(int index) {  
         this.index = index;  
     }  
 }  

用法四：覆盖枚举的方法

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

[java]view plaincopy 
      
 public enum Color {  
     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
     // 成员变量  
     private String name;  
     private int index;  
     // 构造方法  
     private Color(String name, int index) {  
         this.name = name;  
         this.index = index;  
     }  
     //覆盖方法  
     @Override  
     public String toString() {  
         return this.index+"_"+this.name;  
     }  
 }  

用法五：实现接口

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

[java]view plaincopy 
    
 public interface Behaviour {  
     void print();  
     String getInfo();  
 }  
 public enum Color implements Behaviour{  
     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
     // 成员变量  
     private String name;  
     private int index;  
     // 构造方法  
     private Color(String name, int index) {  
         this.name = name;  
         this.index = index;  
     }  
 //接口方法  
     @Override  
     public String getInfo() {  
         return this.name;  
     }  
     //接口方法  
     @Override  
     public void print() {  
         System.out.println(this.index+":"+this.name);  
     }  
 }  

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

[java]view plaincopy 
      
 public interface Food {  
     enum Coffee implements Food{  
         BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
     }  
     enum Dessert implements Food{  
         FRUIT, CAKE, GELATO  
     }  
 }  

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

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

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

参考资料：《ThinkingInJava》第四版

本文转自：http://blog.csdn.net/liuyanghai/article/details/8588527

在JDK1.5之前，java可以有两种方式定义新类型：类和接口。对于大部分面向对象编程来说，这两种方法看起来似乎足够了，但是在一些特殊情况下，这些方法就不适合。例如，想定义一个Color类，它只能有Red 、Green、Blue三种值，其他的任何值都是非法的，那么JDK1.5之前虽然可以构造这样的代码，但是要做很多的工作，也有可能带来各种不安全的问题。而JDK1.5之后引入的枚举类型（Enum）就能避免这些问题。

所谓的枚举就是规定好了指定的取值范围，所有的内容只能从指定的范围中取得。

使用简单类完成颜色的固定取值问题。

[java]view plaincopy 
    
 package com.itmyhome;  
   
 class Color{  
     public static final Color colorRed =  new Color("红色");  
     public static final Color colorGreen =  new Color("蓝色");  
     public static final Color colorBlue =  new Color("绿色");  
     private String name;  
     public Color(String name){  
         this.name = name;  
     }  
     public String getName() {  
         return name;  
     }  
     public void setName(String name) {  
         this.name = name;  
     }  
 }  
 public class T {  
     public static void main(String[] args) throws Exception{  
         Color cRed = Color.colorRed;  
         System.out.println(cRed.getName());  
     }  
 }  

此时，程序限定了所能取的对象的范围，所以达到了枚举的功能，以上是一种枚举的方式，在最早的java开发中因为没有枚举这种概念，所以有时候也使用接口表示。

[java]view plaincopy 
    
 interface Color{  
     public static final int RED = 1;  
     public static final int GREEN = 2;  
     public static final int BLUE = 3;  
 }  

定义一个枚举类型

在JDK1.5之后，引入了一个新的关键字类型 enum，可以直接定义枚举类型，格式如下：

【public】 enum 枚举类型名称{

枚举对象1，枚举对象2，.......枚举对象n;

}

使用enum关键字定义。

[java]view plaincopy 
    
 public enum Color {  
     RED,GREEN,BLUE;  
 }  

因为枚举已经指定好了范围，所以可以使用foreach 进行全部的输出，使用“枚举.values()”的形式取得全部的枚举内容。

[java]view plaincopy 
    
 package com.itmyhome;  
   
 enum Color {  
     RED,GREEN,BLUE;  
 }  
   
 public class T {  
     public static void main(String[] args) throws Exception{  
         for(Color c:Color.values()){  
             System.out.println(c);  
         }  
     }  
 }  

还可以直接将内容在switch语句上使用。

[java]view plaincopy 
    
 package com.itmyhome;  
   
 enum Color {  
     RED, GREEN, BLUE;  
 }  
   
 public class T {  
     public static void main(String[] args) throws Exception{  
         for(Color c:Color.values()){  
             print(c);  
         }  
     }  
     public static void print(Color color){  
         switch(color){  
             case RED:{  
                 System.out.println("红色");  
                 break;  
             }  
             case GREEN:{  
                 System.out.println("绿色");  
                 break;  
             }  
             case BLUE:{  
                 System.out.println("蓝色");  
                 break;  
             }  
             default:{  
                 System.out.println("未知颜色");  
             }  
         }  
     }  
 }  

Enum

从前面已经清楚的知道，使用enum关键字可以定义一个枚举，实际上此关键字表示的是 java.lang.Enum类型，即：使用enum声明的枚举类型，就相当于定义一个类，而此类则默认继承java.lang.Enum类。

java.lang.Enum类的定义如下：

[java]view plaincopy 
    
 public abstract class Enum<E extends Enum<E>>  
 extends Object   
 implements Comparable<E>, Serializable  

此类定义的时候使用了泛型机制，而且实现了Comparable接口以及Serializable接口，证明此中类型是可以比较，可以被序列化的。

枚举类的主要方法

Enum类的构造方法：

[java]view plaincopy 
    
 protected  Enum(String name, int ordinal)   

构造方法中接收两个参数，一个表示枚举的名字，一个表示枚举的序号。

[java]view plaincopy 
    
 for(Color c:Color.values()){  
             System.out.println(c.name()+"----"+c.ordinal());  
         }  

希望可以使用一些文字表示颜色的信息，则可以按照最早的Color类的形式，在枚举中定义属性及自己的构造方法，但是一旦定义有参构造之后，在声明枚举对象的时候就必须明确的调用构造方法，并传递参数。

[java]view plaincopy 
    
 package com.itmyhome;  
   
 enum Color {  
     RED("红色"), GREEN("绿色"), BLUE("蓝色");   //传入参数  
     private String name;  
     private Color(String name){  //定义构造方法  
         this.name = name;  
     }  
     public String getName() {  
         return name;  
     }  
     public void setName(String name) {  
         this.name = name;  
     }  
       
 }  
   
 public class T {  
     public static void main(String[] args) throws Exception{  
         for(Color c:Color.values()){  
             System.out.println(c.ordinal()+"----"+c.name()+"----"+c.getName());  
         }  
     }  
 }  