Effective Java 学习笔记--36-38条 枚举类型

2024-08-25 16:28
文章标签 java 36 类型 学习 笔记 枚举 38 effective

本文主要是介绍Effective Java 学习笔记--36-38条 枚举类型，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

枚举之前--int常量

枚举类型

枚举类型的特性

自定义方法和域的设置

实例的统一行为

实例的不同行为

switch语句

抽象方法

公共接口

策略枚举

用实例域代替默认序数

枚举集合

EnumSet

EnumMap

枚举类型用于定义一组固定的命名常量，在枚举类型中定义的每一个枚举常量都是枚举类型的一个实例，而且这个实例是不可变的。

枚举之前--int常量

枚举类型是Java 5版本引入的，在引入之前通常使用int常量来表示枚举类型，每一个int常量代表一个类型实例：

public class FruitMarket {public static final int APPLE = 0;public static final int ORANGE = 1;public static final int BANANA = 2;public static final int PINEAPPLE = 3;}

int常量的确能够轻松的列举出有限的枚举，但是有几个问题：

一是int常量没有安全性可言，只要是int值相同，不同类型的枚举都视为一样：

class FruitMarket {public static final int APPLE = 0;public static final int ORANGE = 1;public static final int BANANA = 2;public static final int PINEAPPLE = 3;}class VegetableMarket{public static final int CARROT = 0;public static final int CABBAGE = 1;public static final int TOMATO = 2;public static final int CUCUMBER = 3;}public class Application{public static void main(String[] args){VegetableMarket.CARROT == FruitMarket.APPLE;}}

二是Int常量作为静态常量在编译时就会被赋值，一旦常量做了改变（或者有了新增），就要重新编译文件，而且要重新检视应用了这些常量的Java文件。

三是Int常量没有丰富的专用方法，比如遍历所有的枚举、将具体的常量值映射到对应的String标识等等，都要通过循环遍历和switch语句来实现。

四是Int常量受限于Integer类型，无法顺畅的加入一些枚举特有的方法。

但是Int常量的优势在于其存储的轻量化，所以如果是需要轻量化的枚举（比如只需要作为简单的标识作用），Int常量还是可以考虑的。 

枚举类型

枚举类型的特性

Java的枚举类型对于枚举的使用做了针对性的设计，同时配置了齐全的功能。

一是通过公有的静态final域为每一个枚举常量导出一个枚举实例。

二是没有可以外部访问的构造器，进一步保证了外部无法通过构造器来新增枚举实例，但是可以允许有私有构造器，将枚举实例与相关的数据对应起来：

public enum Planet{MERCURY(3.302e+23, 2.439e6),VENUS(4.869e+24, 6.052e6),EARTH(5.972e+24, 6.378e6),MARS(6.419e+23, 3.396e6),JUPITER(1.899e+27, 7.149e7),SATURN(5.685e+26, 6.052e7),URANUS(8.681e+25, 2.556e7),NEPTUNE(1.002e+25, 1.188e6);private double mass;private double radius;private double surfaceGravity;private final static double G = 6.67300E-11;Planet(double mass, double radius){this.mass = mass;this.radius = radius;surfaceGravity = G*mass/(radius*radius);}}//这里将Planet实例与其质量（mass）、半径（radius）和重力常量对应起来。

三是枚举类提供了丰富的内置方法，其中绝大部分都是继承自java.lang.Enum基类（除了values()方法）：

  • name()：

    • 返回枚举常量的名称，即定义枚举时使用的标识符。
    • 例如，对于枚举 Day.MONDAY，name() 方法将返回 "MONDAY"。

  • ordinal()：

    • 返回枚举常量在其枚举类型中的位置索引（从0开始）。
    • 例如，对于枚举 Day.MONDAY，ordinal() 方法将返回 0，因为它是第一个枚举常量。

  • toString()：

    • 返回枚举常量的名称，与 name() 方法相同。
    • 默认情况下，toString() 方法返回枚举常量的名称。

  • compareTo(E other)：

    • 比较两个枚举常量的顺序。
    • 参数 other 是同一枚举类型的另一个枚举常量。
    • 返回值表示当前枚举常量与 other 枚举常量的相对顺序。

  • valueOf(Class<E> enumType, String name)：

    • 静态方法，用于根据枚举类型的名称获取枚举常量。
    • 如果名称匹配枚举类型中的一个常量，则返回该枚举常量；否则，抛出 IllegalArgumentException。

  • values()：

    • 静态方法，返回枚举类型的数组，包含该枚举类型的所有枚举常量。
    • 这个方法可以用来遍历枚举类型的全部常量。

