Understanding Java Enums: Usage, Switch Cases, Singleton Implementation, and Database Integration

Java enums are a powerful language feature that can make code more elegant and type‑safe. The article begins by introducing a simple enum definition and shows how to create and iterate over its values.

public enum Chenmo {
    WANGER, WANGSAN, WANGSI
}

Iterating over the enum values is straightforward:

for (Chenmo e : Chenmo.values()) {
    System.out.println(e);
}

Using an enum as the condition in a switch statement improves readability and prevents accidental string mismatches:

Chenmo key = Chenmo.WANGER;
switch (key) {
    case WANGSI:
        System.out.println("今天我送出一个CSDN大鼠标垫");
        break;
    case WANGSAN:
        System.out.println("今天我被坑一个CSDN学院年卡");
        break;
    default:
        System.out.println("今天我一边高兴，一边失落");
        break;
}

The article then discusses the recommended way to implement a singleton using an enum, as advocated by Effective Java . The enum‑based singleton is concise and automatically provides serialization safety and thread safety.

public enum SingleTon {
    INSTANCE;
    public void method() {
        System.out.println("我很快乐！");
    }
}

Next, the article shows how enums can be mapped to database fields with MyBatis. A more complex enum CheckType includes an integer key and a descriptive text, plus a static parse method for conversion.

public enum CheckType {
    NO_PASS(0, "未通过"),
    PASS(1, "通过");
    private int key;
    private String text;
    private CheckType(int key, String text) {
        this.key = key;
        this.text = text;
    }
    public int getKey() { return key; }
    public String getText() { return text; }
    private static final Map<Integer, CheckType> map = new HashMap<>();
    static { for (CheckType d : CheckType.values()) { map.put(d.key, d); } }
    public static CheckType parse(Integer index) { return map.getOrDefault(index, null); }
}

A MyBatis typeHandler uses this parse method to convert the integer column check_type into the appropriate enum instance.

public class CheckTypeHandler extends BaseTypeHandler<CheckType> {
    @Override
    public CheckType getNullableResult(ResultSet rs, String column) throws SQLException {
        return CheckType.parse(rs.getInt(column));
    }
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, CheckType val, JdbcType jt) throws SQLException {
        ps.setInt(i, val.getKey());
    }
    // other overrides omitted for brevity
}

Finally, the article addresses a common question: do enums consume more memory than static constants? The author argues that the difference is negligible and that the benefits of type safety and built‑in functionality outweigh any minor overhead.