Java面向对象-枚举类详解

1.什么是枚举类

枚举类就是 对象个数有限且确定的类。
比如：季节类，一共就四个对象 ： 春，夏，秋，冬。 
	* 对象个数有限，可以一一列举出来；
	* 对象一旦被定义，不可进行修改。
【当需要定义一组常量时，强力推荐使用枚举类】

2.自定义实现枚举类

根据枚举类的定义，自定义实现枚举类时需要完成的要求：
1.对象属性 用 private final修饰
2.构造器私有化，private 修饰
3.对象在类中创建完成，public static final 修饰
4.可以存在其他的方法，如 对象属性的getter方法，toString方法等

下面定义了一个枚举类：存在四个季节对象的Season类

public class Season {
    //1.私有化属性
    private final String seasonName;
    private final String seasonDesc;
    //2.私有化构造器
    private Season(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    //3.声明四个对象 春夏秋冬
    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("冬天","白雪皑皑");

    //4.其他方法1： 对象属性的getter方法，此时无setter方法的
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }

    //4.其他方法2： toString()方法
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

测试使用枚举类

public class Application {
    public static void main(String[] args) {
        // 正常使用自定义的枚举类
        Season spring = Season.SPRING;
        System.out.println(spring); // 默认调用toString方法
        System.out.println(spring.getSeasonName()); // 正常调用方法
        System.out.println("=========================");
    }
}

执行结果如下：
Season{seasonName='春天', seasonDesc='春暖花开'}
春天
=========================

3.使用enum关键字定义枚举类

定义的格式要求 ：
    1.使用enum关键字代替class；
    2.类的枚举对象必须在类的最开始定义；
    3.有多个对象时，对象之间用英文的逗号隔开，在最后一个对象的后面用英文分号结束；
    4.声明枚举对象时的格式为  
    		【枚举对象名称1，枚举名称2.。。。】  或
    		【枚举对象名称1(构造方法参数。。。)，枚举名称2(构造方法参数)。。。】
    5.属性仍然用 private final 进行修饰；
    6.构造方法仍然用 private 修饰；
    7.可以写其他的方法：getter、重写toString()等

下面是一个使用enum关键字定义的枚举类

public enum Week {

    // 枚举对象
    MONDAY ("星期一","上一天的语文课"),
    TUESDAY ("星期二","上一天的数学课"),
    WEDNESDAY ("星期三","上一天的英语课"),
    THURSDAY ("星期四","上一天的物理课"),
    FRIDAY ("星期五","上一天的化学课"),
    SATURDAY ("星期六","上一天的生物课"),
    SUNDAY ("星期日","上一天的自习课");

    //声明属性
    private final String weekName;
    private final String weekDesc;
    //构造方法
    Week(String weekName, String weekDesc) {
        this.weekName = weekName;
        this.weekDesc = weekDesc;
    }

    // 其他方法：getter方法，toString()方法等
    public String getWeekName() {
        return weekName;
    }

    public String getWeekDesc() {
        return weekDesc;
    }

    @Override
    public String toString() {
        return "Week{" +
                "weekName='" + weekName + '\'' +
                ", weekDesc='" + weekDesc + '\'' +
                '}';
    }
}

测试使用枚举类

public class Application {
    public static void main(String[] args) {
        // 正常使用枚举类
        System.out.println(Week.SUNDAY);
        System.out.println(Week.SUNDAY.getWeekName());
        System.out.println(Week.SUNDAY.getWeekDesc());
        System.out.println("=========================");
    }
}

执行结果如下：
Week{weekName='星期日', weekDesc='上一天的自习课'}
星期日
上一天的自习课
=========================

4.一个简化版的枚举类

枚举类中可以没有任何的属性，直接声明各个枚举对象。
具体形式如下：

/**
* 直接放上枚举对象的枚举类，
* 十分的简洁明了。
*/
public enum WeekSimple {
    MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUM;
}

5.enum枚举类的父类Enum类的常用方法

1.使用enum定义的枚举类的直接父类是 ： java.lang.Enum;
2.直接继承的父类的常用方法如下：
   values():返回枚举类中的枚举对象的数组，可以方便进行遍历；
   valueOf(String objName):返回枚举类中 与参数objName 名称一致的枚举对象，
                          【注意：参数必须是枚举对象中的其中一个，否则程序会抛出异常】；
    toString() : 直接返回枚举对象的名称；
    ordinal():返回枚举对象在声明时的顺序，且顺序从0开始。
    name():直接返回枚举对象的名称，推荐使用toString()!

方法测试：以第四小结中的简单的枚举类为例

public class Application {
    public static void main(String[] args) {
        // 枚举类的常用方法

        WeekSimple[] values = WeekSimple.values();
        System.out.println(Arrays.toString(values));

        WeekSimple aa = WeekSimple.valueOf("MONDAY");
        System.out.println(aa);

        System.out.println(WeekSimple.MONDAY.toString());

        System.out.println(WeekSimple.MONDAY.ordinal());

        System.out.println(WeekSimple.THURSDAY.name());

    }
}

执行结果
[MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUM]
MONDAY
MONDAY
0
THURSDAY

6.实现接口的枚举类

枚举类也是可以实现接口的，实现方式有两种，分别如下：

6.1 方式一：全局实现

全局实现:就是在枚举类中直接实现，此时所有的枚举对象都拥有相同的方法实现

public enum SeasonWithInterface implements AA {
    Spring,SUMMER,AUTUMN,WINTER;

    /**
     * 全局实现接口的方法
     */
    @Override
    public void sayHello() {
        System.out.println("Hello EveryOne!");
    }
}
// 定义一个接口
interface AA{
    void sayHello();
}

6.2 方式二：对象实现

对象实现：就是在声明对象的时候实现，此时每个对象都单独对接口中的方法进行实现

public enum SeasonWithInterface implements AA {
    SPRING(){
        @Override
        public void sayHello() {
            System.out.println("Hello Spring");
        }
    },
    SUMMER(){
        @Override
        public void sayHello() {
            System.out.println("Hello SUMMER");
        }
    },
    AUTUMN(){
        @Override
        public void sayHello() {
            System.out.println("Hello AUTUMN");
        }
    },
    WINTER(){
        @Override
        public void sayHello() {
            System.out.println("Hello WINTER"); 
        }
    };

   
}
// 定义一个接口
interface AA{
    void sayHello();
}

7.完成

Congratulations!
You are one step closer to sucess!