Java枚举详解

一、什么是枚举类型

枚举类型是一种特殊的数据类型，用于定义一组固定的命名常量。枚举类型提供了一种更强大、更安全和更易读的方式来表示一组相关的常量。

在Java中，枚举类型是通过使用enum关键字来定义的。枚举类型可以包含一个或多个枚举常量，每个常量都是枚举类型的实例。枚举常量是在枚举类型中预先定义的，它们是唯一的、已命名的对象。

在Java中，枚举类型是一组固定常量值的集合，每个常量值代表一个特定的数据类型。枚举在Java中被视为数据类型，你可以使用它们来创建枚举类型的变量、数组、参数等。

二、枚举的引入

要求创建一个季节（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）：枚举是一组常量的集合；它是一种特殊的类，里面只包含一组有限的特殊的不能修改的对象。

三、枚举的基本用法

使用 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 类中的对象变成了固定的对象，这样便能满足我们一开始提出的要求了。
对比图如下：

四、枚举的注意事项和细节

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

（6）使用 enum 关键字后，就不能再继承其它类了，因为 enum 类会隐式继承 Enum，而 Java 是单继承机制。

五、枚举类的常用方法

以下是枚举类型常用的方法以及它们的用途：

代码演示：

public class EnumMethod {
    public static void main(String[] args) {

        //使用Season 枚举类，来演示各种方法
        Season autumn = Season.AUTUMN;

        //输出枚举对象的名字  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);
       }
    }
}