Java基础：Java枚举类[详解]

た入场券 2024-03-31 12:04 80阅读 0赞

#### 文章目录 ####

*  一、Java 枚举(enum)
 *   *  1.1概念
     *  1.2enum的常用方法
     *  1.3迭代枚举元素
     *  1.4在 switch 中使用枚举类
     *  1.5 枚举类中的抽象方法实现

## 一、Java 枚举(enum) ##

### 1.1概念 ###

Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节 。

**注意：**

*  枚举对应英文(enumeration,简写 `enum`)
 *  枚举是一组常量的集合
 *  枚举属于一种特殊的类，里面只包含一组有限的特定的对象
 *  不需要提供 `setXxxx()` 方法，因为枚举对象值通常为只读
 *  对枚举对象/属性使用 `static+final` 共同修饰.
 *  构造函数只能使用 `private` 访问修饰符，所以外部无法调用
 *  枚举对象名通常使用全部大写，与常量的命名规范一样
 *  枚举对象根据需要，也可以有多个属性

**例如：**

public class Demo04 {
        
        public static void main(String[] args) {
        
            System.out.println(Season2.SPRING.show());//结果：Season{name='春天', desc='温暖'}
            System.out.println(Season2.SUMMER.show());//结果：Season{name='夏天', desc='炎热'}
        }
    }
    enum  Season2{
        
        SPRING("春天", "温暖") {
        
            //匿名的方式实现show方法
            @Override
            public Season2 show() {
        
                return SPRING;
            }
        },
        WINTER("夏天", "炎热") {
        
            @Override
            public Season2 show() {
        
                return WINTER;
            }
        },
        SUMMER("夏天", "炎热") {
        
            @Override
            public Season2 show() {
        
                return SUMMER;
            }
        },
        AUTUMN("秋天", "凉爽") {
        
            @Override
            public Season2 show() {
        
                return AUTUMN;
            }
        };
    
        private String name;
        private String desc;
    
        private Season2(String name, String desc) {
        
            this.name = name;
            this.desc = desc;
        }
        /** 抽象方法 */
        public abstract Season2 show();
        
        public String getName() {
        
            return name;
        }
        public String getDesc() {
        
            return desc;
        }
        @Override
        public String toString() {
        
            return "Season{" +
                    "name='" + name + '\'' +
                    ", desc='" + desc + '\'' +
                    '}';
        }

每个枚举都是通过 Class 在内部实现的，且所有的枚举值都是 public static final 的。

以上的枚举类 转化在内部类实现：

public class Demo03 {
        
        public static void main(String[] args) {
        
            System.out.println(Season.AUTUMN);
            System.out.println(Season.SUMMER);
        }
    }
    class Season{
        
        private String name;
        private String desc;
        //定义了四个对象
        //加final是为了使引用不能被修改
        public static final Season SPRING = new Season("春天", "温暖");
        public static final Season WINTER = new Season("冬天", "寒冷");
        public static final Season SUMMER = new Season("夏天", "炎热");
        public static final Season AUTUMN = new Season("秋天", "凉爽");
        
        private Season(String name, String desc) {
        
            this.name = name;
            this.desc = desc;
        }
    
        public String getName() {
        
            return name;
        }
        public String getDesc() {
        
            return desc;
        }
        @Override
        public String toString() {
        
            return "Season{" +
                    "name='" + name + '\'' +
                    ", desc='" + desc + '\'' +
                    '}';
        }
    }

**结果：**

Season{
        name='秋天', desc='凉爽'}
    Season{
        name='夏天', desc='炎热'}

**注意：**

*  当我们使用enum关键字开发一个枚举类时，**默认会继承Enum类**；而且该**枚举类是一个final类**。就不能再继承其它类了。
 *  如果使用无参构造器创建枚举对象，则可以省略小括号
 *  当有多个枚举对象时，**使用 ，隔开**，最后以一个分号结尾
 *  枚举对象必须放在枚举类的行首
 *  枚举类和普通类一样，可以实现接口

### 1.2enum的常用方法 ###

*  toString()：Enum类已经重写过了，返回的是当前对象名；子类可以重写该方法，用于返回对象的属性信息
 *  name()：返回当前对象名(常量名)，子类中不能重写
 *  ordinal()：返回当前对象的位置号，默认从0开始
 *  values()：返回当前枚举类中所有的常量对象
 *  valueOf()：将字符串转换成已有的枚举对象，要求字符串必须为已有的常量名，否则报异常！
 *  compareTo()：比较两个枚举常量的大小(编号),返回的结果是两个枚举常量的编号相减得到的数

**代码如下：**

public class Demo05 {
        
        public static void main(String[] args) {
        
            Season2 autumn = Season2.AUTUMN;
     
            System.out.println(autumn.name());
     
            System.out.println(autumn.ordinal());
     
            Season2[] values = Season2.values();
            for (Season2 season : values) {
        
                System.out.println(season);
            }
     
            Season2 autumn1 = Season2.valueOf("AUTUMN");
            System.out.println("season1="+autumn1);
            System.out.println(autumn == autumn1);
     
            System.out.println(Season2.AUTUMN.compareTo(Season2.SUMMER));
        }
    }
    enum  Season2{
        
        SPRING("春天", "温暖"),WINTER("冬天", "寒冷"),SUMMER("夏天", "炎热"),AUTUMN("秋天", "凉爽");
     
        private String name;
        private String desc;
     
        private Season2(String name, String desc) {
        
            this.name = name;
            this.desc = desc;
        }
        public String getName() {
        
            return name;
        }
        public String getDesc() {
        
            return desc;
        }
        @Override
        public String toString() {
        
            return "Season{" +
                    "name='" + name + '\'' +
                    ", desc='" + desc + '\'' +
                    '}';
        }
    }

**结果：**

AUTUMN
    3
    Season{
        name='春天', desc='温暖'}
    Season{
        name='冬天', desc='寒冷'}
    Season{
        name='夏天', desc='炎热'}
    Season{
        name='秋天', desc='凉爽'}
    season1=Season{
        name='秋天', desc='凉爽'}
    true
    1
    Process finished with exit code 0

### 1.3迭代枚举元素 ###

可以使用 for 语句来迭代枚举元素：

enum Color
    {
        
        RED, GREEN, BLUE;
    }
    public class MyClass {
        
      public static void main(String[] args) {
        
        for (Color myVar : Color.values()) {
        
          System.out.println(myVar);
        }
      }
    }

### 1.4在 switch 中使用枚举类 ###

枚举类常应用于 switch 语句中：

enum Color
    {
        
        RED, GREEN, BLUE;
    }
    public class MyClass {
        
      public static void main(String[] args) {
        
        Color myVar = Color.BLUE;
    
        switch(myVar) {
        
          case RED:
            System.out.println("红色");
            break;
          case GREEN:
             System.out.println("绿色");
            break;
          case BLUE:
            System.out.println("蓝色");
            break;
        }
      }
    }

### 1.5 枚举类中的抽象方法实现 ###

enum Color{
        
        RED{
        
            public String getColor(){
        //枚举对象实现抽象方法
                return "红色";
            }
        },
        GREEN{
        
            public String getColor(){
        //枚举对象实现抽象方法
                return "绿色";
            }
        },
        BLUE{
        
            public String getColor(){
        //枚举对象实现抽象方法
                return "蓝色";
            }
        };
        public abstract String getColor();//定义抽象方法
    }
    
    public class Test{
        
        public static void main(String[] args) {
        
            for (Color c:Color.values()){
        
                System.out.print(c.getColor() + "、");
            }
        }
    }

**结果：**

红色、绿色、蓝色、