你一定需要知道的高阶Java枚举特性!

开发 开发工具
JAVA枚举,比你想象中还要有用!我经常发现自己在Java中使用枚举来表示某个对象的一组潜在值。

[[375855]]

JAVA枚举,比你想象中还要有用!

我经常发现自己在Java中使用枚举来表示某个对象的一组潜在值。

在编译时确定类型可以具有什么值的能力是一种强大的能力,它为代码提供了结构和意义。

当我第一次了解枚举时,当时我认为它们只是一个为常量命名的工具,可以很容易地被静态常量字符串ENUM_VAL_NAME所取代。

后来我发现我错了。事实证明,Java枚举具有相当高级的特性,可以使代码干净、不易出错,功能强大。

让我们一起来看看Java中的一些高级枚举特性,以及如何利用这些特性使代码更简单、更可读。

枚举是类!

在Java中,枚举是Object的一个子类。让我们看看所有枚举的基类,Enum(为简洁起见进行了修改)。

  1. public abstract class Enum<E extends Enum<E>> 
  2.     implements Constable, Comparable<E>, Serializable { 
  3.   private final String name
  4.    
  5.   public final String name() { 
  6.       return name
  7.   } 
  8.    
  9.   private final int ordinal; 
  10.    
  11.   public final int ordinal() { 
  12.       return ordinal; 
  13.   } 
  14.    
  15.   protected Enum(String nameint ordinal) { 
  16.       this.name = name
  17.       this.ordinal = ordinal; 
  18.   } 
  19.    
  20.   public String toString() { 
  21.       return name
  22.   } 
  23.    
  24.   public final boolean equals(Object other) { 
  25.       return this==other; 
  26.   } 
  27.    
  28.   public final int hashCode() { 
  29.       return super.hashCode(); 
  30.   } 
  31.    
  32.   public final int compareTo(E o) { 
  33.       Enum<?> other = (Enum<?>)o; 
  34.       Enum<E> self = this; 
  35.       if (self.getClass() != other.getClass() && // optimization 
  36.           self.getDeclaringClass() != other.getDeclaringClass()) 
  37.           throw new ClassCastException(); 
  38.       return self.ordinal - other.ordinal; 
  39.   } 
  40.    

我们可以看到,这基本上只是一个常规的抽象类,有两个字段,name和ordinal。

所以说枚举都是类,所以它们具有常规类的许多特性。

我们能够为枚举提供实例方法、构造函数和字段。我们可以重写toString(),但不能重写hashCode()或equals(Object other)。

接下来我们看下我们的枚举示例,Operation

  1. enum Operation { 
  2.   ADD
  3.   SUBTRACT, 
  4.   MULTIPLY 

这个枚举表示一个Operation可以对两个值执行,并将生成一个结果。关于如何实现此功能,您最初的想法可能是使用switch语句,如下所示:

  1. public int apply(Operation operation, int arg1, int arg2) { 
  2.    switch(operation) { 
  3.      case ADD
  4.        return arg1 + arg2; 
  5.      case SUBTRACT: 
  6.        return arg1 - arg2; 
  7.      case MULTIPLY: 
  8.        return arg1 * arg2; 
  9.      default
  10.        throw new UnsupportedOperationException(); 
  11.  } 
  12.  
  13.   

当然,这样子会有一些问题。

第一个问题是,如果我们将一个新操作添加到我们的枚举Operation中,编译器不会通知我们这个开关不能正确处理新操作。

更糟糕的是,如果一个懒惰的开发人员在另一个类中复制或重新编写这些代码,我们可能无法更新它。

第二个问题是默认情况default,每段程序里面都是必需的,尽管我们知道在正确的代码里它永远不会发生。

这是因为Java编译器知道上面的第一个问题,并且希望确保我们能够处理在不知情的情况下向Operation中添加了新枚举。

还好,Java8用函数式编程为我们提供了一个干净的解决方案。

函数枚举实现

因为枚举是类,所以我们可以创建一个枚举字段来保存执行操作的函数。

但是在我们找到解决方案之前,让我们先来看看一些重构。

首先,让我们把开关放在enum类中。

  1.    
  2. enum Operation { 
  3.   ADD
  4.   SUBTRACT, 
  5.   MULTIPLY; 
  6.    
  7.   public static int apply(Operation operation, int arg1, int arg2) { 
  8.     switch(operation) { 
  9.       case ADD
  10.         return arg1 + arg2; 
  11.       case SUBTRACT: 
  12.         return arg1 - arg2; 
  13.       case MULTIPLY: 
  14.         return arg1 * arg2; 
  15.       default
  16.         throw new UnsupportedOperationException(); 
  17.     } 
  18.   } 
  19.    

我们可以这样做:Operation.apply(Operation.ADD, 2, 3);

因为我们现在从Operation中调用方法,所以我们可以将其更改为实例方法并使用this,而不是用Operation.apply()来实现,如下所示:

  1. public int apply(int arg1, int arg2) { 
  2.   switch(this) { 
  3.     case ADD
  4.       return arg1 + arg2; 
  5.     case SUBTRACT: 
  6.       return arg1 - arg2; 
  7.     case MULTIPLY: 
  8.       return arg1 * arg2; 
  9.     default
  10.       throw new UnsupportedOperationException(); 
  11.   } 
  12.    

像这样使用:Operation.ADD.apply(2, 3);

看起来变好了。现在让我们更进一步,通过使用函数式编程完全消除switch语句。

  1. enum Operation { 
  2.               ADD((x, y) -> x + y), 
  3.               SUBTRACT((x, y) -> x - y), 
  4.               MULTIPLY((x, y) -> x * y); 
  5.    
  6.               Operation(BiFunction<IntegerIntegerInteger> operation) { 
  7.                       this.operation = operation; 
  8.               } 
  9.    
  10.               private final BiFunction<IntegerIntegerInteger> operation; 
  11.    
  12.               public int apply(int x, int y) { 
  13.                       return operation.apply(x, y); 
  14.               } 
  15.    
  16.   } 
  17.    

这里我做的是:

  • 添加了一个字段 BiFunction
  • 用BiFunction创建了用于Operation的构造函数。
  • 调用枚举定义中的构造函数,并用lambda指定BiFunction

这个java.util.function.BiFunction operation字段是对采用两个参数的函数(方法)的引用。

在我们的例子中,两个参数都是int型,返回值也是int型。不幸的是,Java参数化类型不支持原语,所以我们必须使用Integer。

因为BiFunction是用@functioninterface注释的,所以我们可以使用Lambda表示法定义一个。

因为我们的函数接受两个参数,所以我们可以使用(x,y)来指定它们。

然后我们定义了一个单行方法,它使用 ->x+y 返回一个值。这相当于下面的方法,只是更简洁而已。

  1. class Adder implements BiFunction<IntegerIntegerInteger> { 
  2.         @Override 
  3.         public Integer apply(Integer x, Integer y) { 
  4.                 return x + y; 
  5.   } 

我们的新Operation实现采用相同的方式:Operation.ADD.apply(2, 3);.

但是,这种实现更好,因为编译器会告诉我们何时添加了新Operation,这要求我们更新新函数。如果没有这一点,如果我们在添加新Operation时还不记得更新switch语句,就有可能得到UnsupportedOperationException()。

关键要点

  • Enum枚举是Enum的扩展类。
  • Enum枚举可以有字段、构造函数和实例方法。
  • Enum枚举字段可以存储函数。与lambdas配合使用,可以创建干净、安全的特定于枚举的函数实现,并在编译时强制执行它们(而不是使用switch)。

下面是这个示例的GitHub地址。(https://github.com/alex-power/java-enum-example)

本文参考:https://medium.com/javarevisited/advanced-java-enum-features-you-need-to-know-b516a191c7e2

责任编辑:武晓燕 来源: 51CTO专栏
相关推荐

2020-04-27 10:34:23

HTTPDNSDNS网络协议

2018-08-23 16:25:29

HadoopHDFS存储

2024-03-21 17:29:45

2020-06-10 08:33:05

Java 编程语言开发

2020-07-29 07:37:20

Git 修复项目

2020-01-03 10:11:01

数据库安全SQL

2015-08-06 13:30:56

商铺线上

2023-02-10 08:44:05

KafkaLinkedIn模式

2018-06-15 23:00:56

2017-09-18 18:31:08

Hadoop

2022-04-24 09:00:00

渗透测试安全数字时代

2022-07-15 14:58:26

数据分析人工智能IT

2017-02-09 14:46:25

Git事情

2022-12-30 11:24:21

2023-09-11 07:36:35

2018-02-25 04:57:01

物联网网络技术v

2018-12-27 14:21:31

https安全http

2019-11-15 14:00:39

HTTPSHTTP前端

2024-02-19 09:02:00

Rust编码

2011-09-20 10:56:35

云计算PaaS
点赞
收藏

51CTO技术栈公众号