码迷,mamicode.com
首页 > 编程语言 > 详细

第30条:用enum代替int常量

时间:2016-08-02 17:00:33      阅读:232      评论:0      收藏:0      [点我收藏+]

标签:

在java1.5之前,表示枚举类型的常用模式是声明一组具名的int常量,每个类型成员一个常量:

public static final int APPLE_FUJI = 0;
public static final int APPLE_PIPPIN = 1;
public static final int APPLE_GRANNY_SMITH = 2;

public static final int ORANGE_NAVEL = 0;
public static final int ORANGE_TEMPLE = 1;
public static final int ORANGE_BLOOD = 2;

缺点:

1.将apple传到想要orange的方法中,不会出现错误

2.用==操作符将apple与orange比较,不会出现错误

3.int枚举是编译时常量,被编译到客户端中,如果枚举常量关联的int发生变化,客户端必须重新编译,如果没有重新编译,程序仍可以运行,但行为就确定了,如APPLE_FUJI关联的常量不再是0,而是3。

4.将int枚举常量翻译成可打印的字符串很麻烦

5.遍历一个组中所有的int枚举常量,获得int枚举组的大小,没有可靠的方法,如想知道APPLE的常量有多少个,除了查看int枚举常量所在位置的代码外,别无他法,而且靠的是观察APPLE_前缀有多少个,不可靠

 

枚举类型是int枚举常量的替代解决方案:

public enum Apple {FUJI, PIPPIN, GRANNY_SMITH}
public enum Orange {NAVEL, TEMPLE, BLOOD}

枚举是功能齐全的类,通过公有的静态final域为每个枚举常量导出实例的域。因为没有可以可以访问的构造器,客户端不能创建枚举类型的实例,也不能扩展它。

枚举提供编译时的类型安全,如果一个参数的类型是Apple,就可以保证,被传入到该参数上的任何非null对象引用一定是FUJI,PIPPIN,GRANNY_SMITH三个之一。

包含同名常量的多个枚举类型可以共存,因为每个类型有自己的命名空间,增加或重新排列枚举类型的常量,无需重新编译客户端代码。

通过调用toString方法,可以将枚举转换成可打印的字符串。

 

枚举类型有方法和域:

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 surfaceGravity() {
        return surfaceGravity;
    }
    
    public double surfaceWeight(double mass) {//F=ma
        return mass * surfaceGravity;
    }
    
}

根据某个物体在地球上的重量,显示该物体在所有8颗行星上的重量:

public static void main(String[] args) {
        double earthWeight = 175;
        double mass = earthWeight / Planet.EARTH.surfaceGravity();
        for(Planet p : Planet.values()) {
            System.out.printf("Weight on %s is %f%n", p, p.surfaceWeight(mass));
        }
}

如果枚举具有普遍适用性,它应该成为一个顶层类,如果只被用在一个特定的顶层类中,应该成为顶层类的一个成员类。

java.math.RoundingMode枚举表示十进制的舍入模式,用在BigDecimal类。

 

Planet示例展示每个常量关联不同的数据,有时候需要将本质上不同的行为与常量关联起来。

假设有一个枚举类型,表示计算器的四大基本操作:

public enum Operation {
    PLUS("+") {
        double apply(double x, double y) {return x + y;}
    },
    MINUS("-") {
        double apply(double x, double y) {return x - y;}
    },
    TIMES("*") {
        double apply(double x, double y) {return x - y;}
    },
    DIVIDE("/") {
        double apply(double x, double y) {return x - y;}
    }
    private final String symbol;
    Operation(String symbol) {
        this.symbol = symbol;
    }
    public String toString() {
        return symbol;
    }
    abstract double apply(double x, double y);
}

某些情况下,覆盖toString方法使打印算术表达式很容易:

public static void main(String[] args) {
    double x = 2.0;
    double y = 4.0;
    for(Operation op : Operation.values())
        System.out.printf("%f %s %f = %f%n", x, op, y, op.apply(x,y));
}

枚举类型有一个自动产生的valueOf(String)方法,它将常量的名字转变成常量本身。

如果覆盖toString方法,要考虑编写一个fromString方法,将字符串表示法变回相应的枚举:

private static final Map<String, Operation> stringToEnum
    = new HashMap<String, Operation>();
static {
    for(Operation op : values())
        stringToEnum.put(op.toString(), op);
}
public static Operation fromString(String symbol) {
    return stringToEnum.get(symbol);
}

 

枚举策略解决多个枚举常量同时共享相同的行为。

加班报酬,weekday和weekend的计算方式不一样:

enum PayrollDay {
    MONDAY(PayType.WEEKDAY),
    THESDAY(PayType.WEEKDAY),
    WEDNESDAY(PayType.WEEKDAY),
    THURSDAY(PayType.WEEKDAY),
    FRIDAY(PayType.WEEKDAY),
    SATURDAY(PayType.WEEKEND),
    SUNDAY(PayType.WEEKEND);
    
    private final PayType p;
    PayrollDay(PayType p) {
        this.p = p;
    }
    double pay(double hoursWorked, double payRate) {
        return payType.pay(hoursWorked, payRate);
    }

    private enum PayType {
        WEEKDAY {
            double overtimePay(double hours, double payRate) {
                return hours <= HOURS_PER_SHIFT ? 0 :
                    (hours - HOURS_PER_SHIFT) * payRate * 2;
            }
        },
        WEEKEND {
            double overtimePay(double hours, double payRate) {
                return hours * payRate / 2;
            }
        };
        private final static int HOURS_PER_SHIFT = 8;
        abstract double overtimePay(double hours, double Rate);
        double pay(double hoursWorked, double payRate) {
            double basePay = hoursWorked * payRate;
            return basePay + overtimePay(hoursWorked, payRate);
        }
    }
}

每当需要一组固定常量的时候,就应该使用枚举。

 

第30条:用enum代替int常量

标签:

原文地址:http://www.cnblogs.com/13jhzeng/p/5729582.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!