我有几个 switch 语句来测试一个enum. 所有enum值都必须switch由case语句在语句中处理。在代码重构期间，可能会发生enum收缩和增长。当enum收缩时，编译器会抛出错误。但是，如果enum增长，则不会引发错误。匹配状态被遗忘并产生运行时错误。我想将此错误从运行时移到编译时。从理论上讲，应该可以enum在编译时检测到丢失的情况。有什么办法可以做到这一点？
问题已经存在“如何检测新值已添加到枚举中并且未在开关中处理”，但它不包含仅与 Eclipse 相关的解决方法的答案。
在Effective Java中，Joshua Bloch 建议为每个常量创建一个抽象方法。例如：
enum Color {
RED { public String getName() {return "Red";} },
GREEN { public String getName() {return "Green";} },
BLUE { public String getName() {return "Blue";} };
public abstract String getName();
}
这将作为一个更安全的开关，如果您添加一个新常量，则强制您实现该方法。
编辑：为了消除一些混乱，这里是使用常规的等价物switch：
enum Color {
RED, GREEN, BLUE;
public String getName() {
switch(this) {
case RED: return "Red";
case GREEN: return "Green";
case BLUE: return "Blue";
default: return null;
}
}
}
另一种解决方案使用函数式方法。您只需要根据下一个模板声明枚举类：
public enum Direction {
UNKNOWN,
FORWARD,
BACKWARD;
public interface SwitchResult {
public void UNKNOWN();
public void FORWARD();
public void BACKWARD();
}
public void switchValue(SwitchResult result) {
switch (this) {
case UNKNOWN:
result.UNKNOWN();
break;
case FORWARD:
result.FORWARD();
break;
case BACKWARD:
result.BACKWARD();
break;
}
}
}
如果您尝试在至少没有一个枚举常量的情况下使用它，您将收到编译错误：
getDirection().switchValue(new Direction.SwitchResult() {
public void UNKNOWN() { /* */ }
public void FORWARD() { /* */ }
// public void BACKWARD() { /* */ } // <- Compilation error if missing
});
我不知道标准 Java 编译器，但 Eclipse 编译器当然可以配置为对此发出警告。转到 Window->Preferences->Java->Compiler->Errors/Warnings/Enum 类型常量未覆盖开关。
您还可以将访问者模式改编为枚举，从而避免在枚举类中放置各种不相关的状态。
如果修改枚举的人足够小心，就会发生编译时失败，但不能保证。
在默认语句中，您仍然会在 RTE 之前出现故障：当加载访问者类之一时它会失败，您可以在应用程序启动时发生这种情况。
这是一些代码：
你从一个看起来像这样的枚举开始：
public enum Status {
PENDING, PROGRESSING, DONE
}
以下是您如何将其转换为使用访问者模式：
public enum Status {
PENDING,
PROGRESSING,
DONE;
public static abstract class StatusVisitor<R> extends EnumVisitor<Status, R> {
public abstract R visitPENDING();
public abstract R visitPROGRESSING();
public abstract R visitDONE();
}
}
当您向枚举添加一个新常量时，如果您没有忘记将方法 visitXXX 添加到抽象 StatusVisitor 类中，那么您将直接在您使用访问者的任何地方都出现编译错误（它应该替换您所做的每个开关在枚举上）：
switch(anObject.getStatus()) {
case PENDING :
[code1]
break;
case PROGRESSING :
[code2]
break;
case DONE :
[code3]
break;
}
应该变成：
StatusVisitor<String> v = new StatusVisitor<String>() {
@Override
public String visitPENDING() {
[code1]
return null;
}
@Override
public String visitPROGRESSING() {
[code2]
return null;
}
@Override
public String visitDONE() {
[code3]
return null;
}
};
v.visit(anObject.getStatus());
现在是丑陋的部分，EnumVisitor 类。它是访问者层次结构的顶级类，如果您忘记更新抽象访问者，则实现访问方法并使代码在启动（测试或应用程序）时失败：
public abstract class EnumVisitor<E extends Enum<E>, R> {
public EnumVisitor() {
Class<?> currentClass = getClass();
while(currentClass != null && !currentClass.getSuperclass().getName().equals("xxx.xxx.EnumVisitor")) {
currentClass = currentClass.getSuperclass();
}
Class<E> e = (Class<E>) ((ParameterizedType) currentClass.getGenericSuperclass()).getActualTypeArguments()[0];
Enum[] enumConstants = e.getEnumConstants();
if (enumConstants == null) {
throw new RuntimeException("Seems like " + e.getName() + " is not an enum.");
}
Class<? extends EnumVisitor> actualClass = this.getClass();
Set<String> missingMethods = new HashSet<>();
for(Enum c : enumConstants) {
try {
actualClass.getMethod("visit" + c.name(), null);
} catch (NoSuchMethodException e2) {
missingMethods.add("visit" + c.name());
} catch (Exception e1) {
throw new RuntimeException(e1);
}
}
if (!missingMethods.isEmpty()) {
throw new RuntimeException(currentClass.getName() + " visitor is missing the following methods : " + String.join(",", missingMethods));
}
}
public final R visit(E value) {
Class<? extends EnumVisitor> actualClass = this.getClass();
try {
Method method = actualClass.getMethod("visit" + value.name());
return (R) method.invoke(this);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
有几种方法可以实现/改进这个胶水代码。我选择向上走类层次结构，当超类是 EnumVisitor 时停止，然后从那里读取参数化类型。您也可以使用作为枚举类的构造函数参数来做到这一点。
你可以使用更聪明的命名策略来减少丑陋的名字，等等......
缺点是它有点冗长。好处是
Enum Mapper 项目提供了一个注释处理器，它将确保在编译时处理所有枚举常量。
此外，它支持反向查找和部分映射器。
使用示例：
@EnumMapper
public enum Seasons {
SPRING, SUMMER, FALL, WINTER
}
注释处理器将生成一个 java 类Seasons_MapperFull，可用于将所有枚举常量映射到任意值。
这是一个示例，我们将每个枚举常量映射到一个字符串。
EnumMapperFull<Seasons, String> germanSeasons = Seasons_MapperFull
.setSPRING("Fruehling")
.setSUMMER("Sommer")
.setFALL("Herbst")
.setWINTER("Winter");
您现在可以使用映射器来获取值，或进行反向查找
String germanSummer = germanSeasons.getValue(Seasons.SUMMER); // returns "Sommer"
ExtremeSeasons.getEnumOrNull("Sommer"); // returns the enum-constant SUMMER
ExtremeSeasons.getEnumOrRaise("Fruehling"); // throws an IllegalArgumentException
可能像 FindBugs 这样的工具会标记此类开关。
艰难的答案是重构：
可能性一：可以去面向对象
如果可行，取决于案例中的代码。
代替
switch (language) {
case EO: ... break;
case IL: ... break;
}
创建一个抽象方法：说p
language.p();
或者
switch (p.category()) {
case 1: // Less cases.
...
}
可能性二：更高层次
当有许多开关时，在 DocumentType、WORD、EXCEL、PDF、...等枚举中。然后创建扩展基类Doc 的WordDoc、ExcelDoc、PdfDoc。再一次可以面向对象工作。
在我看来，如果您要执行的代码在枚举域之外，那么一种方法是构建一个单元测试用例，循环遍历枚举中的项目并执行包含开关。如果出现问题或不符合预期，您可以使用断言检查对象的返回值或状态。
您可以将测试作为某些构建过程的一部分执行，此时您将看到任何异常。
无论如何，单元测试在许多项目中几乎是强制性的并且是有益的。
如果开关内的代码属于枚举，请按照其他答案中的建议将其包含在其中。
如果您使用的是 Android Studio（至少版本 3 及更高版本），您可以在检查设置中激活此精确检查。这也可能在其他 IntelliJ Java IDE 上可用。
去Preferences/Inspections。在该Java/Control flow Issues部分中，检查项目Enum 'switch' statement that misses case。或者，您可以更改严重性以Error使其比警告更明显。
我知道问题是关于 Java 的，我认为纯 Java 的答案很明确：它不是内置功能，但有一些变通方法。对于那些来到这里并在 Android 或其他可以使用 Kotlin 的系统上工作的人，该语言通过其when 表达式提供了此功能，并且与 Java 的互操作允许它相当无缝，即使这是您中唯一的 Kotlin 代码代码库。
例如：
public enum HeaderSignalStrength {
STRENGTH_0, STRENGTH_1, STRENGTH_2, STRENGTH_3, STRENGTH_4;
}
使用我的原始 Java 代码：
// In HeaderUtil.java
@DrawableRes
private static int getSignalStrengthIcon(@NonNull HeaderSignalStrength strength) {
switch (strength) {
case STRENGTH_0: return R.drawable.connection_strength_0;
case STRENGTH_1: return R.drawable.connection_strength_1;
case STRENGTH_2: return R.drawable.connection_strength_2;
case STRENGTH_3: return R.drawable.connection_strength_3;
case STRENGTH_4: return R.drawable.connection_strength_4;
default:
Log.w("Unhandled HeaderSignalStrength: " + strength);
return R.drawable.cockpit_connection_strength_0;
}
}
// In Java code somewhere
mStrength.setImageResource(HeaderUtil.getSignalStrengthIcon(strength));
可以用 Kotlin 重写：
// In HeaderExtensions.kt
@DrawableRes
fun HeaderSignalStrength.getIconRes(): Int {
return when (this) {
HeaderSignalStrength.STRENGTH_0 -> R.drawable.connection_strength_0
HeaderSignalStrength.STRENGTH_1 -> R.drawable.connection_strength_1
HeaderSignalStrength.STRENGTH_2 -> R.drawable.connection_strength_2
HeaderSignalStrength.STRENGTH_3 -> R.drawable.connection_strength_3
HeaderSignalStrength.STRENGTH_4 -> R.drawable.connection_strength_4
}
}
// In Java code somewhere
mStrength.setImageResource(HeaderExtensionsKt.getIconRes(strength));
这是 Visitor 方法的一种变体，它在您添加常量时为您提供编译时帮助：
interface Status {
enum Pending implements Status {
INSTANCE;
@Override
public <T> T accept(Visitor<T> v) {
return v.visit(this);
}
}
enum Progressing implements Status {
INSTANCE;
@Override
public <T> T accept(Visitor<T> v) {
return v.visit(this);
}
}
enum Done implements Status {
INSTANCE;
@Override
public <T> T accept(Visitor<T> v) {
return v.visit(this);
}
}
<T> T accept(Visitor<T> v);
interface Visitor<T> {
T visit(Done done);
T visit(Progressing progressing);
T visit(Pending pending);
}
}
void usage() {
Status s = getRandomStatus();
String userMessage = s.accept(new Status.Visitor<String>() {
@Override
public String visit(Status.Done done) {
return "completed";
}
@Override
public String visit(Status.Progressing progressing) {
return "in progress";
}
@Override
public String visit(Status.Pending pending) {
return "in queue";
}
});
}
漂亮吧？我称之为“Rube Goldberg 架构解决方案”。
我通常只会使用抽象方法，但如果你真的不想在枚举中添加方法（可能是因为你引入了循环依赖），这是一种方法。
使用 lambda 的函数式方法，更少的代码
public enum MyEnum {
FIRST,
SECOND,
THIRD;
<T> T switchFunc(
Function<MyEnum, T> first,
Function<MyEnum, T> second,
Function<MyEnum, T> third
// when another enum constant is added, add another function here
) {
switch (this) {
case FIRST: return first.apply(this);
case SECOND: return second.apply(this);
case THIRD: return third.apply(this);
// and case here
default: throw new IllegalArgumentException("You forgot to add parameter");
}
}
public static void main(String[] args) {
MyEnum myEnum = MyEnum.FIRST;
// when another enum constant added method will break and trigger compile-time error
String r = myEnum.switchFunc(
me -> "first",
me -> "second",
me -> "third");
System.out.println(r);
}
}
有同样的问题。我在默认情况下抛出错误并添加一个迭代所有枚举值的静态初始化程序。简单但很快失败。如果你有一些单元测试覆盖率，它就可以了。
public class HolidayCalculations {
public static Date getDate(Holiday holiday, int year) {
switch (holiday) {
case AllSaintsDay:
case AscensionDay:
return new Date(1);
default:
throw new IllegalStateException("getDate(..) for "+holiday.name() + " not implemented");
}
}
static {
for (Holiday value : Holiday.values()) getDate(value, 2000);
}
}
如果项目的不同层有多个枚举必须相互对应，这可以通过测试用例来确保：
private static <T extends Enum<T>> String[] names(T[] values) {
return Arrays.stream(values).map(Enum::name).toArray(String[]::new);
}
@Test
public void testEnumCompleteness() throws Exception {
Assert.assertArrayEquals(names(Enum1.values()), names(Enum2.values()));
}