0Pricing
Java Academy · 课时

带字段和方法的枚举

为枚举添加行为

带字段和方法的枚举 是 CoddyKit 上的免费 Java Academy 课时。 这是第 1 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Java Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Java Academy 课程共包含 4 节课。

枚举是完整的类

Java 的 enum 远不只是常量列表。它是真正的类，而它的实例就是这些常量。

这意味着枚举和其他类一样可以拥有字段、构造方法和方法。

public class Main {
    enum Direction { NORTH, SOUTH, EAST, WEST }
    public static void main(String[] args) {
        Direction d = Direction.NORTH;
        System.out.println(d + " is a " + d.getClass().getSuperclass().getSimpleName());
    }
}

添加字段

您可以为每个常量附加数据。声明一个 final 字段和一个构造方法，然后在每个常量后面的括号中传入值。

public class Main {
    enum Planet {
        EARTH(9.81), MARS(3.71), JUPITER(24.79);
        private final double gravity;
        Planet(double gravity) { this.gravity = gravity; }
        double gravity() { return gravity; }
    }
    public static void main(String[] args) {
        System.out.println("Mars gravity: " + Planet.MARS.gravity());
    }
}

枚举构造方法是私有的

枚举构造方法隐式为private。您不能对枚举调用 new；JVM 会在类加载时创建这些常量，并且只创建一次。

这保证了实例集合是固定且有限的。

public class Main {
    enum Coin {
        PENNY(1), NICKEL(5), DIME(10), QUARTER(25);
        private final int cents;
        Coin(int cents) { this.cents = cents; }
        int cents() { return cents; }
    }
    public static void main(String[] args) {
        int total = Coin.QUARTER.cents() + Coin.DIME.cents();
        System.out.println("Total cents: " + total);
    }
}

多个字段

一个常量可以携带多项数据。这里每颗行星都存储质量和半径。

public class Main {
    enum Planet {
        EARTH(5.976e24, 6.37814e6),
        MARS(6.421e23, 3.3972e6);
        private final double mass, radius;
        Planet(double mass, double radius) { this.mass = mass; this.radius = radius; }
        double surfaceGravity() {
            final double G = 6.67300E-11;
            return G * mass / (radius * radius);
        }
    }
    public static void main(String[] args) {
        System.out.printf("Earth g = %.2f%n", Planet.EARTH.surfaceGravity());
    }
}

实例方法

枚举方法可以根据常量自身的字段计算结果，就像普通实例方法一样。

public class Main {
    enum Size {
        SMALL(8), MEDIUM(12), LARGE(16);
        private final int ounces;
        Size(int ounces) { this.ounces = ounces; }
        int ounces() { return ounces; }
        double liters() { return ounces * 0.0295735; }
    }
    public static void main(String[] args) {
        System.out.printf("Large = %.2f L%n", Size.LARGE.liters());
    }
}

内置名称与 ordinal

每个枚举都会获得 name()（确切的标识符）和 ordinal()（从零开始的位置）。

请优先存储您自己的数据，而不要依赖 ordinal()，因为重新排列常量后它会失效。

public class Main {
    enum Day { MON, TUE, WED }
    public static void main(String[] args) {
        for (Day d : Day.values()) {
            System.out.println(d.name() + " -> ordinal " + d.ordinal());
        }
    }
}

values 与 valueOf

编译器会生成两个静态辅助方法：

  • values() 返回包含所有常量的数组。
  • valueOf(String) 按名称查找常量，找不到时会抛出异常。
public class Main {
    enum Status { ACTIVE, PAUSED, CLOSED }
    public static void main(String[] args) {
        System.out.println("count: " + Status.values().length);
        Status s = Status.valueOf("PAUSED");
        System.out.println("parsed: " + s);
    }
}

重写 toString

您可以重写 toString()，为常量提供更友好的标签，同时保留供代码使用的常量名称。

public class Main {
    enum Priority {
        LOW, MEDIUM, HIGH;
        @Override public String toString() {
            return name().charAt(0) + name().substring(1).toLowerCase();
        }
    }
    public static void main(String[] args) {
        for (Priority p : Priority.values()) System.out.println(p);
    }
}

枚举用于分支语句

枚举可以很好地用于分支语句。在现代分支表达式中，您可以获得完备性检查，并且不会发生贯穿执行。

public class Main {
    enum Traffic { RED, YELLOW, GREEN }
    static String action(Traffic t) {
        return switch (t) {
            case RED -> "Stop";
            case YELLOW -> "Slow down";
            case GREEN -> "Go";
        };
    }
    public static void main(String[] args) {
        System.out.println(action(Traffic.GREEN));
    }
}

静态查找映射

一种常见模式是创建一个从字段反向映射到常量的静态映射，并在静态初始化器中构建一次。

import java.util.HashMap;
import java.util.Map;

public class Main {
    enum Op {
        PLUS("+"), MINUS("-");
        private final String symbol;
        Op(String symbol) { this.symbol = symbol; }
        private static final Map<String, Op> BY_SYMBOL = new HashMap<>();
        static { for (Op o : values()) BY_SYMBOL.put(o.symbol, o); }
        static Op fromSymbol(String s) { return BY_SYMBOL.get(s); }
    }
    public static void main(String[] args) {
        System.out.println(Op.fromSymbol("-"));
    }
}

枚举实现接口

枚举可以实现接口，让各个常量接入通用代码。

public class Main {
    interface Describable { String describe(); }
    enum Animal implements Describable {
        DOG, CAT;
        public String describe() { return "A " + name().toLowerCase(); }
    }
    public static void main(String[] args) {
        Describable d = Animal.DOG;
        System.out.println(d.describe());
    }
}

快速检查

检验您对枚举字段的理解。

回顾

您已经了解到枚举是完整的类：

  • 常量可以持有通过私有构造函数设置的字段。
  • 枚举可以拥有实例方法并重写 toString()。
  • values() 和 valueOf() 会由编译器为您生成。
  • 枚举可以实现接口，并且应优先使用字段，而不是 ordinal()。

接下来将学习使用抽象方法实现每个常量的独有行为。

public class Main {
    enum Greeting { HELLO; String text() { return "Hi"; } }
    public static void main(String[] args) {
        System.out.println("Enum fields recap: " + Greeting.HELLO.text());
    }
}

常见问题解答

「带字段和方法的枚举」课时是免费的吗？

是的 — 「带字段和方法的枚举」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Java Academy 课程的其余内容，请升级到 CoddyKit PRO。 Java Academy 课程共包含 4 节课。

「带字段和方法的枚举」这节课中我会学到什么？

为枚举添加行为 你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Java Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Java Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 1 节课，共 4 节。

「带字段和方法的枚举」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Java Academy 课中编写并运行代码吗？

能。每节 Java Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 带字段和方法的枚举
  2. 枚举中的抽象方法
  3. EnumSet
  4. EnumMap
← 返回 Java Academy