java enum 浅析

最新推荐文章于 2015-07-04 12:12:10 发布

weistar103

最新推荐文章于 2015-07-04 12:12:10 发布

阅读量81

点赞数

分类专栏： J2SE 文章标签： j2se enum

本文链接：https://blog.csdn.net/weistar103/article/details/84237956

版权

J2SE 专栏收录该内容

43 篇文章 0 订阅

订阅专栏

java 中的枚举类型包括了其他语言中枚举类型的一般特性。

public class EnumDemo{

  public enum Seasons {

   winter,spring,summer,fall;

  }

  public static void main(String[] args){

  for(Seasons s:Seasons.values()){

   System.out.println(s);

  }

}

上面这个例子，展示了枚举类型的一般用法，在 java 的枚举类中提供了静态 values() 方法以供循环迭代时使用。大家再看一看下面这个例子：

public enum Seasons {

winter,

spring,

summer,

fall;

//list the values

public static void main(String[] args) {

for(Seasons s:Seasons.values())

  {

     System.out.println(s);

  }

}

}

这两个例子得出的是一样的结果。由此可知 enum 关键字是代表一个类相当于 class 的意思，但是它又比 class 的范围要小，仅仅代表枚举类而已。

java 中的枚举类除了有这些一般的功能外还包括一些特殊的功能，例如：枚举类型可以有构造函数、可以添加任意多的方法和属性；同时枚举类型还可以为不同的属性添加不同的方法。

在这里我们假设你希望向一个枚举类中添加数据和行为。例如我们可以设想一下银河系的星球。每个星球的它自己的特定数据，由此来计算物体在其表面上的重量。下面就是实例：

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;

    }

    public double mass()   { return mass; }

    public double radius() { return radius; }

    // universal gravitational constant  (m 3 kg -1 s-2)

    public static final double G = 6.67300E-11;

    public double surfaceGravity() {

        return G * mass / (radius * radius);

    }

    public double surfaceWeight(double otherMass) {

        return otherMass * surfaceGravity();

    }

    public static void main(String[] args) {

        double earthWeight = Double.parseDouble(args[0]);

        double mass = earthWeight/EARTH.surfaceGravity();

        for (Planet p : Planet.values())

           System.out.printf("Your weight on %s is %f%n",

                             p, p.surfaceWeight(mass));

    }

}

运行结果：

C:\java>java Planet 60
Your weight on MERCURY is 22.665457
Your weight on VENUS is 54.299946
Your weight on EARTH is 60.000000
Your weight on MARS is 22.724231
Your weight on JUPITER is 151.833452
Your weight on SATURN is 63.960932
Your weight on URANUS is 54.307632
Your weight on NEPTUNE is 68.299684
Your weight on PLUTO is 4.012468

在这里我们可以看到这个枚举类中含有一个带有两个参数的构造函数。通过构造函数我们可以产生含有不同数据特征的星球对象。在 main() 函数中，我们通过有不同的星球调用相同的方法来得到物体在该星球上的重量。

我们可以把为枚举常量添加行为的主意更向前推进一步。我们可以为不同枚举常量添加不同的行为。通过使用 switch 语句是达到这个目的的一种方法。下面就有一个实例：

public enum Operation {

    PLUS, MINUS, TIMES, DIVIDE;

    // Do arithmetic op represented by this constant

    double eval(double x, double y){

        switch(this) {

            case PLUS:   return x + y;

            case MINUS:  return x - y;

            case TIMES:  return x * y;

            case DIVIDE: return x / y;

        }

        throw new AssertionError("Unknown op: " + this);

    }

}

它工作的非常好，当时如果没有 throw 语句的话，它将不能通过编译，因此它就显得不是那么完美了。更加糟糕的是，你一定要记住在你向枚举类中添加枚举变量时，你要为这个变量添加操作。如果你忘了的话， eval 方法将会操作失败。

这里有另外一种给枚举常量添加行为的方法。使用这种方法你可以避免上面说提到的问题。你可以在枚举类型中添加一个 abstract 方法，然后在每一个枚举常量中重载它。这就是有名的 constant-specific 方法。下面就是用这种技术对以前实例的重写：

public enum Operation {

  PLUS   { double eval(double x, double y) { return x + y; } },

  MINUS  { double eval(double x, double y) { return x - y; } },

  TIMES  { double eval(double x, double y) { return x * y; } },

  DIVIDE { double eval(double x, double y) { return x / y; } };

  // Do arithmetic op represented by this constant

  abstract double eval(double x, double y);

  public static void main(String args[]) {

        double x = Double.parseDouble(args[0]);

        double y = Double.parseDouble(args[1]);

        for (Operation op : Operation.values())

            System.out.printf("%f %s %f = %f%n", x, op, y, op.eval(x, y));

    }

}

运行结果：
C:\java>java Operation 24 56
24.000000 PLUS 56.000000 = 80.000000
24.000000 MINUS 56.000000 = -32.000000
24.000000 TIMES 56.000000 = 1344.000000
24.000000 DIVIDE 56.000000 = 0.428571

大家可能会不太明白“ PLUS { double eval(double x, double y) { return x + y; } } ”的意思。其实如果大家理解内部类的话，可能就不难理解这句话的含义了。我的理解是 :

class MyenumOperation implements enumOperation

{

double eval(double x, double y) { return x + y; }

}

MyenumOperation plus = new MyenumOperation();

与枚举类型一起添加进来的还有 enumset 和 enummap ，我会在下一篇文章中介绍。

这篇文章是参照 sun enum specification 写下来的，版权归 sun 公司所有哦！