Effective Java 学习笔记之枚举

ゞ 浴缸里的玫瑰 2022-06-14 06:41 316阅读 0赞

1.用enum代替int常量

1）为了将数据和枚举常量关联起来 得声明实例域，并编写一个带有数据并将数据保存在域中的构造器。
2）枚举天生就是不可变的，因此所有的域都应该是final的。它们可以是公有的，但是最好做成私有并提供公有的访问方式
3）枚举类型还允许添加任意的方法和域 并实现任意的接口
4）提供了所有Object方法的高级实现 实现了Comparable和Serializable接口，并设计了序列化方式

  1. public enum Planet {
  3.     MERCURY(3.302E+23, 2.439E6),
  4.     VENUS(4.869e+24, 6.052e6),
  5.     EARTH(5.975e+24, 6.378e6),
  6.     MARS(6.419e+23, 3.393e6),
  7.     JUPITER(1.899e+27, 7.149e7),
  8.     SATURN(5.685e+26, 6.027e7),
  9.     URANUS(8.683e+25, 2.556e7),
  10.     NEPTUNE(1.024e+26, 2.477e7);
  12.     private final double mass;
  13.     private final double radius;
  14.     private final double surfaceGravity;
  16.     private static final double G = 6.67300E-11;
  19.     Planet(double mass, double radius) {
  20.         this.mass = mass;
  21.         this.radius = radius;
  22.         surfaceGravity = G * mass / (radius * radius);
  23.     }
  25.     public double getMass() {
  26.         return mass;
  27.     }
  29.     public double getRadius() {
  30.         return radius;
  31.     }
  33.     public double getSurfaceGravity() {
  34.         return surfaceGravity;
  35.     }
  37.     public double getSurfaceWeight(double mass) {
  38.         return mass * surfaceGravity;
  39.     }
  41. }

扩展：需要为每个常量添加不同的行为

  1. public enum Operation1 {
  3.     PLUS, MINUS, TIMES, DIVIDE;
  5.     double apply(double x, double y) {
  6.         switch (this) {
  7.             case PLUS:
  8.                 return x + y;
  9.             case MINUS:
  10.                 return x - y;
  11.             case TIMES:
  12.                 return x * y;
  13.             case DIVIDE:
  14.                 return x / y;
  15.         }
  16.         throw new AssertionError("Unknown op:" + this);
  17.     }
  18. }

上面的代码存在一些问题，当为枚举类添加新的常量后，忘记为其提供相应apply的实现，编译不会出现错误提示，然而运行结果却不是希望的

因此可以进行修改

提供一个抽象的apply方法,这样每个常量都必须实现这个抽象方法，否则编译就会报错

  1. PLUS {
  2.         @Override
  3.         double apply(double x, double y) {
  4.             return x + y;
  5.         }
  6.     },
  7.     MINUS {
  8.         @Override
  9.         double apply(double x, double y) {
  10.             return x - y;
  11.         }
  12.     },
  13.     TIMES {
  14.         @Override
  15.         double apply(double x, double y) {
  16.             return x * y;
  17.         }
  18.     },
  19.     DIVIDE {
  20.         @Override
  21.         double apply(double x, double y) {
  22.             return x / y;
  23.         }
  24.     };
  26.     abstract double apply(double x, double y);

有时候复写toString方法也会非常有用

  1. public enum Operation2 {
  2.     PLUS("+") {
  3.         @Override
  4.         double apply(double x, double y) {
  5.             return x + y;
  6.         }
  7.     },
  8.     MINUS("-")  {
  9.         @Override
  10.         double apply(double x, double y) {
  11.             return x - y;
  12.         }
  13.     },
  14.     TIMES("*")  {
  15.         @Override
  16.         double apply(double x, double y) {
  17.             return x * y;
  18.         }
  19.     },
  20.     DIVIDE("/")  {
  21.         @Override
  22.         double apply(double x, double y) {
  23.             return x / y;
  24.         }
  25.     };
  27.     abstract double apply(double x, double y);
  29.     private String symbol;
  31.     Operation2(String symbol) {
  32.         this.symbol = symbol;
  33.     }
  35.     @Override
  36.     public String toString() {
  37.         return symbol;
  38.     }
  39. }
  41. public class OpeartionTest {
  42.     public static void main(String[] args) {
  43.         double d1 = 1.3;
  44.         double d2 = 2.6;
  45.         for (Operation2 o:Operation2.values()){
  46.             System.out.printf("%f %s %f = %f%n",d1,o,d2,o.apply(d1,d2));
  47.         }
  48.     }
  49. }

