Java——枚举

一、枚举类的引出

枚举的步骤
构造器私有化
本类内部创建一组对象
对外暴露对象（通过为对象添加public final static修饰符）
可以提供get方法，但是不要提供set方法

---

二、自定义类实现枚举

不需要提供set方法，因为枚举对象值通常只需要读
对枚举对象/属性使用final+static 共同修饰，实现底层的优化
枚举对象名通常使用全部大写，常量的命名规范
枚举对象根据需要，也可以有多个属性

package com.ylxstudy.enum_;

/**
 * @author 杨乐昕
 * @version 1.0
 */
public class Enumeration02 {
    public static void main(String[] args) {
        //在没有重写toString方法的前提下，打印对象名之后，输出的是
        //全类名（包名+类名）+@+哈希值的十六进制
        //重写toString方法之后，输出的是重写之后的规则内容
        System.out.println(Season2.SPRING);
        System.out.println(Season2.AUTUMN);
    }
}

class Season2{
    private String name ;
    private String desc;//描述

//定义四个对象固定
//枚举的对象名通常使用全部大写，常量的命名规范
    public final static Season2 SPRING = new Season2("春天","温暖");
    public final static Season2 WINTER = new Season2("冬天","寒冷");
    public final static Season2 SUMMER = new Season2("夏天","炎热");
    public final static Season2 AUTUMN = new Season2("秋天","凉爽");

//1、构造器私有化 目的防止 直接new
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 "Season2{" +
            "name='" + name + '\'' +
            ", desc='" + desc + '\'' +
            '}';
}

}

---

三、使用Java的enum关键字实现枚举

使用关键字enum 实现枚举

1. 使用关键字 enum 替代 class

2. public final static Season3 SPRING = new Season3(“春天”,“温暖”);
   public final static Season3 WINTER = new Season3(“冬天”,“寒冷”);
   public final static Season3 SUMMER = new Season3(“夏天”,“炎热”);
   public final static Season3 AUTUMN = new Season3(“秋天”,“凉爽”);
   直接使用
   SPRING(“春天”,“温暖”),WINTER(“冬天”,“寒冷”),SUMMER(“夏天”,“炎热”),AUTUMN(“秋天”,“凉爽”);
   替代
   3.如果使用多个常量对象，使用,号隔开
   4.如果使用enum来实现枚举，要求将定义常量对象，写在前面（属性写在常量对象后面）

   package com.ylxstudy.enum_;
   
   /**
    * @author 杨乐昕
    * @version 1.0
    */
   public class Enumeration03 {
       public static void main(String[] args) {
           System.out.println(Season3.SPRING);
           System.out.println(Season3.AUTUMN);
       }
   }
   
   enum  Season3{
       //定义四个对象固定
       //枚举的对象名通常使用全部大写，常量的命名规范
   //    public final static Season3 SPRING = new Season3("春天","温暖");
   //    public final static Season3 WINTER = new Season3("冬天","寒冷");
   //    public final static Season3 SUMMER = new Season3("夏天","炎热");
   //    public final static Season3 AUTUMN = new Season3("秋天","凉爽");
   //    ============================================================================================
   //    使用关键字enum 实现枚举
   //    1.使用关键字 enum 替代 class
   //    2.public final static Season3 SPRING = new Season3("春天","温暖");
   //      public final static Season3 WINTER = new Season3("冬天","寒冷");
       public final static Season3 SUMMER = new Season3("夏天","炎热");
       public final static Season3 AUTUMN = new Season3("秋天","凉爽");
   //      直接使用
   //      SPRING("春天","温暖"),WINTER("冬天","寒冷"),SUMMER("夏天","炎热"),AUTUMN("秋天","凉爽");
   //      替代
   //    3.如果使用多个常量对象，使用,号隔开
   //    4.如果使用enum来实现枚举，要求将定义常量对象，写在前面（属性写在常量对象后面）
   //    =========================================================================================
       SPRING("春天","温暖"),WINTER("冬天","寒冷"),SUMMER("夏天","炎热"),AUTUMN("秋天","凉爽");
       private String name ;
       private String desc;//描述
       private Season3(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 "Season2{" +
                   "name='" + name + '\'' +
                   ", desc='" + desc + '\'' +
                   '}';
       }
   }
   

