Java 中的枚举类（4千字超全详解）

今天药忘吃喽~ 2023-09-28 14:34 40阅读 0赞

# 枚举 #

## 1. 枚举的引入 ##

> **要求创建一个季节（Season）类，只能创建春夏秋冬4个对象。**
> 
>  *  旧方法：假如按照以往的思路，只能创建一个普通的Season 类。

*  **代码如下：**

public class Enumeration01 {
        
       public static void main(String[] args) {
        
           //使用
           Season spring = new Season("春天", "温暖");
           Season winter = new Season("冬天", "寒冷");
           Season summer = new Season("夏天", "炎热");
           Season autumn = new Season("秋天", "凉爽");
           Season other = new Season("红天", "~~~");// 可以随意多创建对象，不满足题目要求
    //     autumn.setName("XXX");// 会改变对象的属性，不满足题目的要求
    //     autumn.setDesc("非常的热..");
       }
    }
    class Season{
        //类
       private String name;
       private String desc;// 季节描述
    
       public Season(String name, String desc) {
        
           this.name = name;
           this.desc = desc;
       }
    
       public String getName() {
        
           return name;
       }
    
       public void setName(String name) {
        
           this.name = name;
       }
    
       public String getDesc() {
        
           return desc;
       }
    
       public void setDesc(String desc) {
        
           this.desc = desc;
       }
    }

*  思考：使用普通类的定义，我们不能体现Season 类只有4个固定的对象，因为使用者可以随意创建更多的对象。因此我们需要一种特殊的类，可以限制使用者创建的对象的个数与类型 ---- 于是便引入了枚举类。
 *  **枚举（enumeration）：枚举是一组常量的集合；它是一种特殊的类，里面只包含****一组有限的特殊的不能修改的对象。**

## 2. 枚举的基本用法 ##

*  **使用 enum 关键字实现枚举：**

> **使用步骤：**  
> **（1）使用 enum 关键字取代 class 关键字定义一个类，该类便称为枚举类。**  
> **（2）在枚举类内部直接创建对象，枚举类对象是默认使用 public static final 一起修饰的，如果有多个对象，则必须且只能使用（，）间隔开。**  
> **（3）在枚举类中将构造器私有化，防止外部随意创建枚举类对象。**  
> **（4）只保留属性的get 方法，不提供属性的 set 方法，防止枚举类的对象属性被更改。**

*  **将上例代码修改如下：**

public class Enumeration03 {
        
        public static void main(String[] args) {
        
            System.out.println(Season.AUTUMN);
            System.out.println(Season.SUMMER);
        }
    }
    
    enum  Season {
        //类
    
        //定义了四个静态对象，使用了enum 来实现枚举类
        /*
        1. 使用关键字 enum 替代 class；
        2. public static final Season SPRING = new Season("春天", "温暖") 直接使用
          SPRING("春天", "温暖") 来代替，即常量名(实参列表)；
        3. 如果有多个常量(对象)， 使用 , 号间隔即可；
        4. 如果使用enum 来实现枚举，要求将定义常量对象的语句，写在第一行；
        5. 如果我们使用的是无参构造器，创建常量对象，则可以省略括号()；
         */
        SPRING("春天", "温暖"), WINTER("冬天", "寒冷"), AUTUMN("秋天", "凉爽"),
        SUMMER("夏天", "炎热");// 调用了构造器
        
    	// 下面定义对象的语句和上面的效果是一样的。
    //    public static final Season SPRING = new Season("春天", "温暖");
    //    public static final Season WINTER = new Season("冬天", "寒冷");
    //    public static final Season AUTUMN = new Season("秋天", "凉爽");
    //    public static final Season SUMMER = new Season("夏天", "炎热");
    
        private String name;
        private String desc;
    
        private 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 + '\'' +
                    '}';
        }
    }

*  说明：使用 enum 关键字后，Season 类中的对象变成了固定的对象，这样便能满足我们一开始提出的要求了。

## 3. 枚举的注意事项和细节 ##

> **（1）当我们使用 enum 关键字开发一个枚举类时，默认会继承 Enum 类，而且是一个 final 类，不能再被其他类继承。**  
> **（2）传统的 public static final Season2 SPRING = new Season2(“春天”, “温暖”); 简化成 SPRING(“春天”, “温暖”)， 这里必 须知道，它调用的是哪个构造器。**  
> **（3）如果使用无参构造器 创建 枚举对象时，其实参列表和小括号都可以省略。**  
> **（4）当有多个枚举对象时，使用（，）间隔，最后由一个分号结尾。**  
> **（5）定义类枚举对象的语句必须放在枚举类的第一句。**

