枚举实现接口

如果每个枚举值的行为都不同，怎么实现？

enum Operation {
    PLUS { double apply(double a, double b) { return a + b; } },
    MINUS { double apply(double a, double b) { return a - b; } };
    // 每个枚举值有自己的 apply 实现
    abstract double apply(double a, double b);
}

这就是枚举实现接口的核心用法。

基本概念

枚举本身是一种特殊的类，可以像普通类一样实现接口：

enum Color implements Drawable {
    RED, GREEN, BLUE;
}

但真正强大的是：每个枚举值可以实现接口方法，拥有不同的行为。

代码示例

基本实现

public class EnumImplementInterfaceDemo {

    interface Operation {
        double apply(double a, double b);
    }

    enum BasicOperation implements Operation {
        PLUS("+") {
            @Override
            public double apply(double a, double b) {
                return a + b;
            }
        },
        MINUS("-") {
            @Override
            public double apply(double a, double b) {
                return a - b;
            }
        },
        TIMES("*") {
            @Override
            public double apply(double a, double b) {
                return a * b;
            }
        },
        DIVIDE("/") {
            @Override
            public double apply(double a, double b) {
                if (b == 0) throw new ArithmeticException("Division by zero");
                return a / b;
            }
        };

        private final String symbol;

        BasicOperation(String symbol) {
            this.symbol = symbol;
        }

        @Override
        public String toString() {
            return symbol;
        }
    }

    public static void main(String[] args) {
        double x = 10;
        double y = 5;

        for (BasicOperation op : BasicOperation.values()) {
            System.out.println(x + " " + op + " " + y + " = " + op.apply(x, y));
        }
    }
}

策略模式应用

枚举天然适合策略模式——每种策略是一个枚举值：

public class StrategyPatternDemo {

    interface PayStrategy {
        void pay(double amount);
    }

    enum PaymentMethod implements PayStrategy {
        ALIPAY {
            @Override
            public void pay(double amount) {
                System.out.println("支付宝支付：" + amount);
            }
        },
        WECHAT {
            @Override
            public void pay(double amount) {
                System.out.println("微信支付：" + amount);
            }
        },
        CARD {
            @Override
            public void pay(double amount) {
                System.out.println("银行卡支付：" + amount);
            }
        }
    }

    public static void main(String[] args) {
        PaymentMethod.ALIPAY.pay(100);
        PaymentMethod.WECHAT.pay(200);
    }
}

实现多个接口

public class MultiInterfaceDemo {

    interface Printable {
        void print();
    }

    interface Serializable {
        byte[] toBytes();
    }

    enum Status implements Printable, Serializable {
        ACTIVE("活跃", (byte) 1),
        INACTIVE("不活跃", (byte) 0);

        private final String name;
        private final byte code;

        Status(String name, byte code) {
            this.name = name;
            this.code = code;
        }

        @Override
        public void print() {
            System.out.println(name);
        }

        @Override
        public byte[] toBytes() {
            return new byte[]{code};
        }
    }

    public static void main(String[] args) {
        Status status = Status.ACTIVE;
        status.print();
        System.out.println(Arrays.toString(status.toBytes()));
    }
}

注意事项

1. 每个枚举值单独实现：可以为每个枚举值写不同的行为
2. 抽象方法强制实现：枚举值实现接口抽象方法时，枚举本身必须是 abstract
3. 替代策略模式：枚举实现接口是策略模式的简洁实现
4. 可扩展性：虽然枚举值行为独立，但仍然是同一类型，方便统一处理