Enum类型

所谓枚举是指由一组固定的常量组成合法值的类型，例如一年中的季节、每个星期的7天、太阳系的恒星或扑克牌的花色(阳光的样色)等等。在引入枚举类型前，表示枚举类型的方法是声明一组具名的常量；

例如：

public static final int APPLE_FUJI = 0;

public static final int APPLE_PIPPIN = 1;

public static final int APPLE_CRANNY_SMITH = 2;

public static final int ORANGE_NAVEL = 0;

public static final int ORANGE_TEMPLE = 1;

public static final int ORANGE_BLOOD = 2;

这种方式叫int枚举模式(int Enum pattern)。

int枚举的缺点较多 

1.容易出现编译器无法检测的错误。例如 讲apple传到了orange方法中；

2.int枚举是编译时常量，当常量值发生变化是需要重新编译，否则可能出现不可预见的错误；

3.int类型只是一个整型数值。如果将其打印出来或者从调试器中显示出来，就是一个数字，没有多大的用处。

之后的String枚举模式也一样缺点较多。

Java1,5开始出现了枚举类型

枚举类型其实就是通过公有的静态final域为每个枚举常量导出实例的类。枚举类型是单例的泛型化，它是实例受控的。因为枚举没有课访问的构造，枚举类型是真正的final。

枚举除了完善int枚举的不足之外，还允许添加任意的方法和域，并实现任意的接口。

eg:

public Enum Planet() {

MERCURY(3.302e+23, 2.439e6),

VENUS(4.869e+24, 6.052e6),

EARTH(5.975e+24, 6.378e6),

MARS(6.419e+23, 3.393e6),

JUPITER(1.899e+27, 7.149e7),

SATURN(5.685e+26, 6.027e7),

URANUS(8.683e+25, 2.556e7),

NEPTUNE(1.024e+26, 2.477e7);

private final double mass;

private final double radius;

private final double surfaceGravity;

private static final double G = 6.67300E-11;

Planet(double mass, double radius) {

this.mass = mass;

this.radius = radius;

surfaceGravity = G * mass / (radius * radius);

}

public double mass(){ return mass;}

public double radius(){ return radius;}

public double surfaceGraviity() { return surfaceGravity;}

public double surfaceWeight(double mass) {

return mass = surfaceGravity;

}

}

测试程序

public class WeightTable {

public static void main(String[] args) {

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

double mass = earthWeight / Planet.EARTH.surfaceGravity();

for( Planent p : Planet.values()){

System.out.printf("Weight on %s id %f%n",p, p.surfaceWeight(mass));

}

}

}

通过抽象方法可以将不同的行为与每个枚举常量关联起来。

public Enum Operation {

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

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

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

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

abstract double applay(double x, double y);

}

public Enum Operation {

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

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

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

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

abstract double applay(double x, double y);

private final String symbol;

Operation(String symbol){ this.symbol = symbol;}

@Override

public String toString(){return symbol;}

}

测试

public class test{

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.applay(x, y));

}

}

}

枚举策略 明天继续

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