在大多数情况下，事实证明扩展枚举枚举并不是好注意。如果一个扩展类型的元素是基本类型的实例，但反过来不成立，这会令人困惑。要枚举基类型以及其扩展类型的所有元素，也没有很好的办法。最后，可扩展性会让设计和实现的许多方面变得复杂。

可扩展的枚举类型至少有一个很有说服力的使用场景，这就是运算码，也称做opcode。

有一种很好的方式可以使用枚举类型来实现这种效果。基本的想法是：利用枚举类型可以实现任意接口这一事实，为opcode类型定义一个接口，并定义一个枚举，作为该接口的标准实现。例如第三十四条中的Operation类型的扩展版本：

public interface Operation {
    
    double apply(double x, double y);
    
}
 enum BasicOperation implements Operation {
    PLUS("+") {
        public double apply(double x, double y) {return x + y;}
    },
    MINUS("-") {
        public double apply(double x, double y) {return x - y;}
    },
    TIMES("*") {
        public double apply(double x, double y) {return x - y;}
    },
    DIVIDE("/") {
        public double apply(double x, double y) {return x - y;}
    };
    private final String symbol;
    BasicOperation(String symbol) {
        this.symbol = symbol;
    }
    public String toString() {
        return symbol;
    }

}

你可以定义另外一个枚举类型，它实现这个接口，并用这个新类型的实例代替基本类型。例如，假设你想要定义一个上述操作类型的扩展，由求幂和求余操作组成。你所要做的就是编写一个枚举类型，让它实现Operation接口：

public enum ExtendedOperation implements Operation {

    EXP("^"){
        @Override
        public double apply(double x, double y) {
            return Math.pow(x , y);
        }
    },
    REMAINDER("%"){
        @Override
        public double apply(double x, double y) {
            return x % y;
        }

    };

    private final String symbol;
    ExtendedOperation(String symbol) {
        this.symbol = symbol;
    }
}

注意，在枚举中，不必像在不可扩展的枚举中所做的那样，利用特定于实例的方法实现来声明抽象的apply方法。这是因为抽象的方法是接口的一部分。

不仅可以在任何需要“基本枚举”的地方单独传递一个"扩展枚举"的实例，而且除了那些基本类型的元素之外，还可以传递完整的扩展枚举类型，并使用它的元素。通过下面这个测试程序，体验一下上面定义过的所有扩展过的操作：

 

 public static class test1 {
        public static void main(String[] args) {
            double x = 2;
            double y = 4;
            test(ExtendedOperation.class, x, y);
        }
        private static <T extends Enum<T> & Operation> void test(Class<T> opSet,
                                                                 double x, double y) {
            for (Operation op : opSet.getEnumConstants())
                System.out.printf("%f %s %f= %f%n", x, op, y, op.apply(x, y));
        }
    }

结果：

2.000000 EXP 4.000000= 16.000000
2.000000 REMAINDER 4.000000= 2.000000

Process finished with exit code 0

第二种方法是使用Collection<? extends Operation>，这个有限的通配符类型，作为opSet参数的类型：

public class test2 {
    public static void main(String[] args) {
        double x = 2;
        double y = 4 ;
    
        test(Arrays.asList(ExtendedOperation.values()),x,y);
    }
    private static void test(Collection<? extends Operation> opSet,double x, double y) {
        for (Operation op : opSet) {
            System.out.printf("%f %s %f= %f%n", x, op, y, op.apply(x, y));
        }
    }
}

结果：

2.000000 EXP 4.000000= 16.000000
2.000000 REMAINDER 4.000000= 2.000000

Process finished with exit code 0

用接口模拟可伸缩枚举有个小小的不足，即无法将实现从一个枚举类型继承到另一个枚举类型。在上Operation的实例中，保存和获取与某项操作相关联的符号的逻辑代码，可以复制到BasicOperation和ExtendedOperation中。在这个例子中是可以的，因为复制的代码非常少。如果共享功能比较多，则可以将它封装在一个辅助类或者静态辅助方法中，来避免代码的复制工作。

总而言之，虽然无法编写可扩展的枚举类型，却可以通过编写接口以及实现该接口的基础枚举类型，对它进行模拟。这样允许客户端编写自己的枚举来实现接口。如果API是根据接口编写的，那么在可以使用基础枚举类型的任何地方，也就可以使用这些枚举。

所有文章无条件开放，顺手点个赞不为过吧！