java enum 父类_Java枚举（enum）详解

1. 枚举概述

枚举：列举，一个一个地列出来。

Java枚举：把某个类型的对象，全部列出来。

什么情况下会用到枚举类型？

某些类的对象只有确定的有限个时，可以把这样的类声明为枚举。

例如：

星期：Monday(星期一)......Sunday(星期天)

性别：Male(男)、Female(女)

月份：January(1月)......December(12月)

季节：Spring(春天)......Winter(冬天)

枚举是一种特殊的类，特殊在它的对象是有限的几个常量对象。它既是一种类(class)类型却又比类类型多了些特殊的约束，枚举的本质是一种受限制的类。

当需要定义一组常量时，可以使用枚举。

2. 枚举类型的定义

枚举是JDK1.5新增的引用数据类型。

枚举的对象的属性不应允许被改动，所以应该使用 private final 修饰

属性应该在构造器中为其赋值

若枚举显式的定义了带参数的构造器，则在列出枚举值时也必须对应地传入参数

枚举的实现：

jdk1.5之前，自定义枚举类

jdk1.5，可以使用 enum 关键字定义枚举

2.1 自定义枚举类

要求：

私有化类的构造器，保证不能在类的外部创建其对象

在类的内部创建枚举类的实例，并用声明为 public static final 的变量来引用

对象如果有实例变量，应该声明为private final，并在构造器中初始化

class Season {

//声明Season对象的属性：使用 private final 修饰

private final String seasonName;

private final String seasonDesc;

//私有化Season类的构造器，并给对象属性赋值

private Season(String seasonName, String seasonDesc) {

this.seasonName = seasonName;

this.seasonDesc = seasonDesc;

}

//在类的内部创建当前枚举类的对象，变量用 public static final 修饰

//public：外部可以使用枚举类的实例

//static：外部可以使用“类名.对象名”调用

//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("冬天", "白雪皑皑");

//其他需求

//获取枚举类的对象的属性

public String getSeasonName() {

return seasonName;

}

public String getSeasonDesc() {

return seasonDesc;

}

//提供toString()

@Override

public String toString() {

return "Season{" +

"seasonName='" + seasonName + '\'' +

", seasonDesc='" + seasonDesc + '\'' +

'}';

}

}

public class SeasonTest {

public static void main(String[] args) {

Season spring = Season.SPRING;

System.out.println(spring.getSeasonName());

System.out.println(spring);

}

}

2.2 使用enum定义枚举

jdk1.5之前，枚举的定义格式太繁琐，存在很多重复代码

使用 enum 关键字简化枚举的定义

声明格式：

[修饰符] enmu 枚举名{

//实例列表

//其他成员列表

}

枚举的所有实例必须在其他成员的前面显式列出(多个实例之间 , 分隔 ; 结尾，只存在实例列表时，最后一个实例后面的 ; 可省略，存在其他成员时，不能省略)，它们实际上都是 public static final 修饰的常量对象，不用自己添加修饰符，填上反而会报错。

枚举的所有构造器只能使用 private 访问控制符，并且是隐式私有的。

switch 表达式的case 子句可以直接使用 Enum定义的枚举的对象的名字。

如果枚举中只有一个对象，则可以作为单例模式的一种实现方式。

//RED、GREEN、BLUE不是枚举Color的属性，而是它的对象

enum Color {

//只有对象列表，可省略最后一个对象后的;

//对象后面没有“(参数列表)”就是调用无参构造

RED, GREEN, BLUE

}

//SPRING、SUMMER、AUTUMN、WINTER就是枚举Season的对象

enum Season {

//对象列表必须写在类的前面，多个对象之间用,隔开，末尾对象;结束

//对象后面有“(参数列表)”就是调用有参构造

SPRING("春天", "春暖花开"),

SUMMER("夏天", "烈日炎炎"),

AUTUMN("秋天", "秋高气爽"),

WINTER("冬天", "白雪皑皑");

//声明Season对象的属性：使用 private final 修饰

private final String seasonDesc;

private final String seasonName;

//私有化Season类的构造器，并给对象属性赋值

private Season(String seasonName, String seasonDesc) {

this.seasonName = seasonName;

this.seasonDesc = seasonDesc;

}

//其他需求

//获取枚举的对象的属性

public String getSeasonName() {

return seasonName;

}

public String getSeasonDesc() {

return seasonDesc;

}

//一般不用重写toString

}