---

四、enum关键字实现枚举注意事项

1. 当我们使用enum关键字开发一个枚举类时，默认会继承Enum类，而且是一个final类

2. 如果使用无参构造器，创建枚举对象，则实参列表和小括号可以省略
3. 枚举对象要放在枚举类的行首

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QfCtRmME-1658231335385)(leanote://file/getImage?fileId=62d503c9437d31283e000001)]

---

枚举练习

enum Gender{
    BOY,GIRL;
}

这样写是正确的，
上面的枚举类没有属性，没有有参构造器，则默认使用无参构造器
枚举对象就不用加小括号

enum Gender2{
    BOY,GIRL;
}
Gender2 boy = Gender2.BOY;
Gender2 boy2 = Gender2.BOY;
System.out.println(boy);
System.out.println(boy2 == boy);

System.out.println(boy);输出对象名，是调用toString方法
在这句话中输出的boy本质调用Gender2的父类Enum的toString()
因为在Gender2中没有重写父类的toString方法，
所有向上找到了父类的toString方法
父类的toString方法

public String toString(){
    return name;
}

name 中就是代表的是枚举对象的对象名
这是父类Enum决定的

---

五、 Enum类的相关方法

当我们使用enum关键字的时候，
会隐式的继承Enum类，这样我们就可以使用Enum类的相关方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ONwrvNJj-1658231335386)(leanote://file/getImage?fileId=62d50bd7437d31283e000002)]

增强for循环的写法

每一次循环，把num 赋值给 i ,直至num遍历完，退出for循环

    System.out.println("=======普通far循环=======");
    int[] num ={1,2,9};
    for (int i = 0; i < num.length; i++) {
        System.out.println("i = " + i);
    }
    System.out.println("=======增强far循环=======");
    for(int i : num){
        System.out.println("i = " + i );
    }

---

package com.ylxstudy.enum_;

/**
 * @author 杨乐昕
 * @version 1.0
 * 演示Enum方法的各种使用
 */
public class EnumMethod {
    public static void main(String[] args) {
//        System.out.println(Season3.AUTUMN.name());
        Season3 autumn = Season3.AUTUMN;//地址拷贝,和上面的写法是一样的
//        1.name方法
        System.out.println(autumn.name());
//        2.ordinal方法
//        输出该枚举对象的次序/编号，从0 开始编号
//        autumn的次序排在第四个，所以输出是3
        System.out.println(autumn.ordinal());

//        3.value()方法
//        只有从反编译才能看到value()方法，返回Season3[]数组，含有定义的所有枚举对象
        Season3[] values = Season3.values();
        for(Season3 season3 : values){
//            输出season3的所有枚举对象，又因为Season3这个枚举类重写了父类Object的
//            toString方法
//            所以输出
//            Season2{name='春天', desc='温暖'}
//            Season2{name='冬天', desc='寒冷'}
//            Season2{name='夏天', desc='炎热'}
//            Season2{name='秋天', desc='凉爽'}
            System.out.println(season3);
        }
//        4.valueOf()方法
//        将小括号内的字符串转化为 枚举对象 ，要求字符串必须是已经存在的枚举对象（常量），否则报错
        /*执行流程
        * 1. 根据你输入的”AUTUMN“到Season3的枚举对象查找
        * 2. 如果找到了，就返回，如果没有找到就报错
        * 3. autumn = autumn1
        * */
        Season3 autumn1 = Season3.valueOf("AUTUMN");
        System.out.println(autumn == autumn1 );

    /*5.compareTo()方法
    * 第一个枚举对象.compareTo(第二个枚举对象)
    * 根据 第一个枚举对象的编号 - 第二个枚举对象的编号 = 输出的值
    * AUTUMN编号为3  WINTER编号为1 输出结果为 2
    * */
    System.out.println(Season3.AUTUMN.compareTo(Season3.WINTER));

//        System.out.println("=======普通far循环=======");
//        int[] num ={1,2,9};
//        for (int i = 0; i < num.length; i++) {
//            System.out.println("i = " + i);
//        }
//        System.out.println("=======增强far循环=======");
//        for(int i : num){
//            System.out.println("i = " + i );
//        }
    }
}