转载

重走JAVA编程之路（一）枚举

Java 1.5 发行版本增加了新的引用类型： 枚举 ， 在其之前，我们使用枚举类型值的时候通常是借助常量组成合法值的类型，例如表示光的三原色：红黄蓝的代码表示可能是以下这样的。 

/*******************光的三原色*********************/
    public static final int LIGHT_RED = 1;
    public static final int LIGHT_YELLOW = 2;
    public static final int LIGHT_BLUE = 3;

    /*******************颜料的三原色*********************/
    public static final int PIGMENT_RED = 1;
    public static final int PIGMENT_YELLOW = 2;
    public static final int PIGMENT_BLUE = 3;
复制代码

但是这样使用功能是受限的，比如不能知道对应枚举的个数等。幸好，Java 1.5引入了枚举类型Enum。

枚举的特性

Java 的枚举类型的父类均为 java.lang.Enum

Java的枚举本质上是int值

使用枚举类型将前面的使用常量方式调整如下：

public enum LighjtOriginColorEnums {
    RED,
    YELLOW,
    BLUE
}

public enum PigmentOriginColorEnums {
    RED,
    YELLOE,
    BLUE;
}

public static void main(String[] args){
    for(LighjtOriginColorEnums ele : LighjtOriginColorEnums.values()){
        System.out.println(ele + " int value is: " + ele.ordinal());
    }
}

复制代码

输出结果为：

RED int value is: 0
YELLOW int value is: 1
BLUE int value is: 2
复制代码

枚举类型的 ordinal() 方法，可以得到枚举的int整型值，该方法在 Enum 中定义，是一个不可覆盖的方法： 

public final int ordinal() {
    return ordinal;
}
复制代码

该方法返回枚举的 ordinal 属性值， 该值默认是枚举在其定义中的未知的索引值， 从0开始，即 RED.ordinal = 0, YELLOW.ordinal = 1, BLUE.ordinal = 2。ordinal的值大都数情况下是不会用到的。

枚举不能被实例化

关于枚举的说明：

枚举是不能实例化的，只能声明后，再使用

枚举不能实例化，所以是单例的

同理，枚举也是线程安全的

所以可以使用枚举实现单例模式

枚举提供了编译时的类型安全

如果声明一个参数类型为 LighjtOriginColorEnums ，则可以保证传递到该方法的任何非 null 的参数必须为 LighjtOriginColorEnums 中的三个枚举值之一。

枚举禁用了 clone 方法

protected final Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }
复制代码

枚举不会被finalize

/**
     * enum classes cannot have finalize methods.
     */
    protected final void finalize() { }
复制代码

枚举禁用了反序列化

/**
     * prevent default deserialization
     */
    private void readObject(ObjectInputStream in) throws IOException,
        ClassNotFoundException {
        throw new InvalidObjectException("can't deserialize enum");
    }

    private void readObjectNoData() throws ObjectStreamException {
        throw new InvalidObjectException("can't deserialize enum");
    }
复制代码

正因为枚举具有这些特性，所以我们可以使用枚举实现友好的单例模式，请见: 【设计模式】你的单例模式真的是生产可用的吗？

枚举可以定义方法

看一个简单的示例，表示一个互金公司的金额项：本金、利息、手续费、滞纳金 的枚举： acquireOffsetItemByCode(String code) 方法可以根据枚举的code属性，获得枚举。 

public enum OffsetItemEnums {

    /**
     * 手续费
     */
    offsetitem_fee("fee", "手续费"),
    /**
     * 滞纳金
     */
    offsetitem_penalty("penalty", "滞纳金"),
    /**
     * 利息
     */
    offsetitem_int("int", "利息"),
    /**
     * 本金
     */
    offsetitem_principal("principal", "本金"),


    ;

    private String code;
    private String desc;

    private OffsetItemEnums(String code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public static OffsetItemEnums acquireOffsetItemByCode(String code) throws Exception{
        for( OffsetItemEnums ele : OffsetItemEnums.values() ){
            if( ele.code.equalsIgnoreCase(code) ){
                return ele;
            }
        }
        throw new Exception("Error code:" + code);
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
}

复制代码

Effective Java 中的场景实例: 枚举中的抽象方法

在 Effective Java 第二版中的第30条定律中，举例了一个场景，如实现四则运算。

public enum Operation {
    PLUS, MINUS, TIMES, DIVIDE;

    double apply(double x, double y) throws Exception{
        switch (this){
            case PLUS:
                return x + y;
            case MINUS:
                return x - y;
            case TIMES:
                return x * y;
            case DIVIDE:
                return x / y;
        }
        throw new Exception("Unknown op: " + this);
    }
}
复制代码

这段代码可行, 但是需要 throw 一个Exception，如果没有抛出一个异常，就编译不过了，但是实际上是不可能执行到最后一行代码的。还存在一个问题是，如果新增了枚举常量，但是忘记给switch添加相应的条件，枚举仍然可以编译，但是运行时不会得到期望的结果。

我们发现一种更好的实现，是给枚举添加一个抽象的方法 apply:

public enum OperationGraceful {
    PLUS, MINUS, TIMES, DIVIDE;

    abstract double apply(double x, double y);
}
复制代码

此时编译错误：Class 'OperationGraceful' must either be declared abstract or implement abstract method 'apply(double, double)' in 'OperationGraceful'意思是每一个枚举常量必须实现声明的抽象方法： 

public enum OperationGraceful {
    PLUS{
        @Override
        double apply(double x, double y) {
            return x + y;
        }
    }, MINUS {
        @Override
        double apply(double x, double y) {
            return x - y;
        }
    }, TIMES {
        @Override
        double apply(double x, double y) {
            return x * y;
        }
    }, DIVIDE {
        @Override
        double apply(double x, double y) {
            return x / y;
        }
    };

    abstract double apply(double x, double y);
}
复制代码

如此一来，就不会在新增一个枚举值后，遗漏掉前面示例的switch分支逻辑，即使忘记了，编译器也会提醒，您需要实现抽象方法的规约。

特定于常量的方法实现可以与特定于常量的数据结合起来：

public enum OperationGracefulField {
    PLUS("+"){
        @Override
        double apply(double x, double y) {
            return x + y;
        }
    }, MINUS("-") {
        @Override
        double apply(double x, double y) {
            return x - y;
        }
    }, TIMES("*") {
        @Override
        double apply(double x, double y) {
            return x * y;
        }
    }, DIVIDE("/") {
        @Override
        double apply(double x, double y) {
            return x / y;
        }
    };

    // 属性
    private String symbol;
    OperationGracefulField(String symbol){
        this.symbol = symbol;
    }

    abstract double apply(double x, double y);
}

复制代码

计算加班工资的案例

在五个工作日中，正常超过8个小时，就会产生加班工资（当然现实其实是不可能的，万恶的资本主义丿_/）。周末全部算加班。加班费按基本工资的一半计算。

public enum PayrollDay {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY;

    private static final int HOUR_PER_SHIFT = 8;

    double pay(double hourseWorked, double payRate){
        double basePay = hourseWorked * payRate;

        double overtimePay;

        switch (this){
            case SATURDAY:
            case SUNDAY:
                overtimePay = hourseWorked * payRate / 2;
             default:
                 overtimePay = hourseWorked <= HOUR_PER_SHIFT
                         ? 0 : (hourseWorked - HOUR_PER_SHIFT) * payRate / 2;
                 break;
        }

        return  basePay + overtimePay;
    }
}
复制代码

这个程序可以运行，达到基本的业务需求，但是从维护角度来看，比较危险，假设将一个元素添加到枚举中，或许是一个表示假期天数的特殊值，但是非常不幸，忘记了在switch分支添加代码区分，虽然程序可以编译，但是实际运行时可能会出现尴尬的结果，比如假期也计算了工资，带薪假期忘了计算工资等等。

策略枚举的计算加班工资实现

我们可以根据是否工作日、双休日，将加班工资计算移到一个私有的嵌套枚举中，然后将这个 策略枚举 的实例传递到 PayrollDay 枚举的构造器中。 之后 PayrollDay 的加班费计算规则委托给策略枚举， PayrollDay 就不需要switch 语句或者特定于常量的方法了。 

public enum PayrollDayStrategy {
    MONDAY(PayType.WEEKDAY),
    TUESDAY(PayType.WEEKDAY),
    WEDNESDAY(PayType.WEEKDAY),
    THURSDAY(PayType.WEEKDAY),
    FRIDAY(PayType.WEEKDAY),
    SATURDAY(PayType.WEEKEND),
    SUNDAY(PayType.WEEKEND);

    private final PayType payType;

    PayrollDayStrategy(PayType payType){
        this.payType = payType;
    }

    private enum PayType{
        WEEKDAY{
            @Override
            double overtimePay(double hrs, double payRate) {
                return hrs <= HOUR_PER_SHIFT ?
                        0 : (hrs - HOUR_PER_SHIFT) * payRate / 2;
            }
        },
        WEEKEND {
            @Override
            double overtimePay(double hrs, double payRate) {
                return hrs * payRate /2;
            }
        };

        private static final int HOUR_PER_SHIFT = 8;

        abstract double overtimePay(double hrs, double payRate);

        double pay( double hoursWork, double payRate ){
            double basePay = hoursWork * payRate;
            return basePay + overtimePay(hoursWork, payRate);
        }
    }
}
复制代码

枚举的使用场景

  • 需要一组固定常量的时候

    例如： 行星、一周的天数等等

  • 如果多个枚举常量同时共享相同的行为， 则考使用虑策略枚举

EnumSet 枚举集合

EnumSet 类用来有效地表示从单个枚举类型中提取的多个值的多个集合，实现了 Set 集合，提供了丰富的功能和类型安全性。 

public class EnumSetDemo {
    public enum Style{
        BOLD,
        ITALIC,
        UNDERLINE,
        STRIKETHROUGH
    }

    public void applyStyle(Set<Style> styles){
        // TODO
    }

    public static void main(String[] args){
        EnumSetDemo enumSetDemo = new EnumSetDemo();
        enumSetDemo.applyStyle(EnumSet.of(Style.BOLD, Style.ITALIC));
    }
}
复制代码

EnumSet 提供了很多静态方法用于创建集合。

EnumSet.of(...) 源码

public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2) {
    EnumSet<E> result = noneOf(e1.getDeclaringClass());
    result.add(e1);
    result.add(e2);
    return result;
}
    
public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType) {
    Enum<?>[] universe = getUniverse(elementType);
    if (universe == null)
        throw new ClassCastException(elementType + " not an enum");

    if (universe.length <= 64)
        return new RegularEnumSet<>(elementType, universe);
    else
        return new JumboEnumSet<>(elementType, universe);
}


复制代码

其中 RegularEnumSet 、 JumboEnumSet 是JDK自带的EnumSet的实现类。 如果底层的枚举类型有64个或者更少的元素————其实大都数如此，整个 EnumSet 就用单个long来表示，性能较好。

EnumMap 枚举映射使用场景

自从我们知道 Enum 存在一个 ordinal 方法之后，可能对其使用就跃跃欲试了，比如，有一个用来表示一种烹饪的香草：

public enum Herb {
    ,
    ;
    
    public enum Type{
        ANNUAL, PERENNIAL, BIENNIAL
    }

    private String name;
    private Type type;

    Herb(String name, Type type){
        this.name = name;
        this.type = type;
    }


    @Override
    public String toString() {
        return name;
    }

}
复制代码

场景： 现在假设有一个香草的数组，表示一座花园中的植物，但是想要按照类型进行组织后将这些植物列出来。 分析 ： 我们发现，需要按类型分类，然后列出来。可以用作映射，刚好有一个 EnumMap 的类可以达到这样的目的。 

public enum Herb {
    A("A", Type.ANNUAL),
    B("B", Type.BIENNIAL),
    AA("AA", Type.ANNUAL),
    BB("BB", Type.BIENNIAL),
    C("C", Type.PERENNIAL),
    ;

    public enum Type{
        ANNUAL, PERENNIAL, BIENNIAL
    }

    private String name;
    private Type type;

    Herb(String name, Type type){
        this.name = name;
        this.type = type;
    }


    @Override
    public String toString() {
        return name;
    }

    public static void main(String[] args){
        // 这是一个花园，栽种有各种类型的香草
        Herb[] garden = new Herb[]{Herb.A, Herb.B, Herb.AA, Herb.BB, Herb.C};

        // EnumMap 构造器需要指定 class 作为类型参数
        Map<Herb.Type, Set<Herb>> herbsByType =
                new EnumMap<Type, Set<Herb>>(Type.class);

        for (Type t : Herb.Type.values()){
            // 按类型分类
            herbsByType.put(t, new HashSet<Herb>());
        }

        // 开始对花园处理
        for (Herb h : garden){
            herbsByType.get(h.type).add(h);
        }

        // 输出分类信息
        System.out.println(herbsByType);
    }

}
复制代码

枚举实现接口

枚举还可以实现接口，用于实现扩展功能。

改装前面的四则运算案例：

// 接口
package org.byron4j.cookbook.javacore.enums;

public interface OperationI {
    public double apply(double x, double y);
}



// 实现接口的枚举
package org.byron4j.cookbook.javacore.enums;

public enum BasicOperation implements OperationI{
    PLUS("+"){
        @Override
        public double apply(double x, double y) {
            return x + y;
        }
    }, MINUS("-") {
        @Override
        public double apply(double x, double y) {
            return x - y;
        }
    }, TIMES("*") {
        @Override
        public double apply(double x, double y) {
            return x * y;
        }
    }, DIVIDE("/") {
        @Override
        public double apply(double x, double y) {
            return x / y;
        }
    };

    // 属性
    private String symbol;
    BasicOperation(String symbol){
        this.symbol = symbol;
    }


}

复制代码

参考资料：

  • Effective Java（第二版）
原文  https://juejin.im/post/5c80ce8cf265da2da00edbb5
正文到此结束
所属分类： Java 编程技术

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 springcloud-demo Hive教程 Ant教程 ANTLR教程 SpringCloud java实例教程 XStream教程 Hazelcast教程 Elastic-Job-Lite 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 solr教程 Hadoop教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 java-demo Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 如何将Spring Cloud Task发布Data Flow上执行？
  2. 2 Spring Cloud Data Flow快速入门Demo
  3. 3 Spring Cloud Consul实现选举机制
  4. 4 Spring Boot集成ShedLock实现分布式定时任务
  5. 5 利用oss进行数据库和网站图片备份
  6. 6 Spring Cloud Stream实现数据流处理
  7. 7 Python3访问MySQL数据库快速入门Demo
  8. 8 Github开源项目作者可以免费申请 JetBrains 全家桶
  9. 9 Spring Cloud Vault快速入门Demo
  10. 10 Spring Cloud Gateway快速入门Demo
网站信息
  • 文章总数：82,716 篇
  • 文件总数：284,297 个
  • 标签总数：2,396 个
  • 分类总数：85 个
  • 留言数量：2,560 条
  • 在线人数：618 人
  • 运行天数：4,410天
  • 最后更新：2024年11月23日15点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG