Question

假设我有这段代码：

public Foo {
    public enum Bar {FooBar, BarFoo, FooFoo, BarBar}
    public Foo (Bar bar) {
        //Do something
    }
}

现在，在创建对象时，我有几种不同的情况可以创建migth：FooBar, BarFoo, FooFoo, BarBar。根据这些情况，我如何为每种情况执行不同的方法？我想我想做一些像这样的事情：

public Foo {
    public enum Bar {FooBar, BarFoo, FooFoo, BarBar}
    public Foo (Bar bar) {
        switch (bar) {
            case FooBar: fooBar(bar); break;
            case BarFoo: barFoo(bar); break;
            case FooFoo: fooFoo(bar); break;
            case BarBar: barBar(bar); break;
            default: break;
        }
    }
    void fooBar (Bar bar) {
        //Treat this as the constructor class for case FooBar
    }
    void barFoo (Bar bar) {
        //Treat this as the constructor class for case barFoo
    }
    void fooFoo (Bar bar) {
        //Treat this as the constructor class for case fooFoo
    }
    void barBar (Bar bar) {
        //Treat this as the constructor class for case barBar
    }
}

另外，这是一种不好的做法吗？为每个案例创建一个单独的类并删除枚举会更好吗？

Answer 1

将特定于案例的代码移动到enum Bar，并在构造函数中使用覆盖：

public Foo {
    public enum Bar {
        FooBar {
            @Override
            public void configure(Foo obj) {
                ... // Code specific to this enum case
            }
        }
    ,   BarFoo {
            @Override
            public void configure(Foo obj) {
                ... // Code specific to this enum case
            }
        }
    ,   FooFoo {
            @Override
            public void configure(Foo obj) {
                ... // Code specific to this enum case
            }
        }
    ,   BarBar {
            @Override
            public void configure(Foo obj) {
                ... // Code specific to this enum case
            }
        }
    ;
    public abstract void configure(Foo obj);
    }
    public Foo (Bar bar) {
        bar.configure(this);
    }
}

configure(Foo)的每个覆盖中的代码都可以访问构造函数正在配置的Bar实例，从而可以用虚拟调度替换switch。

Answer 2

我在枚举中实现一个方法来直接执行它。它删除了不必要的switch语句和方法。

public class Foo {

    public Foo (Bar bar) {
        bar.execute();
    }

    public enum Bar {
        FooBar, BarFoo, FooFoo, BarBar;
        public void execute() {
            // TODO
            // System.out.println(this.toString());
        }
    }
}

如果您确实需要为每个枚举实例使用唯一方法，请为execute方法提取摘要，并为每个方法设置@Override。

public enum Bar {
    FooBar {
        @Override
        public void execute() { }
    }, BarFoo {
        @Override
        public void execute() { }
    }, FooFoo {
        @Override
        public void execute() { }
    }, BarBar {
        @Override
        public void execute() { }
    };

    public abstract void execute();
}

Answer 3

枚举也可以有方法，因此您可以添加抽象方法并为您需要的每个案例覆盖它，如下所示：

public enum Bar {
    FooBar {
        @Override
        public void doSomething() {
            // your code for FooBar
        }
    },
    BarFoo {
        @Override
        public void doSomething() {
            // your code for BarFoo
        }
    },
    FooFoo {
        @Override
        public void doSomething() {
            // .....
        }
    }, 
    BarBar {
        @Override
        public void doSomething() {
            // .....
        }
    };
    public abstract void  doSomething();
}

使用私有方法

3 个答案: