Java基础(十二)：枚举类

Java基础系列文章

Java基础(一)：语言概述

Java基础(二)：原码、反码、补码及进制之间的运算

Java基础(三)：数据类型与进制

Java基础(四)：逻辑运算符和位运算符

Java基础(六)：数组

Java基础(七)：面向对象编程

Java基础(八)：封装、继承、多态性

Java基础(九)：Object 类的使用

Java基础(十)：关键字static、代码块、关键字final

Java基础(十一)：抽象类、接口、内部类

Java基础(十二)：枚举类

---

---

一、概述

• 枚举类型本质上也是一种类，只不过是这个类的对象是有限的、固定的几个，不能让用户随意创建
• 枚举类的例子举不胜举：
  • 星期：Monday(星期一)…Sunday(星期天)
  • 性别：Man(男)、Woman(女)
  • 月份：January(1月)…December(12月)
  • 季节：Spring(春节)…Winter(冬天)
• 若枚举只有一个对象, 则可以作为一种单例模式的实现方式
• 枚举类的实现：
  • 在JDK5.0 之前，需要程序员自定义枚举类型
  • 在JDK5.0 之后，Java支持enum关键字来快速定义枚举类型

二、定义枚举类（JDK5.0 之前）

• 私有化类的构造器，保证不能在类的外部创建其对象
• 在类的内部创建枚举类的实例。声明为：public static final ，对外暴露这些常量对象
• 对象如果有实例变量，应该声明为private final（建议，不是必须），并在构造器中初始化

示例代码：

public class SeasonTest{
    public static void main(String[] args) {
        System.out.println(Season.AUTUMN);
    }
}
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 + '\'' +
                '}';
    }
}

三、定义枚举类（JDK5.0 之后）

enum关键字声明枚举

【修饰符】 enum 枚举类名{
    常量对象列表
}

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

enum方式定义的要求和特点

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

举例1：

• 两个参数，手动添加两个参数的构造方法

public enum SeasonEnum {
    SPRING("春天","春风又绿江南岸"),
    SUMMER("夏天","映日荷花别样红"),
    AUTUMN("秋天","秋水共长天一色"),
    WINTER("冬天","窗含西岭千秋雪");

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

举例2：

• 一个参数，手动添加一个参数的构造方法
• 构造函数的private可以省略

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;
    }
}

举例3：

• 没有参数，也不需要添加构造方法

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

public class TestEnum {
	public static void main(String[] args) {
		Season spring = Season.SPRING;
		System.out.println(spring);
	}
}

举例4：

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中常用方法

• String toString(): 默认返回的是常量名（对象名），可以继续手动重写该方法！
  • 默认就是父类Enum的同String，返回对象名

public abstract class Enum<E extends Enum<E>>
        implements Constable, Comparable<E>, Serializable {

    private final String name;
...
    protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }
    
    public String toString() {
        return name;
    }
    ...
}

• static 枚举类型[] values():返回枚举类型的对象数组
  • 该方法可以很方便地遍历所有的枚举值，是一个静态方法
• static 枚举类型 valueOf(String name)：可以把一个字符串转为对应的枚举类对象
  • 要求字符串必须是枚举类对象的“名字”
  • 如不是，会有运行时异常：IllegalArgumentException
• String name():得到当前枚举常量的名称
  • 建议优先使用toString()
• int ordinal():返回当前枚举常量的次序号，默认从0开始

举例：

public class TestEnumMethod {
    public static void main(String[] args) {
        //values()
        Week[] values = Week.values();
        for (int i = 0; i < values.length; i++) {
            //ordinal()、name()
            System.out.println((values[i].ordinal()+1) + "->" + values[i].name());
        }
        System.out.println("------------------------");

        Scanner input = new Scanner(System.in);
        System.out.print("请输入星期值：");
        int weekValue = input.nextInt();
        Week week = values[weekValue-1];
        //toString()
        System.out.println(week);

        System.out.print("请输入星期名：");
        String weekName = input.next();
        //valueOf()
        week = Week.valueOf(weekName);
        System.out.println(week);

        input.close();
    }
}

五、实现接口的枚举类

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

语法：

//1、枚举类可以像普通的类一样，实现接口，并且可以多个，但要求必须实现里面所有的抽象方法！
enum A implements 接口1，接口2{
	//抽象方法的实现
}

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

举例1：

• 统一实现方法

interface Info{
    void show();
}

//jdk5.0中使用enum关键字定义枚举类
enum Season1 implements Info{
    //1. 必须在枚举类的开头声明多个对象。对象之间使用,隔开
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","白雪皑皑");

    //2. 声明当前类的对象的实例变量,使用private final修饰
    private final String seasonName;//季节的名称
    private final String seasonDesc;//季节的描述

    //3. 私有化类的构造器
    private Season1(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //4. 提供实例变量的get方法
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    @Override
    public void show() {
        System.out.println("这是一个季节");
    }
}

举例2：

• 分别实现方法

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;
	}
}