Java-枚举

枚举

问题引出

package com.pero.enum_;

/**
 * 枚举和注解
 *
 * @version 1.0
 * @author Pero
 */

public class Enumeration01 {
    public static void main(String[] args) {
        Season season1 = new Season("春天", "温暖的");
        Season season2 = new Season("夏天", "炎热的");
        Season season3 = new Season("秋天", "凉爽的");
        Season season4 = new Season("冬天", "寒冷的");
        //因为对季节而言，对象是固定的，不会有更多
        Season otherSeason = new Season("其他", "其他的");
        //按照当前设计，不能体现对象固定的特点
    }
}

class Season{

    //属性
    private String name;
    private String desc;

    //构造器
    public Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }


    //getter和setter
    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;
    }
}

解决方案-枚举

1）枚举是一组常量的集合；

2）枚举属于一种特殊的类，里面包含一组有限的特定的对象。

package com.pero.enum_;

/**
 * 枚举和注解
 *
 * @version 1.0
 * @author Pero
 */

public class Enumeration01 {
    public static void main(String[] args) {
//        Season spring = new Season("春天", "温暖的");
//        Season summer = new Season("夏天", "炎热的");
//        Season autumn = new Season("秋天", "凉爽的");
//        Season winter = new Season("冬天", "寒冷的");
//        //因为对季节而言，对象是固定的，不会有更多
//        Season otherSeason = new Season("其他", "其他的");
//        //按照当前设计，不能体现对象固定的特点

        //直接调用枚举类中的对象
        System.out.println(Season.SPRING);
        System.out.println(Season.SUMMER);
        System.out.println(Season.AUTUMN);
        System.out.println(Season.WINTER);
    }
}

class Season{

    //属性
    private String name;
    private String desc;

    //3.在类内部创建固定的对象（public 意味着外部可以访问，static 意味着不用创建对象直接调用）
    //4.可以再加入final修饰符
    public static final Season SPRING = new Season("春天","温暖的");
    public static final Season SUMMER = new Season("夏天","炎热的");
    public static final Season AUTUMN = new Season("秋天","凉爽的");
    public static final Season WINTER = new Season("冬天","寒冷的");

    //构造器
    private Season(String name, String desc) {  //1.私有化构造器，防止其他类创建对象
        this.name = name;
        this.desc = desc;
    }


    //getter和setter
    public String getName() {
        return name;
    }

    public void setName(String name) {  //2.去掉set相关方法，防止属性被修改
        this.name = name;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {  //2.去掉set相关方法
        this.desc = desc;
    }
}

枚举类的特点

①不需要提供set方法，对象通常为只读；

②对枚举对象/属性使用final+static共同修饰，实现底层优化；

③枚举对象名称通常使用全部大写，按照常量命名的规范；

④枚举对象根据需要可以有多个属性。

enum关键字实现枚举

package com.pero.enum_;

/**
 * 枚举和注解
 *
 * @version 1.0
 * @author Pero
 */

public class Enumeration01 {
    public static void main(String[] args) {
        //直接调用枚举类中的对象
        System.out.println(Season.SPRING);
        System.out.println(Season.SUMMER);
        System.out.println(Season.AUTUMN);
        System.out.println(Season.WINTER);
    }
}

/*class*/enum Season{  //①将class关键字改为enum

    //属性
//    private String name;
//    private String desc;
    
    //创建枚举对象
//    public static final Season SPRING = new Season("春天","温暖的");
//    public static final Season SUMMER = new Season("夏天","炎热的");
//    public static final Season AUTUMN = new Season("秋天","凉爽的");
//    public static final Season WINTER = new Season("冬天","寒冷的");
    
    //②public static final Season SPRING = new Season("春天","温暖的");
    //  以SPRING("春天","温暖的")代替;  模板为：常量对象名（实参列表）;
    //③如果有多个常量（对象），使用 , 号间隔
    //  常量对象名1（实参列表）,常量对象名1（实参列表）... ;
    //④如果使用enum来实现枚举，要求定义的常量对象写在最前面

    SPRING("春天","温暖的"),SUMMER("夏天","炎热的"),
    AUTUMN("秋天","凉爽的"),WINTER("冬天","寒冷的");
    
    private String name;
    private String desc;
    

    //构造器
    private Season(String name, String desc) {  
        this.name = name;
        this.desc = desc;
    }


    //getter和setter
    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;
    }
}

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

1）当我们使用enum关键字开发一个枚举类时，默认会继承Enum类；