可以看到绝大部分方法都是继承了Object类和实现Comparable与Serializable接口所实现的方法。

自定义方法和域的设置

实例的统一行为

枚举类型由于不是基本数据类型，所以在构建的时候可以添加自定义方法和域，这些方法和域可以实现将各种支持性数据和它对应的常量对应起来（比如将Apple实例与其图片、介绍等内容关联起来），自定义域的定义的在前面说私有构造器的时候已经举过相关例子了，这里把自定义的方法扩展一下：

public enum Planet{MERCURY(3.302e+23, 2.439e6),VENUS(4.869e+24, 6.052e6),EARTH(5.972e+24, 6.378e6),MARS(6.419e+23, 3.396e6),JUPITER(1.899e+27, 7.149e7),SATURN(5.685e+26, 6.052e7),URANUS(8.681e+25, 2.556e7),NEPTUNE(1.002e+25, 1.188e6);private final double mass;private final double radius;private final double surfaceGravity;private final static double G = 6.67300E-11;Planet(double mass, double radius){this.mass = mass;this.radius = radius;surfaceGravity = G*mass/(radius*radius);}public double getMass(){return mass;}public double getRadius(){return radius;}public double surfaceWeight(double mass){return mass*surfaceGravity;}
}

这里作者强调由于枚举类本身是不可变的，因此所有的域都要改成final，而且要做好封装，能私有化的尽量都私有化，通过公有接口来调用。

实例的不同行为

比如四则运算，每一个枚举实例的运算规则都不相同，这种实例的不同行为可以有多种实现方式：

switch语句
public enum Operation{PLUS, MINUS, TIMES, DIVIDE;public double apply(double x, double y){switch(this){case PLUS: return x+y;case MINUS: return x-y;case TIMES: return x*y;case DIVIDE: return x/y;}throw new AssertionError("Unknow op:"+this);}}//由switch语句来实现apply方法

这种方法比较简洁，但是有几个问题：

一是必须声明throw方法，不然无法通过编译，但是枚举类保证了实例的范围，所以这段代码是永远不会被执行的。

二是一旦新增了枚举常量，就需要记得给switch方法中再增加一个case。

抽象方法
package Operation;public enum BasicOperation{PLUS("+"){public double apply(double x, double y){return x + y;}},MINUS("-"){public double apply(double x, double y){return x-y;}},MULTIPLY("*"){public double apply(double x, double y){return x * y;}},DIVIDE("/"){public double apply(double x, double y){return x / y;}};public abstract double apply(double x, double y);//在枚举类中设置抽象方法，然后让各个实例来自行实现。 private final String symbol;BasicOperation(String symbol){this.symbol = symbol;}@Overridepublic String toString(){return symbol;}
}

这个方法将公共方法抽象到了类中，实现了高内聚，但是还可以进一步的抽象为公共接口。

公共接口
package Operation;//将apply方法抽象到接口当中
public interface Operation {public double apply(double x, double y);
}//具体的枚举类通过实现接口来调用接口方法apply
public enum BasicOperation implements Operation{PLUS("+"){public double apply(double x, double y){return x + y;}},MINUS("-"){public double apply(double x, double y){return x-y;}},MULTIPLY("*"){public double apply(double x, double y){return x * y;}},DIVIDE("/"){public double apply(double x, double y){return x / y;}};private final String symbol;BasicOperation(String symbol){this.symbol = symbol;}@Overridepublic String toString(){return symbol;}
}

公共接口的方式进一步提升了抽象的层次，使得任何枚举类都可以通过实现接口来调用相关方法，这种方式适合新建另一个枚举类的时候使用（比如新建一个AdvancedOperation类实现了幂运算和开方运算）。

策略枚举

策略枚举是一种较为特殊的方式，它适用的场景是对于枚举实例设置一个新的分类方式，并基于这个分类方式实行差异化的方法，比如把周一到周日分为工作日和休息日，其中工作日超过八小时的工作时间会产生加班工资，在休息日所有工作都产生加班工资：

