Java 中在 Switch Case 里使用 Enum

简介

在 Java 编程中，enum（枚举）是一种特殊的数据类型，它允许我们定义一组固定的常量。switch 语句则是一种条件控制结构，用于根据不同的值执行不同的代码块。将 enum 与 switch 语句结合使用，可以使代码更加清晰、易读和可维护。本文将深入探讨在 Java 中如何在 switch 语句里使用 enum，包括基础概念、使用方法、常见实践以及最佳实践。

Enum 基础概念

enum 是 Java 5 引入的一个特性，用于定义一组命名常量。例如，一周有七天，我们可以定义一个 Day 枚举类型：

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

这里，Day 是一个枚举类型，它包含了七个常量值。每个常量都是 Day 类型的一个实例。枚举类型的常量默认是 public static final 的，这意味着它们可以通过枚举类型名直接访问，例如 Day.MONDAY。

在 Switch Case 中使用 Enum 的方法

在 switch 语句中使用 enum 非常直观。下面是一个简单的示例，根据不同的 Day 输出相应的信息：

public class EnumSwitchExample {
    public static void main(String[] args) {
        Day day = Day.FRIDAY;
        switch (day) {
            case MONDAY:
                System.out.println("Start of the workweek.");
                break;
            case TUESDAY:
            case WEDNESDAY:
            case THURSDAY:
                System.out.println("Midweek.");
                break;
            case FRIDAY:
                System.out.println("Nearing the weekend!");
                break;
            case SATURDAY:
            case SUNDAY:
                System.out.println("Weekend time!");
                break;
            default:
                System.out.println("Invalid day.");
        }
    }
}

在这个例子中，switch 语句根据 day 的值来执行相应的代码块。注意，case 标签直接使用枚举常量名，不需要使用枚举类型名进行限定。

常见实践

处理业务逻辑

在实际开发中，我们经常使用 enum 和 switch 来处理业务逻辑。例如，根据订单的状态进行不同的操作：

public enum OrderStatus {
    PENDING, APPROVED, REJECTED, DELIVERED
}

public class OrderProcessor {
    public static void processOrder(OrderStatus status) {
        switch (status) {
            case PENDING:
                System.out.println("Processing pending order...");
                // 处理待处理订单的逻辑
                break;
            case APPROVED:
                System.out.println("Shipping approved order...");
                // 处理已批准订单的逻辑
                break;
            case REJECTED:
                System.out.println("Notifying customer about rejected order...");
                // 处理已拒绝订单的逻辑
                break;
            case DELIVERED:
                System.out.println("Order delivered.");
                // 处理已交付订单的逻辑
                break;
            default:
                System.out.println("Invalid order status.");
        }
    }
}

实现状态机

enum 和 switch 还可以用于实现简单的状态机。例如，一个简单的电梯状态机：

public enum ElevatorState {
    IDLE, MOVING_UP, MOVING_DOWN, DOORS_OPEN
}

public class Elevator {
    private ElevatorState state;

    public Elevator() {
        state = ElevatorState.IDLE;
    }

    public void transition(ElevatorState newState) {
        switch (state) {
            case IDLE:
                if (newState == ElevatorState.MOVING_UP || newState == ElevatorState.MOVING_DOWN) {
                    state = newState;
                    System.out.println("Elevator is now " + newState);
                } else {
                    System.out.println("Invalid transition from IDLE.");
                }
                break;
            case MOVING_UP:
                if (newState == ElevatorState.DOORS_OPEN || newState == ElevatorState.MOVING_DOWN) {
                    state = newState;
                    System.out.println("Elevator is now " + newState);
                } else {
                    System.out.println("Invalid transition from MOVING_UP.");
                }
                break;
            case MOVING_DOWN:
                if (newState == ElevatorState.DOORS_OPEN || newState == ElevatorState.MOVING_UP) {
                    state = newState;
                    System.out.println("Elevator is now " + newState);
                } else {
                    System.out.println("Invalid transition from MOVING_DOWN.");
                }
                break;
            case DOORS_OPEN:
                if (newState == ElevatorState.MOVING_UP || newState == ElevatorState.MOVING_DOWN) {
                    state = newState;
                    System.out.println("Elevator is now " + newState);
                } else {
                    System.out.println("Invalid transition from DOORS_OPEN.");
                }
                break;
            default:
                System.out.println("Invalid state.");
        }
    }
}

最佳实践

使用常量代替魔法数字

在传统的 switch 语句中，我们可能会使用数字作为 case 标签，这使得代码难以理解和维护。使用 enum 可以避免这种情况，使代码更加清晰：

// 不推荐：使用魔法数字
public class OldStyleSwitch {
    public static void process(int status) {
        switch (status) {
            case 1:
                System.out.println("Pending");
                break;
            case 2:
                System.out.println("Approved");
                break;
            case 3:
                System.out.println("Rejected");
                break;
            default:
                System.out.println("Invalid status");
        }
    }
}

// 推荐：使用 enum
public enum NewStyleStatus {
    PENDING, APPROVED, REJECTED
}

public class NewStyleSwitch {
    public static void process(NewStyleStatus status) {
        switch (status) {
            case PENDING:
                System.out.println("Pending");
                break;
            case APPROVED:
                System.out.println("Approved");
                break;
            case REJECTED:
                System.out.println("Rejected");
                break;
            default:
                System.out.println("Invalid status");
        }
    }
}

提供默认行为

在 switch 语句中，始终提供 default 分支是一个好习惯，以处理意外情况：

public enum Color {
    RED, GREEN, BLUE
}

public class ColorProcessor {
    public static void processColor(Color color) {
        switch (color) {
            case RED:
                System.out.println("This is red.");
                break;
            case GREEN:
                System.out.println("This is green.");
                break;
            case BLUE:
                System.out.println("This is blue.");
                break;
            default:
                System.out.println("Unknown color.");
        }
    }
}

保持代码简洁

尽量保持 switch 块中的代码简洁。如果代码逻辑过于复杂，可以考虑将其提取到单独的方法中：

public enum Shape {
    CIRCLE, SQUARE, TRIANGLE
}

public class ShapeProcessor {
    public static void processShape(Shape shape) {
        switch (shape) {
            case CIRCLE:
                drawCircle();
                break;
            case SQUARE:
                drawSquare();
                break;
            case TRIANGLE:
                drawTriangle();
                break;
            default:
                System.out.println("Invalid shape.");
        }
    }

    private static void drawCircle() {
        System.out.println("Drawing a circle...");
    }

    private static void drawSquare() {
        System.out.println("Drawing a square...");
    }

    private static void drawTriangle() {
        System.out.println("Drawing a triangle...");
    }
}

小结

在 Java 中，将 enum 与 switch 语句结合使用可以提高代码的可读性、可维护性和安全性。通过定义清晰的枚举常量，我们可以避免使用魔法数字，使代码逻辑更加直观。在实际应用中，要遵循最佳实践，如提供默认行为和保持代码简洁，以确保代码的质量和可扩展性。