## 4. 枚举类常用方法说明 ##

*  **当我们使用 enum 关键字开发一个枚举类时，该类默认会继承 Enum 类，这时便可以使用 Enum 类的方法了。**
 *  **常用方法如下：**

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">toString（）</td> 
   <td align="left">Enum 类已经重写过了Object类的toString 方法，返回的是当前对象名。</td> 
  </tr> 
  <tr> 
   <td align="left">name（）</td> 
   <td align="left">返回当前对象名（常量名），子类中不能重写。</td> 
  </tr> 
  <tr> 
   <td align="left">ordinal（）</td> 
   <td align="left">返回当前对象的位置号，默认从 0 开始。</td> 
  </tr> 
  <tr> 
   <td align="left">values（）</td> 
   <td align="left">返回当前枚举类中所有的对象数组。</td> 
  </tr> 
  <tr> 
   <td align="left">valueOf（String str）</td> 
   <td align="left">将字符串转换成枚举对象，要求传入的字符串必须 为已有的对象名，否则报异常。</td> 
  </tr> 
  <tr> 
   <td align="left">compareTo（Enum e）</td> 
   <td align="left">比较两个枚举常量，比较是位置号。</td> 
  </tr> 
 </tbody> 
</table>

*  **代码演示：**

public class EnumMethod {
        
        public static void main(String[] args) {
        
    
            //使用Season 枚举类，来演示各种方法
            Season autumn = Season.AUTUMN;
    
            //输出枚举对象的名字
            System.out.println(autumn.name());
            
            //ordinal() 输出的是该枚举对象的次序/位置号，从0开始编号
            //AUTUMN 枚举对象是第三个，因此输出 2
            System.out.println(autumn.ordinal());
    
            // values方法，返回 Season2[]
            // 含有定义的所有枚举对象
            Season[] values = Season.values();
            
            System.out.println("===遍历取出枚举对象(增强for)====");
            for (Season season: values) {
        
                System.out.println(season);
            }
    
            //valueOf：将字符串转换成枚举对象，要求字符串必为已有的对象名，否则报异常
            //执行流程
            //1. 根据你输入的 "AUTUMN" 到 Season2的枚举对象去查找
            //2. 如果找到了，就返回，如果没有找到，就报错
            Season autumn1 = Season.valueOf("AUTUMN");
            System.out.println("autumn1=" + autumn1);
            System.out.println(autumn == autumn1);
    
            //compareTo：比较两个枚举常量，比较的就是位置号
     		// 就是把 Season.AUTUMN 枚举对象的位置号 和 Season.SUMMER枚举对象的位置号比较
            /*
            源码如下：
    
            public final int compareTo(E o) {
                return self.ordinal - other.ordinal;
            }
             */
            // Season.AUTUMN的编号[2] - Season.SUMMER的编号[3]
            System.out.println(Season.AUTUMN.compareTo(Season.SUMMER));
    
            // 最后补充了一个增强for
           int[] nums = {
        1, 2, 9};
    
           //普通的for循环
           System.out.println("=====普通的for=====");
           for (int i = 0; i < nums.length; i++) {
        
               System.out.println(nums[i]);
           }
    
           System.out.println("=====增强的for=====");
    
           //执行流程是 依次从nums数组中取出数据，赋给i, 如果取出完毕，则退出for
           for(int i : nums) {
        
               System.out.println("i=" + i);
           }
        }
    }

## 5. 枚举类实现接口 ##

> **（1）使用 enum 关键字后，就不能再继承其它类了，因为 enum 类会隐式继承 Enum，而 Java 是单继承机制。**  
> （**2）枚举类和普通类一样，可以实现接口，形式： enum 类名 implements 接口 1，接口 2 \{\} 。**

# 总结 #

*  本文是小白博主在学习B站韩顺平老师的Java网课时整理总结的学习笔记，在这里感谢韩顺平老师的网课，如有有兴趣的小伙伴也可以去看看。
 *  本文详细解释了 枚举类 的概念与使用，并深入讲解了 枚举类 的注意事项和细节，希望小伙伴们看后能有所收获！
 *  最后，如果本文有什么错漏的地方，欢迎大家批评指正！一起加油！！我们下一篇博文见吧！