自定义枚举

1. 枚举对应英文（enumeration，简写enum）
2. 枚举是一种常量的集合
3. 枚举是一种特殊的类，里面包含一组有限的特定的对象

场景：创建季节对象的时候，一年只有四个季节（春夏秋冬），这四个季节不能会有其它季节；如果让用户去创建季节，那么肯定会乱了套，所以为了避免这种情况，我们需要通过枚举来创建四个季节的对象，让用户直接使用就可以了

/**
 * @author mao-design
 * @version 1.0
 */
public class Index01 {
    public static void main(String[] args) {
// 	    因为Season类中创建的对象是静态的，所以可以直接调用
        System.out.println(Season.A);
        System.out.println(Season.B);
        System.out.println(Season.C);
        System.out.println(Season.D);
        /*
        * 运行结果：
        * 季节：春天  气候：温暖
        * 季节：夏天  气候：炎热
        * 季节：秋天  气候：凉爽
        * 季节：冬天  气候：寒冷
        * */
    }
}

// 定义枚举类
/*
* 构造器私有化，防止外部其它类创建对象
* 去掉setXxx方法，防止属性被修改
* 在Season类内直接创建固定对象
* 加入 final 修饰符
* */
class Season {
//	  枚举对象根据需要，可以有多个属性
    String season;
    String climate;

//    枚举的方法名的命名规则是单词的所有字母大写
//    对外暴露的对象可以通过public static final来修饰
//    公开静态不能修改的对象
    public static final Season A = new Season("春天", "温暖");
    public static final Season B = new Season("夏天", "炎热");
    public static final Season C = new Season("秋天", "凉爽");
    public static final Season D = new Season("冬天", "寒冷");

    public String toString() {
        return "季节：" + season + "  气候：" + climate;
    }
}

总结：

1. 构造器私有化
2. 本类中创建一组对象
3. 对暴露的对象可以通过public static final来修饰
4. 可以提供 get 方法，但是不要 set 方法

enum枚举

1. 当我们使用 enum 关键字一个枚举类的时候，默认会继承 Enum 类
2. 如果我们创建的是无参构造器，那么我们调用无参构造器的时候括号里面可以不用写任何实参，甚至可以不用写括号
3. 在enum枚举中，枚举对象要写在最前面，而自定义枚举则不用
4. 如果有多个对象，那么对象于对象之间要使用,隔开，到最后一个对象的时候使用;结尾
5. 在 enum 枚举中的 toString 返回的是调用成员的名字

/**
 * @author mao-design
 * @version 1.0
 */
public class Index02 {
    public static void main(String[] args) {
//        在enum枚举类中，如果没有重写toString方法，那么返回的就是调用对象的名字
        System.out.println(A1.A); // 如果没有重写toString，那么这里就输出的则是A
        System.out.println(A1.B);
        System.out.println(A1.C);
        System.out.println(A1.D);
        /*
        * 运行结果：
        * 季节：春天  气候：温暖
        * 季节：夏天  气候：炎热
        * 季节：秋天  气候：凉爽
        * 季节：冬天  气候：寒冷
        * */
    }
}
enum A1 {
//    在enum枚举中 A("春天", "温暖") 等于 public static final A1 A = new A1("春天", "温暖")
//    如果有多个对象，那么对象于对象之间要使用 , 隔开，到最后一个对象的时候使用 ; 结尾
//    在enum枚举中，对象要写在最前面，而其定义枚举则不用
    A("春天", "温暖"),
    B("夏天", "炎热"),
    C("秋天", "凉爽"),
    D("冬天", "寒冷"),
    E();
    String season;
    String climate;
    private A1(String season, String climate) {
        this.season = season;
        this.climate = climate;
    }
    private A1() {
        
    }
    public String toString() {
        return "季节：" + season + "  气候：" + climate;
    }
}

Enum 常用方法

public class Enum01 {
    public static void main(String[] args) {
        Enum02 a = Enum02.A;
        Enum02 b = Enum02.B;
        A a1 = A.A1;

        /*
        * toString：枚举中的toString是返回当前对象的名字
        * 当然，你也可以重写toString方法来返回你想要的内容
        * */
        System.out.println(a1.A1);    // 输出 A1

        /*
        * name：显示调用对象的名字
        * */
        System.out.println(a.name());

        /*
        * ordinal：显示对象的编号（第一个对象的编号为0，后面接着的对象编号以此类推）
        * */
        System.out.println(a.ordinal());    // 0
        System.out.println(b.ordinal());    // 1

        /*
        * values：返回调用的枚举类数组，当前 Enum02.values() 返回的是 Enum02[],
        * Enum02[0] 就表示的是该枚举类中第一个对象
        * */
        Enum02[] v = Enum02.values();
        System.out.println(v[1]);		// 输出 World
        for (int i = 0; i < v.length; i++) {
            System.out.println(v[i]);
        }
//       这里的v表示的Enum02枚举类数组
//       也就是说每次循环都会将Enum02枚举类数组中的元素（枚举类中所对应的对象）赋值给x
//       直到枚举类中的所有枚举对象都赋值完才会停止
        for (Enum x : v) {
            /*
            * 输出内容之所以不是对象的哈希值，是因为枚举类中重写的有toString方法
            * Hello
            * World
            * */
            System.out.println(x);
        }

        /*
        * valueOf：将字符串转换成枚举对象，前提是该字符串必须是枚举类中的枚举对象名
        * 所以括号内应输入枚举类的枚举对象名
        * valueOf返回的是你所输入的枚举对象内容
        * 如果输入的内容不是枚举类中的枚举对象名，那么该代码就会报错
        * */
        Enum02 enum02 = Enum02.valueOf("A");
        System.out.println("enum02:" + enum02);     // enum02:Hello
        System.out.println(a == enum02);    // true
        
        /*
        * compareTo：比较同一个枚举类中的枚举对象编号
        * 比较方法就是前一个对象编号减去后一个对象编号
        * a.A的编号是0，a.B的编号是1，所以 a.A 小于 a.B
        * */
        System.out.println(a.A.compareTo(a.B));		// -1
    }
}

enum Enum02 {
    /*
    * 枚举对象编号的排序是从左往右，从上往下由小到大依次排列
    * */
//    编号 0
    A("Hello"),
//    编号 1
    B("World");

    private String name;

    private Enum02(String name) {
        this.name = name;
    }


    public String getName() {
        return name;
    }
    public String toString() {
        return name;
    }
}
enum A {
    A1("niah");
    String name;
    A(String name) {

    }
}

枚举细节

1. 因为枚举类会隐式继承Enum类，而Java又是单线程机制，所以枚举类不能继承别的类

2. 枚举类也是一个类，所以可以实现接口

   interface fei {
       public void info();
   }
   
   enum fa implements fei {
       M();
       public void info() {
           System.out.println("Hello,World!");
       }
   }