2）传统的public static final Season SPRING = new Season("春天","温暖的");

      简化成SPRING("春天","温暖的");这里必须明确调用的是哪个构造器；

3）如果使用无参构造器创建枚举对象，则实参列表和小括号都可以省略；

4）当有多个枚举对象时，使用  ,  号间隔，最后一个用分号结尾；

5）枚举对象必须放在枚举类的首行。

enum常用方法

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

★查看Enum类的源码

public abstract class Enum<Extends Enum <E>> implements Comparable <E>,Serializable{ }

常用方法：valueOf、toString、equals、hashCode、getDeclaringClass、name、ordinal、compareTo、clone

package com.pero.enum_;

/**
 * 演示Enum类的各种方法的使用
 *
 * @author Pero
 * @version 1.3
 */
public class EnumMethod {
    public static void main(String[] args) {
        //1.使用Season 枚举类，来演示各种方法
        Season autumn = Season.AUTUMN;
        //2使用.name()方法得到当前枚举常量的名称，建议优先使用toString
        System.out.println(autumn.name());  //输出AUTUMN

        //3使用.ordinal()方法输出当前枚举常量对象的次序/编号，从0开始
        System.out.println(autumn.ordinal());  //输出2

        //从反编译可以看出 values方法，返回Season[]
        //含有定义的所有枚举对象
        Season[] values = Season.values();

//        //普通for循环
//        for (int i = 0; i < Season.values().length; i++) {
//            System.out.println(Season.values()[i]);
//        }
//
        //增强for循环
        for (Season season : values){
            System.out.println(season);  //输出SPRING、SUMMER 、AUTUMN 、WINTER
        }

//        double[] numbers = {1.0, 2.0, 9.0};
//        //普通for循环
//        for (int i = 0; i < numbers.length; i++) {
//            System.out.println(numbers[i]);
//        }
//
//        //增强for循环
//        for (double j :numbers){
//            System.out.println(j);
//            //依次从numbers数组中取出数据，赋值给j，如果取出完毕，则退出for循环
//        }

        //4.使用valueOf()方法，将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常
        //执行流程
        //①根据输入的"AUTUMN"到Season的枚举类对象中查找
        //②如果找到了就返回，如果没有找到则报错,找不到输入的对象信息
        Season autumn1 = Season.valueOf("AUTUMN");
        System.out.println(autumn1);  //输出AUTUMN
        System.out.println(autumn == autumn1);  //输出true

        //5.使用compareTo方法，比较两个枚举常量，比较的是编号
        //Season.WINTER的编号【3】-Season.SUMMER编号【1】；
        System.out.println(Season.WINTER.compareTo(Season.SUMMER));  //输出2
    }
}

Enum课堂练习

package com.pero.enum_;

/**
 * 课堂练习
 *
 * @author Pero
 * @version 1.4
 */
public class EnumExercise02 {
    public static void main(String[] args) {
        System.out.println("===所有星期的信息如下===");
        Week[] weeks = Week.values();
        for (Week week : weeks){
            System.out.println(week);  //输出同toString方法的返回值，需要重写toString方法
        }
    }
}

enum Week{
    MONDAY("星期一"),TUESDAY("星期二"),WEDNESDAY("星期三"),
    THURSDAY("星期四"),FRIDAY("星期五"),SATURDAY("星期六"),SUNDAY("星期日");

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

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return name;
    }
}

Enum使用细节

1）使用enum关键字后，就不能在继承其他类了，因为enum会隐式继承Enum类，java是单继承机制；

2）枚举类和普通类一样，可以实现接口，例如：

      enum 类名 implements 接口1，接口2 { } 

package com.pero.enum_;

/**
 * enum的使用细节
 *
 * @author Pero
 * @version 1.0
 */
public class EnumDetail {
    public static void main(String[] args) {
        Person person = Person.CLASSICMUISC;
        person.play();
        System.out.println(person);
        System.out.println(person.toString());
        System.out.println(person.name());
    }
}

interface IA{
    void play();
}

//1.使用enum关键字后，就不能在继承其他类了，因为enum会隐式继承Enum类，java是单继承机制
enum Person /*extends Animal*/implements IA{
    CLASSICMUISC("美妙的音乐");  //这是一个对象

    private String name;

    private Person(String name){
        this.name = name;
    }
//2.枚举类和普通类一样，可以实现接口
    public void play(){
        System.out.println("枚举类实现接口");
    }

    @Override
    public String toString() {
        return name;
    }
}

class Animal{ }