输出结果

  1. 1.300000 + 2.600000 = 3.900000
  2. 1.300000 - 2.600000 = -1.300000
  3. 1.300000 * 2.600000 = 3.380000
  4. 1.300000 / 2.600000 = 0.500000

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

  1. Operation2 plus = Operation2.valueOf("PLUS");
  2. System.out.println(plus);

输出结果

  1. +

如果在枚举类型中覆盖toString，要考虑编写一个fromString方法，将定制的字符串表示法变回相应的枚举，考虑用map保存

  1. private static Map<String,Operation3> operation3Map = new HashMap<>();
  3. static {
  4.    for (Operation3 o:Operation3.values()){
  5.        operation3Map.put(o.toString(),o);
  6.    }
  7. }
  9. public static Operation3 fromString(String str){
  10.     return operation3Map.get(str);
  11. }

测试方法

  1. Operation3 minus = Operation3.fromString("-");
  2. System.out.println(minus);

输出结果

  1. -

6）特定于常量的方法有一点不足，它们是的在枚举常量中共享代码变得困难

  1. public enum PayrollDay {
  2.     MONDAY, TUESDAT, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
  4.     /** * 正常工作时间 */
  5.     private static final int HOURS_PER_SHIFT = 8;
  7.     /** * 计算工资 * * @param hoursWorked 工作时间 * @param payRate 薪资 * @return 工资 */
  8.     double pay(double hoursWorked, double payRate) {
  9.         double basePay = hoursWorked * payRate;
  11.         double overtimePay;
  13.         switch (this) {
  14.             case SATURDAY:
  15.             case SUNDAY:
  16.                 overtimePay = hoursWorked * payRate / 2;
  17.             default:
  18.                 overtimePay = hoursWorked <= HOURS_PER_SHIFT ? 0 : (hoursWorked - HOURS_PER_SHIFT) * payRate / 2;
  19.         }
  20.         return basePay + overtimePay;
  21.     }
  22. }

当添加一个元素而没有添加相应的case时就会出现问题

可以使用枚举策略来解决，即讲加班工资的计算转移到一个私有的嵌套枚举中，将这个枚举的实例传到外部枚举的构造器中，这样外部枚举就可以将工资计算委托给内部枚举不需要再用switch进行转化了

  1. public enum PayrollDay2 {
  3.     MONDAY(PayType.PAY_WEEKDAY),
  4.     TUESDAY(PayType.PAY_WEEKDAY),
  5.     WEDNESDAY(PayType.PAY_WEEKDAY),
  6.     THURSDAY(PayType.PAY_WEEKDAY),
  7.     FRIDAY(PayType.PAY_WEEKDAY),
  8.     SATURDAY(PayType.PAY_WEEKEND),
  9.     SUNDAY(PayType.PAY_WEEKEND);
  11.     private final PayType payType;
  13.     PayrollDay2(PayType payType) {
  14.         this.payType = payType;
  15.     }
  17.     public double pay(double hoursWork, double payRate) {
  18.         return this.payType.pay(hoursWork, payRate);
  19.     }
  21.     private enum PayType {
  22.         PAY_WEEKDAY {
  23.             @Override
  24.             double overtimePay(double hoursWork, double payRate) {
  25.                 return hoursWork <= HOUR_SHIFT_TIME ? 0 : (hoursWork - HOUR_SHIFT_TIME) * payRate / 2;
  26.             }
  27.         },
  28.         PAY_WEEKEND {
  29.             @Override
  30.             double overtimePay(double hoursWork, double payRate) {
  31.                 return hoursWork * payRate;
  32.             }
  33.         };
  35.         private static final int HOUR_SHIFT_TIME = 8;
  37.         abstract double overtimePay(double hoursWork, double payRate);
  39.         public double pay(double hoursWork, double payRate) {
  40.             double basePay = hoursWork * payRate;
  41.             double overtimePay = overtimePay(hoursWork, payRate);
  42.             return basePay + overtimePay;
  43.         }
  44.     }
  45. }

2.用实例域代替序数

  1. public enum Ensemble {
  2.     SOLO(1),
  3.     DUET(2),
  4.     TRIO(3),
  5.     QUARTET(4),
  6.     QUEINTET(5),
  7.     SEXTET(6),
  8.     SEPTET(7);
  10.     private final int numberOfMusicians;
  12.     Ensemble(int size) {
  13.         this.numberOfMusicians = size;
  14.     }
  16.     public int getNumberOfMusicians() {
  17.         return numberOfMusicians;
  18.     }
  20.     //public int numberOfMusicians() { 
  21.     // //ordinal():返回每个枚举常量在类型中的数字位置
  22.     // return ordinal() + 1;
  23.     //}
  24. }

3.用接口模拟可伸缩的枚举

  1. public interface Operation { 
  2.     double apply(double x, double y);
  3. }
  4. public enum BaseOperation implements Operation {
  5.     PLUS {
  6.         @Override
  7.         public double apply(double x, double y) {
  8.             return x + y;
  9.         }
  10.     }, MINUS {
  11.         @Override
  12.         public double apply(double x, double y) {
  13.             return x - y;
  14.         }
  15.     }, TIMES {
  16.         @Override
  17.         public double apply(double x, double y) {
  18.             return x * y;
  19.         }
  20.     }, DIVIDE {
  21.         @Override
  22.         public double apply(double x, double y) {
  23.             return x / y;
  24.         }
  25.     };
  26. }
  28. public enum ExtendOperation implements Operation {
  29.     MOD {
  30.         @Override
  31.         public double apply(double x, double y) {
  32.             return x % y;
  33.         }
  34.     },
  35.     EXP {
  36.         @Override
  37.         public double apply(double x, double y) {
  38.             return Math.pow(x, y);
  39.         }
  40.     };
  41. }

测试方法

  1. public class ExtendOperationTest {
  2.     public static void main(String[] args) {
  3.         double d1 = 1.3;
  4.         double d2 = 2.6;
  5.         test(ExtendOperation.class, d1, d2);
  6.         test1(Arrays.asList(ExtendOperation.values()), d1, d2);
  7.     }
  9.     private static <T extends Enum<T> & Operation> void test(Class<T> opSet, double d1, double d2) {
  10.         for (Operation o : opSet.getEnumConstants()) {
  11.             System.out.printf("%f %s %f = %f%n", d1, o, d2, o.apply(d1, d2));
  12.         }
  13.     }
  15.     private static void test1(Collection<? extends Operation> opSet, double d1, double d2) {
  16.         for (Operation o : opSet) {
  17.             System.out.printf("%f %s %f = %f%n", d1, o, d2, o.apply(d1, d2));
  18.         }
  19.     }
  20. }

输出结果

  1. 1.300000 MOD 2.600000 = 1.300000
  2. 1.300000 EXP 2.600000 = 1.978120
  3. 1.300000 MOD 2.600000 = 1.300000
  4. 1.300000 EXP 2.600000 = 1.978120

发表评论

表情：
评论列表 （有 0 条评论，316人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java之枚举

    ine, 我写这个是因为在读Calendar的时候发现对枚举类(enum)的使用不熟悉。 使用原因 * 清晰明了。例如枚举类SeasonEnum表示的季节，它...

    怼烎@怼烎@/ 0 赞/ 148 阅读

    相关 Java SE学习之枚举总结

    本文是学习网络上的文章时的总结以及自己的一点实践，感谢大家无私的分享。 最近在看Java基础方面的书的时候，又遇到了枚举的介绍。在网上查了一些资料，对这些资料进行一些总结。

    深碍√TFBOYSˉ_深碍√TFBOYSˉ_/ 0 赞/ 225 阅读

    相关 Java之枚举

    1.定义 enum 是一种数据类型，与 全局常量比较相似，都是全局的并且是可以通过类名调用的 与全局常量区别 枚举功能更强大，可以有属性和方法

    绝地灬酷狼绝地灬酷狼/ 0 赞/ 294 阅读

    相关 枚举学习笔记

    [2019独角兽企业重金招聘Python工程师标准>>> ][2019_Python_] ![hot3.png][] 枚举Enum > 关键字enum可以将一组具名的值

    亦凉亦凉/ 0 赞/ 400 阅读