public class SeasonTest {

public static void main(String[] args) {

Color blue = Color.BLUE;

System.out.println(blue); //BLUE

System.out.println(Color.class.getSuperclass()); //class java.lang.Enum

Season summer = Season.SUMMER;

System.out.println(summer); //SUMMER

System.out.println(Season.class.getSuperclass()); //class java.lang.Enum

Season s = Season.SPRING;

switch(s) {

case SPRING:

System.out.println("春暖花开");

break;

case SUMMER:

System.out.println("烈日炎炎");

break;

case AUTUMN:

System.out.println("秋高气爽");

break;

case WINTER:

System.out.println("白雪皑皑");

break;

}

}

}

3. 枚举的隐含直接父类：Enum类

枚举不能继承其他类型，因为枚举类型有一个隐含的直接父类 java.lang.Enum ：它是所有枚举的父类。

public abstract class Enum>

implements Comparable, Serializable {...}

Enum类中有一个唯一的构造器：protected Enum(String name, int ordinal)

这个构造器不是程序员手动调用的，是编译器自动调用，在所有枚举类型的构造器的首行，并且自动传入name和ordinal的值。

name：就是枚举对象名称

ordinal：就是枚举对象的序号(在枚举声明中的位置)，其中初始常量序号为0

3.1 Enum类的主要方法

除了toString方法，都是final修饰的方法，因此都不能重写。

toString()：返回此枚举常量的名称，与其在枚举声明中的声明完全相同

String name()：返回此枚举常量的名称，与其在枚举声明中的声明完全相同，一般用toString()

int ordinal()：返回此枚举常量的序号(在枚举声明中的位置)，其中初始常量序号为0

API中没有的方法，是编译器帮我们生成的方法：

values()方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。

valueOf(String str)：根据枚举常量的名称返回对应的枚举对象。要求字符串必须是枚举对象的“名字”。如不是，会有运行时异常

//便利枚举的对象

Season[] seasons = Season.values();

for (Season season : seasons) {

System.out.println(season);

}

//SPRING

//SUMMER

//AUTUMN

//WINTER

Season spring = Season.valueOf("SPRING");

System.out.println(spring); //SPRING

4. 枚举实现接口

和普通 Java 类一样，枚举也可以实现一个或多个接口。

若每个枚举值在调用实现的接口方法呈现相同的行为，则只要统一实现该方法即可。

若需要每个枚举值在调用实现的接口方法呈现出不同的行为，则可以让每个枚举值分别来实现该方法。

定义接口：

interface MyInter {

void message();

}

interface Info {

void show();

}

枚举实现接口：

enum Season implements MyInter, Info {

SPRING("春天", "春暖花开") {

@Override

public void show() {

System.out.println("春天在哪里");

}

},

SUMMER("夏天", "烈日炎炎") {

@Override

public void show() {

System.out.println("夏天的风");

}

},

AUTUMN("秋天", "秋高气爽") {

@Override

public void show() {

System.out.println("秋天不回来");

}

},

WINTER("冬天", "白雪皑皑") {

@Override

public void show() {

System.out.println("大约在冬季");

}

};

private final String seasonDesc;

private final String seasonName;

private Season(String seasonName, String seasonDesc) {

this.seasonName = seasonName;

this.seasonDesc = seasonDesc;

}

//统一实现的重写方法

@Override

public void message() {

System.out.println("一年四季各不同");

}

}

测试类：

public class SeasonTest {

public static void main(String[] args) {

Season spring = Season.SPRING;

spring.message();

Season summer = Season.SUMMER;

summer.message();

Season autumn = Season.AUTUMN;

autumn.show();

Season winter = Season.WINTER;

winter.show();

}

}

一年四季各不同

一年四季各不同

秋天不回来

大约在冬季

对于同一个方法，两种重写方式可任选其一，也可同时存在。分别重写时，所有的实例都要自己重写接口中的方法，否则必须添加枚举的统一重写方法。同时存在时，实例自己的重写方法会覆盖枚举的统一重写方法。

枚举既可以包含具体方法，也可以包含抽象方法。 如果枚举含有抽象方法，则枚举的每个实例都必须分别实现该方法。与实现接口类似。