枚举——用接口模拟可伸缩的枚举

傷城~ 2024-03-16 09:36 48阅读 0赞

在 java 中，普通类默认继承了 Object 类， 如果显示声明 extends ，则变为继承指定的类，但无论如何，所有类的最终继承都指向了 Object 类，因此，一切实例都可以被 Object 接受。

枚举出现于 jdk1.5 ，所有的枚举隐式继承了 Enum 类。区别于Object，枚举的继承是无需声明也无法声明的, 所有的自定义枚举都只能直接继承 Enum 类，枚举类也无法继承普通类也无法继承另一个枚举类。

枚举的这种限制让它可以被 jvm 优化，提供了优异的性能，自 jdk 1.5 之后，单例的最佳实现就是枚举，jvm 帮我们优化处理好了一切，包括反射，克隆，序列化等都无法破坏枚举的单例。

但同时，枚举的种种封闭特性对于伸缩性则造成了一定限制，因为枚举在写完之后就被固定，除非更改源码，否则无法增加枚举类型，对于使用者来说某些时候不太方便。

幸好，java 也考虑到了这一点，让枚举可以实现接口，因此，我们可以通过接口来模拟枚举的扩展。

举例 ：

我们需要设计一个计算器，如果用单纯的枚举，只能做已定义好的计算，不方便扩展

public class Operator {
        public enum BaseOperation {
            PLUS,
            MINUS,
            TIMES,
            DIVIDE
        }
        public static double operate(BaseOperation operation, double x, double y) {
            Objects.requireNonNull(operation, "操作符不能为 null");
            switch (operation) {
                case PLUS:
                    return plus(x, y);
                case MINUS:
                    return minus(x, y);
                case TIMES:
                    return times(x, y);
                case DIVIDE:
                    return divide(x, y);
            }
            return 0;
        }
    
        public static double plus(double x, double y) {
            return x + y;
        }
    
        public static double minus(double x, double y) {
            return x - y;
        }
    
        public static double times(double x, double y) {
            return x * y;
        }
    
        public static double divide(double x, double y) {
            return x / y;
        }
    
    
        public static void main(String[] args) {
            System.out.println(operate(BaseOperation.PLUS, 22, 3));
            System.out.println(operate(BaseOperation.TIMES, 22, 3));
    
        }
    }

使用接口来扩展枚举功能，则代码更清晰高效,而且更加方便使用者扩展自定义，实现更强大的功能

public class Operator {
        public enum BaseOperation implements Operation {
            PLUS() {
                @Override
                public double operate(double x, double y) {
                    return x + y;
                }
            },
            MINUS() {
                @Override
                public double operate(double x, double y) {
                    return x - y;
                }
            },
            TIMES() {
                @Override
                public double operate(double x, double y) {
                    return x * y;
                }
            },
            DIVIDE() {
                @Override
                public double operate(double x, double y) {
                    return x / y;
                }
            }
        }
    
        public enum AdvOperation implements Operation {
            MOD() {
                @Override
                public double operate(double x, double y) {
                    return x % y;
                }
            }
        }
        public static double operate(Operation operation, double x, double y) {
            Objects.requireNonNull(operation, "操作符不能为 null");
            return operation.operate(x, y);
        }
    
        public static void main(String[] args) {
            System.out.println(operate(BaseOperation.PLUS, 22, 3));
            System.out.println(operate(BaseOperation.TIMES, 22, 3));
            System.out.println(operate(AdvOperation.MOD,20,4));
        }
    }

总结：

1.  使用枚举可以实现将预定义的操作类型规范起来，避免使用 String 和 int 等数据范围太大导致的可能的逻辑错误
2.  但使用枚举也导致了扩展性方面的问题，因为枚举本身无法被扩展
3.  使用接口可以避免此不足，并且接口非常容易扩展；而且，开发中也更鼓励用接口代替直接的实现类