对JAVA枚举类型的学习

最新推荐文章于 2026-08-20 21:54:00 发布

原创最新推荐文章于 2026-08-20 21:54:00 发布 · 2.9k 阅读

5 ·

本内容遵循CC 4.0 BY-SA版权协议

本文详细介绍了Java SE 1.5引入的枚举类型，包括定义方法、基本要求及其实现原理。并展示了如何在枚举中添加属性、方法以及实现接口的例子。

java SE 1.5以后的版本中，引入了一个新的引用类型----枚举类型。枚举类型指的是由一组固定的常量组合成的合法值类型，例如一年的四季，一个星期的7天，红绿蓝三色、状态的可用与不可用等，都是枚举类型的示例。

java中定义枚举的方法如下：

Code:

public enum Year{SPRING,SUMMER,FALL,WINTER};

java中定义枚举的基本要求有：

1.使用关键字enum。

2.类型名称,比如这里的Year。

3.一串允许的值，比如上面定义的春夏秋冬四季。

4。枚举可以单独定义在一个文件中，也可以嵌在其他Java类中。

除了这样的定义以外，用户还有一些其他选择：

1。枚举可以实现一个或多个接口（interface）。

2。可以定义新的变量和方法。

3。可以定义根据具体枚举值而相异的类。

java枚举类的原理也比较简单，就是在编译器编译的时候，枚举类型会被转换成为static final类型的一个类。比如以上定义枚举类被编译后的代码如下所示：

Code:

//源代码
public class Test
{
public enum Year{SPRING,SUMMER,FALL,WINTER};
public static void main(String[] args){}
}

Code:

//编译后生成的class文件经过反编译以后的代码
public class Test
{
public static final class Year extends Enum
{
public static Year[] values()
{
return (Year[])$VALUES.clone();
}
public static Year valueOf(String s)
{
return (Year)Enum.valueOf(Test$Year, s);
}
public static final Year SPRING;
public static final Year SUMMER;
public static final Year FALL;
public static final Year WINTER;
private static final Year $VALUES[];
static
{
SPRING = new Year("SPRING", 0);
SUMMER = new Year("SUMMER", 1);
FALL = new Year("FALL", 2);
WINTER = new Year("WINTER", 3);
$VALUES = (new Year[] {
SPRING, SUMMER, FALL, WINTER
});
}
private Year(String s, int i)
{
super(s, i);
}
}
public Test()
{
}
public static void main(String args[])
{
}
}

那么通过看编译后生成的代码可以看出，大概有这么几个规律：

1.定义的枚举变量变成了一个类名,并且继承了java.lang.Enum类。

2.枚举常量被变成了static final Year类型的。并且多了一个枚举类类型的数组变量private static final Year $VALUES[];

3.枚举类中多了这么几个方法。

Code:

public static Year[] values(){...} //返回该枚举对象定义的一个枚举类型数组。
public static Year valueOf(String s){...}//根据传入的字符串返回相应的枚举值。
private Year(String s, int i){...} //构造方法

4.多了一个静态执行块。

Code:

static
{
SPRING = new Year("SPRING", 0);//调用构造方法类给枚举常量给值。
SUMMER = new Year("SUMMER", 1);
FALL = new Year("FALL", 2);
WINTER = new Year("WINTER", 3);
$VALUES = (new Year[] { //初始化枚举类类型数组
SPRING, SUMMER, FALL, WINTER
});
}

所以枚举类型的值是直接用“枚举名.枚举值”来访问的，使用如下所示。

Code:

public class Test
{
enum Year{SPRING,SUMMER,FALL,WINTER};
public static void main(String[] args){
Year thisYear = Year.SPRING;
Year[] ty = Year.values();
for(Year tyear : ty){
System.out.println(tyear);
}
Year yearSeason = Year.valueOf("SPRING");
switch(yearSeason){
case SPRING:
System.out.println("春天");break;
case SUMMER:
System.out.println("夏天");break;
case FALL:
System.out.println("秋天");break;
case WINTER:
System.out.println("冬天");break;
default:
System.out.println("四季平安");break;
}
}
}

运行结果：

SPRING
SUMMER
FALL
WINTER
春天

由于枚举类型就是java.lang.Enum类的子类，因此，在枚举类型中可以添加属性，构造器和方法，并可以实现任意的接口，而且提供了所有Object类的方法，使用示例如下：

Code:

