恕我直言，我怀疑你没怎么用过枚举

时间  2020-03-18
标签 恕我直言 怀疑 怎么 用过 枚举 繁體版
原文   原文链接

Profile

咱们是否同样？

估计不少小伙伴（也包括我本身）都有这种状况，在自学Java语言看书时，关于枚举enum这一块的知识点可能都有点 “轻敌” ，以为这块内容很是简单，一带而过，并且在实际写代码过程当中也不注意运用。java

是的，我也是这样！直到有一天我提的代码审核没过，被技术总监一顿批，我才从新拿起了《Java编程思想》，把枚举这块的知识点从新又审视了一遍。编程

为何须要枚举

常量定义它不香吗？为啥非得用枚举？设计模式

举个栗子，就以B站上传视频为例，视频通常有三个状态：草稿、审核和发布，咱们能够将其定义为静态常量：数组

public class VideoStatus {
    
    public static final int Draft = 1; //草稿
    
    public static final int Review = 2; //审核
    
    public static final int Published = 3; //发布
}
复制代码

对于这种单值类型的静态常量定义，自己也没错，主要是在使用的地方没有一个明确性的约束而已，好比：ide

void judgeVideoStatus( int status ) {
    
    ...
    
}
复制代码

好比这里的 judgeVideoStatus 函数的本意是传入 VideoStatus 的三种静态常量之一，但因为没有类型上的约束，所以传入任意一个int值都是能够的，编译器也不会提出任何警告。函数

可是在枚举类型出现以后，上面这种状况就能够用枚举严谨地去约束，好比用枚举去定义视频状态就很是简洁了：this

public enum VideoStatus {
    Draft, Review, Published
}
复制代码

并且主要是在用枚举的地方会有更强的类型约束：编码

// 入参就有明确类型约束
void judgeVideoStatus( VideoStatus status ) {
    
    ...
    
}
复制代码

这样在使用 judgeVideoStatus 函数时，入参类型就会受到明确的类型约束，一旦传入无效值，编译器就会帮咱们检查，从而规避潜在问题。spa

除此以外，枚举在扩展性方面比普常量更方便、也更优雅。设计

从新系统认识一下枚举

仍是拿前文《答应我，别再if/else走天下了能够吗》中的那个例子来讲：好比，在后台管理系统中，确定有用户角色一说，并且角色通常都是固定的，适合定义成一个枚举：

public enum UserRole {

    ROLE_ROOT_ADMIN,  // 系统管理员

    ROLE_ORDER_ADMIN, // 订单管理员

    ROLE_NORMAL       // 普通用户
}
复制代码

接下来咱们就用这个UserRole为例来讲明枚举的全部基本用法：

UserRole role1 = UserRole.ROLE_ROOT_ADMIN;
UserRole role2 = UserRole.ROLE_ORDER_ADMIN;
UserRole role3 = UserRole.ROLE_NORMAL;

// values()方法：返回全部枚举常量的数组集合
for ( UserRole role : UserRole.values() ) {
    System.out.println(role);
}
// 打印：
// ROLE_ROOT_ADMIN
// ROLE_ORDER_ADMIN
// ROLE_NORMAL

// ordinal()方法：返回枚举常量的序数，注意从0开始
System.out.println( role1.ordinal() ); // 打印0
System.out.println( role2.ordinal() ); // 打印1
System.out.println( role3.ordinal() ); // 打印2

// compareTo()方法：枚举常量间的比较
System.out.println( role1.compareTo(role2) ); //打印-1
System.out.println( role2.compareTo(role3) ); //打印-2
System.out.println( role1.compareTo(role3) ); //打印-2

// name()方法：得到枚举常量的名称
System.out.println( role1.name() ); // 打印ROLE_ROOT_ADMIN
System.out.println( role2.name() ); // 打印ROLE_ORDER_ADMIN
System.out.println( role3.name() ); // 打印ROLE_NORMAL

// valueOf()方法：返回指定名称的枚举常量
System.out.println( UserRole.valueOf( "ROLE_ROOT_ADMIN" ) );
System.out.println( UserRole.valueOf( "ROLE_ORDER_ADMIN" ) );
System.out.println( UserRole.valueOf( "ROLE_NORMAL" ) );
复制代码

除此以外，枚举还能够用于switch语句中，并且意义更加明确：

UserRole userRole = UserRole.ROLE_ORDER_ADMIN;
switch (userRole) {
    case ROLE_ROOT_ADMIN:  // 好比此处的意义就很是清晰了，比1，2，3这种数字好！
        System.out.println("这是系统管理员角色");
        break;
    case ROLE_ORDER_ADMIN:
        System.out.println("这是订单管理员角色");
        break;
    case ROLE_NORMAL:
        System.out.println("这是普通用户角色");
        break;
}
复制代码

自定义扩充枚举

上面展现的枚举例子很是简单，仅仅是单值的情形，而实际项目中用枚举每每是多值用法。

好比，我想扩充一下上面的UserRole枚举，在里面加入 角色名 -- 角色编码 的对应关系，这也是实际项目中经常使用的用法。

这时候咱们能够在枚举里自定义各类属性、构造函数、甚至各类方法：

public enum UserRole {

    ROLE_ROOT_ADMIN( "系统管理员", 000000 ),
    ROLE_ORDER_ADMIN( "订单管理员", 100000 ),
    ROLE_NORMAL( "普通用户", 200000 ),
    ;

    // 如下为自定义属性
    
    private final String roleName;  //角色名称

    private final Integer roleCode; //角色编码

    // 如下为自定义构造函数
    
    UserRole( String roleName, Integer roleCode ) {
        this.roleName = roleName;
        this.roleCode = roleCode;
    }

    // 如下为自定义方法
    
    public String getRoleName() {
        return this.roleName;
    }

    public Integer getRoleCode() {
        return this.roleCode;
    }

    public static Integer getRoleCodeByRoleName( String roleName ) {
        for( UserRole enums : UserRole.values() ) {
            if( enums.getRoleName().equals( roleName ) ) {
                return enums.getRoleCode();
            }
        }
        return null;
    }

}
复制代码

从上述代码可知，在enum枚举类中彻底能够像在普通Class里同样声明属性、构造函数以及成员方法。

枚举 + 接口 = ?

好比在个人前文《答应我，别再if/else走天下了能够吗》中讲烦人的if/else消除时，就讲过如何经过让枚举去实现接口来方便的完成。

这地方不妨再回顾一遍：

什么角色能干什么事，这很明显有一个对应关系，因此咱们首先定义一个公用的接口RoleOperation，表示不一样角色所能作的操做：

public interface RoleOperation {
    String op();  // 表示某个角色能够作哪些op操做
}
复制代码

接下来咱们将不一样角色的状况所有交由枚举类来作，定义一个枚举类RoleEnum，并让它去实现RoleOperation接口：

public enum RoleEnum implements RoleOperation {

    // 系统管理员(有A操做权限)
    ROLE_ROOT_ADMIN {
        @Override
        public String op() {
            return "ROLE_ROOT_ADMIN:" + " has AAA permission";
        }
    },

    // 订单管理员(有B操做权限)
    ROLE_ORDER_ADMIN {
        @Override
        public String op() {
            return "ROLE_ORDER_ADMIN:" + " has BBB permission";
        }
    },

    // 普通用户(有C操做权限)
    ROLE_NORMAL {
        @Override
        public String op() {
            return "ROLE_NORMAL:" + " has CCC permission";
        }
    };
}
复制代码

这样，在调用处就变得异常简单了，一行代码就好了，根本不须要什么if/else：

public class JudgeRole {
    public String judge( String roleName ) {
        // 一行代码搞定！以前的if/else灰飞烟灭
        return RoleEnum.valueOf(roleName).op();
    }
}
复制代码

并且这样一来，之后假如我想扩充条件，只须要去枚举类中加代码便可，而不用改任何老代码，很是符合开闭原则！

枚举与设计模式

什么？枚举还能实现设计模式？

是的！不只能并且还能实现好几种！

一、单例模式

public class Singleton {

    // 构造函数私有化，避免外部建立实例
    private Singleton() {

    }

    //定义一个内部枚举
    public enum SingletonEnum{

        SEED;  // 惟一一个枚举对象，咱们称它为“种子选手”！

        private Singleton singleton;

        SingletonEnum(){
            singleton = new Singleton(); //真正的对象建立隐蔽在此！
        }

        public Singleton getInstnce(){
            return singleton;
        }
    }

    // 故意外露的对象获取方法，也是外面获取实例的惟一入口
    public static Singleton getInstance(){
        return SingletonEnum.SEED.getInstnce(); // 经过枚举的种子选手来完成
    }
}
复制代码

二、策略模式

这个也比较好举例，好比用枚举就能够写出一个基于策略模式的加减乘除计算器

public class Test {

    public enum Calculator {

        ADDITION {
            public Double execute( Double x, Double y ) {
                return x + y; // 加法
            }
        },

        SUBTRACTION {
            public Double execute( Double x, Double y ) {
                return x - y; // 减法
            }
        },

        MULTIPLICATION {
            public Double execute( Double x, Double y ) {
                return x * y; // 乘法
            }
        },


        DIVISION {
            public Double execute( Double x, Double y ) {
                return x/y;  // 除法
            }
        };

        public abstract Double execute(Double x, Double y);
    }
    
    public static void main(String[] args) {
        System.out.println( Calculator.ADDITION.execute( 4.0, 2.0 ) );       
        // 打印 6.0
        System.out.println( Calculator.SUBTRACTION.execute( 4.0, 2.0 ) );    
        // 打印 2.0
        System.out.println( Calculator.MULTIPLICATION.execute( 4.0, 2.0 ) ); 
        // 打印 8.0
        System.out.println( Calculator.DIVISION.execute( 4.0, 2.0 ) );       
        // 打印 2.0
    }
}
复制代码

专门用于枚举的集合类

咱们日常通常习惯于使用诸如：HashMap 和 HashSet等集合来盛放元素，而对于枚举，有它专门的集合类：EnumSet和EnumMap

一、EnumSet

EnumSet 是专门为盛放枚举类型所设计的 Set 类型。

仍是举例来讲，就以文中开头定义的角色枚举为例：

public enum UserRole {

    ROLE_ROOT_ADMIN,  // 系统管理员

    ROLE_ORDER_ADMIN, // 订单管理员

    ROLE_NORMAL       // 普通用户
}
复制代码

好比系统里来了一批人，咱们须要查看他是否是某个角色中的一个：

// 定义一个管理员角色的专属集合
EnumSet<UserRole> userRolesForAdmin 
    = EnumSet.of( 
        UserRole.ROLE_ROOT_ADMIN,
        UserRole.ROLE_ORDER_ADMIN 
    );

// 判断某个进来的用户是否是管理员
Boolean isAdmin( User user ) {
    
    if( userRoles.contains( user.getUserRole() ) )
        return true;
    
    return false;
}
复制代码

二、EnumMap

一样，EnumMap 则是用来专门盛放枚举类型为key的 Map 类型。

好比，系统里来了一批人，咱们须要统计不一样的角色到底有多少人这种的话：

Map<UserRole,Integer> userStatisticMap = new EnumMap<>(UserRole.class);

for ( User user : userList ) {
    Integer num = userStatisticMap.get( user.getUserRole() );
    if( null != num ) {
        userStatisticMap.put( user.getUserRole(), num+1 );
    } else {
        userStatisticMap.put( user.getUserRole(), 1 );
    }
}
复制代码

用EnumMap能够说很是方便了。

总 结

小小的枚举就玩出这么多的花样，不过好在探索和总结的过程还挺有意思的，也复习了不少知识，慢慢来吧。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程