package PayrollDay;public class PayrollDay {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;GoodPayrollDay(PayType payType){this.payType = payType;}int pay(int minutesWorked, int payRate){return payType.pay(minutesWorked, payRate);}}
//这里将PayTYpe设置为新的分类方式，并且作为基本枚举类PayrollDay的一个域映射到每一个实例上，而pay的实现方法都定义在PayTYpe中enum PayType{WEEKDAY{int overtimePay(int minutes, int PayRate){return minutes <= MINS_PER_SHIFT ? 0 : (minutes - MINS_PER_SHIFT) * PayRate/2;};},WEEKEND{int overtimePay(int minutes, int PayRate){return minutes * PayRate/2;}};abstract int overtimePay(int minutes, int PayRate);private static final int MINS_PER_SHIFT = 8 * 60; int pay(int minutes, int PayRate){int basePay = minutes*PayRate;return basePay + overtimePay(minutes, PayRate);}
}

用实例域代替默认序数

枚举类有默认实现的ordinal()方法来返回每个枚举常量在类型中对应的数字位置，但是这个数字并不是程序员可以直接控制的，而且没有实际的意义，因此作者建议自行定义关联值并将它保存在一个实例域中：

package Ensemble;public enum ensemble {SOLO(1), DUET(2), TRIO(3), QUARTET(4), QUINTET(5), SEXTET(6), SEPTET(7), OCTET(8), DOUBLE_QUARTET(8), NONET(9), DECTET(10);private int numberOfMusicians;ensemble(int size){this.numberOfMusicians = size;}public int numberOfMusicians(){return numberOfMusicians;}
}

枚举集合

EnumSet

EnumSet是同一个枚举类常量的集合，在枚举类出现之前的int常量时期，往往使用位域操作来实现int常量的集合运算：

public class text {public static final int STYLE_BOLD = 1<<0;public static final int STYLE_ITALIC = 1<<1;public static final int STYLE_UNDERLINE = 1<<2;public static final int STYLE_STRIKETHROUGH = 1<<3;public static int applyStyle(int style){return style;};
}

这里由int常量来表示枚举，由于int有32位，这意味着可以使用int类型来表示最多32中不同的状态，并且通过or运算来做并集（比如将0001和1000合并成为1001）。

但是这种方式有很大的问题，一是它继承了int常量所有的缺陷，二是难以遍历位域运算形成的集合，三是在编写API的时候，必须先预测最多需要多少位，同时要选择合适的类型（如果特性较多可能要使用long类型），不然会导致溢出。

所以EnumSet可以完美解决上述的缺陷，它实现了Set接口的集合处理方法，使得对于集合的各种处理功能更加丰富。

public class Text{public enum Style{BOLD, ITALIC, UNDERLINE, STRIKETHROUGH}publi void applyStyles(Set<Style> styles){};
}Text.applyStyles(EnumSet.of(Style.BOLD, Style.ITALIC));

EnumMap

EnumMap即以枚举常量为key的Map，在实现EnumMap之前一般通过序数索引来构建枚举实例为key对应的Map类型，而序数索引一般由ordinal方法实现。

package Plant;import java.util.HashSet;
import java.util.Set;public class BadApplication {public static void main(String[] args) {Set<Plant> garden = new HashSet<>();garden.add(new Plant("Violets", Plant.LifeCycle.ANNUAL));garden.add(new Plant("Radishes", Plant.LifeCycle.PERENNIAL));garden.add(new Plant("Apple", Plant.LifeCycle.BIENNIAL));garden.add(new Plant("Pears", Plant.LifeCycle.BIENNIAL));garden.add(new Plant("Grapes",Plant.LifeCycle.ANNUAL));Set<Plant>[] plantByLifeCycle = (Set<Plant>[]) new Set[Plant.LifeCycle.values().length];for(int i = 0; i < Plant.LifeCycle.values().length; i++){plantByLifeCycle[i] = new HashSet<>();}for(Plant p : garden){plantByLifeCycle[p.getLifeCycle().ordinal()].add(p);}for(int i=0; i<plantByLifeCycle.length; i++){System.out.printf("%s: %s%n", Plant.LifeCycle.values()[i], plantByLifeCycle[i]);}}}

这方法首先数组与泛型合用时程序需要进行未受检的转换，不然会在编译是出告警；二是ordinal()方法返回的序数和plantByLifeCycle序数的对应需要人工进行核对，程序是不保证的。

而EnumMap可以很好的解决这个问题：

public class Application {public static void main(String[] args) {Set<Plant> garden = new HashSet<>();garden.add(new Plant("Violets", Plant.LifeCycle.ANNUAL));garden.add(new Plant("Radishes", Plant.LifeCycle.PERENNIAL));garden.add(new Plant("Apple", Plant.LifeCycle.BIENNIAL));garden.add(new Plant("Pears", Plant.LifeCycle.BIENNIAL));garden.add(new Plant("Grapes",Plant.LifeCycle.ANNUAL));Map<Plant.LifeCycle, List<Plant>> plantByLifeCycle = new EnumMap<>(Plant.LifeCycle.class);for(Plant.LifeCycle lc: Plant.LifeCycle.values()){plantByLifeCycle.put(lc, new ArrayList<Plant>());}for(Plant p: garden){plantByLifeCycle.get(p.getLifeCycle()).add(p);}for (Plant.LifeCycle lc : Plant.LifeCycle.values()) {System.out.println(lc+": ");for (Plant plant : plantByLifeCycle.get(lc)) {System.out.println(plant);}System.out.println("\n");}}

这里有的读者会质疑EnumMap和普通Map相比在起初构建时并无显著不同，那它的优势在哪里：

  1. 类型安全：EnumMap 的键必须是某个枚举类型的枚举值。这意味着在编译时就会检查键的有效性，从而避免了运行时可能出现的 ClassCastException。
  2. 高效：EnumMap 内部使用数组实现，因此在查找枚举键时非常高效。这是因为枚举类型的枚举值数量是固定的，而且是已知的，因此 EnumMap 可以预先计算出每个枚举值的位置。
  3. 有序：EnumMap 会按照枚举值的声明顺序来维护键的顺序。这意味着当你遍历 EnumMap 时，键的顺序是确定的，这有助于简化代码逻辑。

除了上述方法之外，作者还展示了如何使用Stream的形式来实现EnumMap:

System.out.println(Arrays.stream(garden).collect(groupingBy(p->p.lifeCycle, ()->new EnumMap<>(LifeCycle.class), Collector.toSet())));

区别在于后一种方式可以仅包含garden涉及的枚举类型，而第一种的key中会列示所有的枚举常量。 

这里补充一下Stream的用法解析：

  1. 使用 Stream API：使用 Arrays.stream(garden) 将列表转换为 Stream。
  2. 分组：使用 Collectors.groupingBy 方法按 Plant 的 lifeCycle 属性进行分组。
    1. Plant::getLifeCycle：指定分组键的提取器。
    2. () -> new EnumMap<>(LifeCycle.class)：指定创建 EnumMap 的工厂方法。
    3. Collectors.toSet()：指定收集器，将每个分组的结果收集到 Set 中。

这篇关于Effective Java 学习笔记--36-38条 枚举类型的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1106056。

相关文章

HarmonyOS学习(七)——UI（五）常用布局总结

HarmonyOS学习(七)——UI（五）常用布局总结

自适应布局 1.1、线性布局（LinearLayout） 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列，Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距，达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式，且在各类尺寸屏幕上表现一致，其中交叉轴为垂直时，取值为Vert
阅读更多...
Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya（不是本人，claude AI）在社交媒体上分享了他在OpenAI学习到的15个Prompt撰写技巧。 以下是详细的内容： 提示精确化:在编写提示时,力求表达清晰准确。清楚地阐述任务需求和概念定义至关重要。例:不用"分析文本",而用"判断这段话的情感倾向:积极、消极还是中性"。 快速迭代:善于快速连续调整提示。熟练的提示工程师能够灵活地进行多轮优化。例:从"总结文章"到"用
阅读更多...
JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【课程链接】 AntV G6：深入图形与图形分组、自定义节点、节点动画（下）_哔哩哔哩_bilibili 本章十吾老师讲解了一个复杂的自定义节点中，应该怎样去计算和绘制图形，如何给一个图形制作不间断的动画，以及在鼠标事件之后产生动画。（有点难，需要好好理解） <!DOCTYPE html><html><head><meta charset="UTF-8"><title>06
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2