//sun公司提供的enum使用示例
public class PlanetTest{
public enum Planet {
MERCURY (3.303e+23, 2.4397e6),
VENUS (4.869e+24, 6.0518e6),
EARTH (5.976e+24, 6.37814e6),
MARS (6.421e+23, 3.3972e6),
JUPITER (1.9e+27, 7.1492e7),
SATURN (5.688e+26, 6.0268e7),
URANUS (8.686e+25, 2.5559e7),
NEPTUNE (1.024e+26, 2.4746e7),
PLUTO (1.27e+22, 1.137e6);
private final double mass; // in kilograms
private final double radius; // in meters
Planet(double mass, double radius)
{
this.mass = mass;
this.radius = radius;
}
private double mass() { return mass; }
private double radius() { return radius; }
// universal gravitational constant (m3 kg-1 s-2)
public static final double G = 6.67300E-11;
double surfaceGravity() {
return G * mass / (radius * radius);
}
double surfaceWeight(double otherMass) {
return otherMass * surfaceGravity();
}
}
public static void main(String[] args){
for(int i = 0;i<Planet.values().length;i++){
System.out.println(Planet.values()[i]);
//System.out.println(Planet.MERCURY);
//System.out.println(Planet.values()[i].mass());
//System.out.println(Planet.values()[i].surfaceGravity());
//System.out.println(Planet.values()[i].surfaceWeight(1.27e+22));
}
}
}

以上使用方法大体规律为：

构造方法，和枚举值中的参数，参数的出处（如上例的mass和radius）必须要联系起来。其他变量和方法没什么特殊要求。看下面代码所示：

Code:

MERCURY (3.303e+23, 2.4397e6),
以及
private final double mass; // in kilograms
private final double radius; // in meters
以及
Planet(double mass, double radius){
this.mass = mass;
this.radius = radius;
}

为什么上面要说他们必须要有联系呢。先别多说，看看反编译后的代码。如下所示：

Code:

import java.io.PrintStream;
public class PlanetTest
{
public static final class Planet extends Enum
{
public static Planet[] values()
{
return (Planet[])$VALUES.clone();
}
public static Planet valueOf(String s)
{
return (Planet)Enum.valueOf(PlanetTest$Planet, s);
}
private double mass()
{
return mass;
}
private double radius()
{
return radius;
}
double surfaceGravity()
{
return (6.6729999999999999E-011D * mass) / (radius * radius);
}
double surfaceWeight(double d)
{
return d * surfaceGravity();
}
public static final Planet MERCURY;
public static final Planet VENUS;
public static final Planet EARTH;
public static final Planet MARS;
public static final Planet JUPITER;
public static final Planet SATURN;
public static final Planet URANUS;
public static final Planet NEPTUNE;
public static final Planet PLUTO;
private final double mass;
private final double radius;
public static final double G = 6.6729999999999999E-011D;
private static final Planet $VALUES[];
static
{
MERCURY = new Planet("MERCURY", 0, 3.3030000000000001E+023D, 2439700D);
VENUS = new Planet("VENUS", 1, 4.8690000000000001E+024D, 6051800D);
EARTH = new Planet("EARTH", 2, 5.9760000000000004E+024D, 6378140D);
MARS = new Planet("MARS", 3, 6.4209999999999999E+023D, 3397200D);
JUPITER = new Planet("JUPITER", 4, 1.9000000000000001E+027D, 71492000D);
SATURN = new Planet("SATURN", 5, 5.6879999999999998E+026D, 60268000D);
URANUS = new Planet("URANUS", 6, 8.686E+025D, 25559000D);
NEPTUNE = new Planet("NEPTUNE", 7, 1.0239999999999999E+026D, 24746000D);
PLUTO = new Planet("PLUTO", 8, 1.2700000000000001E+022D, 1137000D);
$VALUES = (new Planet[] {
MERCURY, VENUS, EARTH, MARS, JUPITER, SATURN, URANUS, NEPTUNE, PLUTO
});
}
private Planet(String s, int i, double d, double d1)
{
super(s, i);
mass = d;
radius = d1;
}
}
public PlanetTest()
{
}
public static void main(String args[])
{
for(int i = 0; i < Planet.values().length; i++)
System.out.println(Planet.values()[i]);
}
}

通过观察不难发现有以下几个特点：

1.构造方法多了两个参数，且为private的。private Planet(String s, int i, double d, double d1)。为什么会这样呢，首先private 就是为了方式实例化该类。其次多余的两个参数就是源代码中构造方法的两个参数，方法体中包含父类构造方法调用和源文件中构造方法的方法体。

2.静态执行快中，调用了构造方法，构造方法的参数为4个，后面多出的两个参数也正是枚举常量后的参数MERCURY (3.303e+23, 2.4397e6)...。

所以，编译器在编译的过程中是根据构造方法来增加编译后构造方法中多余的参数。

下面一个实例是利用枚举来实现加减乘除运算。

Code: