枚举类概述

枚举是 Java1.5 引入的新特性，通过关键字 enum 来定义枚举类。枚举类是一种特殊类，它和普通类一样可以使用构造器、定义成员变量和方法，也能实现一个或多个接口,但枚举类不能继承其他类。

定义枚举类

枚举类的实现：

  • 在JDK5.0 之前，需要程序员自定义枚举类型。
  • 在JDK5.0 之后，Java支持enum关键字来快速定义枚举类型

JDK5.0 之前

在JDK5.0 之前如何声明枚举类呢？

  • 私有化类的构造器，保证不能在类的外部创建其对象
  • 在类的内部创建枚举类的实例。声明为：public static final对外暴露这些常量对象
  • 对象如果有实例变量，应该声明为private final（建议，不是必须），并在构造器中初始化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Season{
    private final String SEASONNAME; // 季节的名称
    private final String SEASONDESC; // 季节的描述
    
    private Season(String seasonName,String seasonDesc){
        this.SEASONNAME = seasonName;
        this.SEASONDESC = seasonDesc;
    }
    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("冬天", "白雪皑皑");

    @Override
    public String toString() {
        return "Season{" +
                "SEASONNAME='" + SEASONNAME + '\'' +
                ", SEASONDESC='" + SEASONDESC + '\'' +
                '}';
    }
}
class SeasonTest{
    public static void main(String[] args) {
        System.out.println(Season.AUTUMN);
    }
}

JDK5.0 之后

enum关键字声明枚举

1
2
3
4
5
6
7
8
9
【修饰符】 enum 枚举类名{
    常量对象列表
}

【修饰符】 enum 枚举类名{
    常量对象列表;
    
    对象的实例变量列表;
}

举例1：

1
2
3
4
5
package com.atguigu.enumeration;

public enum Week {
    MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY;
}
1
2
3
4
5
6
public class TestEnum {
	public static void main(String[] args) {
		Season spring = Season.SPRING;
		System.out.println(spring);
	}
}

enum方式定义的要求和特点

  • 枚举类的常量对象列表必须在枚举类的首行，因为是常量，所以建议大写。
  • 列出的实例系统会自动添加 public static final 修饰。
  • 如果常量对象列表后面没有其他代码，那么“；”可以省略，否则不可以省略“；”。
  • 编译器给枚举类默认提供的是 private 的无参构造，如果枚举类需要的是无参构造，就不需要声明，写常量对象列表时也不用加参数
  • 如果枚举类需要的是有参构造，需要手动定义，有参构造的 private 可以省略，调用有参构造的方法就是在常量对象名后面加(实参列表)就可以。
  • 枚举类默认继承的是java.lang.Enum类，因此不能再继承其他的类型。
  • JDK5.0 之后 switch，提供支持枚举类型，case 后面可以写枚举常量名，无需添加枚举类作为限定。

举例2：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public enum SeasonEnum {
    SPRING("春天","春风又绿江南岸"),
    SUMMER("夏天","映日荷花别样红"),
    AUTUMN("秋天","秋水共长天一色"),
    WINTER("冬天","窗含西岭千秋雪");

    private final String seasonName;
    private final String seasonDesc;
    
    private SeasonEnum(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
}

举例3：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.atguigu.enumeration;

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

    private final String description;

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

    @Override
    public String toString() {
        return super.toString() +":"+ description;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.atguigu.enumeration;

public class TestWeek {
    public static void main(String[] args) {
        Week week = Week.MONDAY;
        System.out.println(week);

        switch (week){
            case MONDAY:
                System.out.println("怀念周末，困意很浓");
                break;
            case TUESDAY:
                System.out.println("进入学习状态");
                break;
            case WEDNESDAY:
                System.out.println("死撑");
                break;
            case THURSDAY:
                System.out.println("小放松");
                break;
            case FRIDAY:
                System.out.println("又信心满满");
                break;
            case SATURDAY:
                System.out.println("开始盼周末，无心学习");
                break;
            case SUNDAY:
                System.out.println("一觉到下午");break;
        }
    }
}

开发中，当需要定义一组常量时，强烈建议使用枚举类。

enum的常用方法

在 Java 中，enum 类继承自 java.lang.Enum，因此具有一些常用方法。下面是一些常用的枚举方法以及相应的示例代码：

  • name()
    • 返回枚举常量的名称，即声明时的字符串。
  • ordinal()
    • 返回枚举常量的顺序，从 0 开始计数。
  • values()
    • 返回包含所有枚举常量的数组。
  • valueOf(String name)
    • 根据给定的字符串返回枚举常量。如果不存在对应的枚举常量则抛出 IllegalArgumentException。
  • compareTo(Enum e)
    • 按枚举常量的声明顺序进行比较。
  • toString()
    • 返回枚举常量的名称，与 name() 类似，但可以被重写
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package com.base10._enum;

public class enumTest {
    public static void main(String[] args) {
        // 使用 Day 枚举类
        Day today = Day.MONDAY;
        System.out.println("Today is: " + today.name()); // 输出：Today is: MONDAY

        // 使用 ordinal() 方法
        System.out.println("Ordinal of " + today + " is: " + today.ordinal()); // 输出：Ordinal of MONDAY is: 1

        // 使用 values() 方法遍历枚举
        for (Day day : Day.values()) {
            System.out.println(day);
        }

        // 使用 valueOf() 方法
        Day anotherDay = Day.valueOf("FRIDAY");
        System.out.println("Another day: " + anotherDay); // 输出：Another day: FRIDAY

        // 使用 compareTo() 方法
        Day day1 = Day.SUNDAY;
        Day day2 = Day.WEDNESDAY;
        System.out.println(day1.compareTo(day2)); // 输出：-3 （SUNDAY 在 WEDNESDAY 之前）

        // 使用 toString() 方法（默认情况下）
        System.out.println(today.toString()); // 输出：MONDAY
    }
}


enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY;
}

实现接口的枚举类

  • 和普通 Java 类一样，枚举类可以实现一个或多个接口
  • 若每个枚举值在调用实现的接口方法呈现相同的行为方式，则只要统一实现该方法即可。
  • 若需要每个枚举值在调用实现的接口方法呈现出不同的行为方式，则可以让每个枚举值分别来实现该方法

语法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//1、枚举类可以像普通的类一样，实现接口，并且可以多个，但要求必须实现里面所有的抽象方法！
enum A implements 接口1，接口2{
	//抽象方法的实现
}

//2、如果枚举类的常量可以继续重写抽象方法!
enum A implements 接口1，接口2{
    常量名1(参数){
        //抽象方法的实现或重写
    },
    常量名2(参数){
        //抽象方法的实现或重写
    },
    //...
}

举例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
interface Info{
	void show();
}

//使用enum关键字定义枚举类
enum Season1 implements Info{
	//1. 创建枚举类中的对象,声明在enum枚举类的首位
	SPRING("春天","春暖花开"){
		public void show(){
			System.out.println("春天在哪里？");
		}
	},
	SUMMER("夏天","夏日炎炎"){
		public void show(){
			System.out.println("宁静的夏天");
		}
	},
	AUTUMN("秋天","秋高气爽"){
		public void show(){
			System.out.println("秋天是用来分手的季节");
		}
	},
	WINTER("冬天","白雪皑皑"){
		public void show(){
			System.out.println("2002年的第一场雪");
		}
	};
	
	//2. 声明每个对象拥有的属性:private final修饰
	private final String SEASON_NAME;
	private final String SEASON_DESC;
	
	//3. 私有化类的构造器
	private Season1(String seasonName,String seasonDesc){
		this.SEASON_NAME = seasonName;
		this.SEASON_DESC = seasonDesc;
	}
	
	public String getSEASON_NAME() {
		return SEASON_NAME;
	}

	public String getSEASON_DESC() {
		return SEASON_DESC;
	}
}