Java中枚举类中的简化方法

我有一个包含枚举的类来进行计算。 每个枚举使用外部类中的一些或所有非静态变量。然而，由于它们不能访问实例变量，我必须将它们作为参数传入

public class Outer{
    ClassA a;
    ClassB b;
    ClassC c;
    Map<MyEnum,Double> results= new EnumMap(MyEnum.class);
    private enum MyEnum{
        X{  public double calc(ClassA _a){ dostuff }           },
        Y{  public double calc(ClassB _b,ClassC _c){ dostuff } },
        Z{  public double calc(ClassA _a,ClassB _b){ dostuff } };
    }

    public void doCalc(){
        for(MyEnum item:MyEnum.values()){
            result.get(item) = item.calc(...);//Not uniform here
        }
    }
}

---

但是如果我有更多的类，参数看起来会太难看。有没有更好的方法来做这类事情？

为什么不将outer的实例传递给

calc（）

方法呢。在这种情况下，每个特定的枚举将具有相应地处理

外部

对象的逻辑，并且新的枚举不需要任何更改

class Outer {

    ClassA a;
    ClassB b;
    ClassC c;
    Map<MyEnum,Double> results= new EnumMap<MyEnum, Double>(MyEnum.class);
    private enum MyEnum{
        X{  public void calc(Outer o){ }           },
        Y{  public void calc(Outer o){  } },
        Z{  public void calc(Outer o){ } };
        abstract void calc(Outer o);
    }

    public void doCalc(){
        for(MyEnum item:MyEnum.values()){
            item.calc(this);
        }
    }
}


class ClassA {}
class ClassB {}
class ClassC {}

类外部{
甲级；
b类；
c类；
映射结果=新的EnumMap（MyEnum.class）；
私有枚举髓鞘{
X{公共无效计算（外部o）{}，
Y{公共无效计算（外部o）{}，
Z{public void calc（Outer o）{}；
抽象孔隙计算（外o）；
}
公共文件{
对于（MyEnum项：MyEnum.values（））{
项目.计算（本）；
}
}
}
类ClassA{}
类B{}
类C{}

您可以将枚举方法更改为：

public double calc(Object... params) {
    switch(this) {
        case X:
            // cast params needed for X methodology.
            // doXStuff
            break;
        case y:
            . . . 
    }
}

---

我注意到在枚举值上有不同的方法实现 在Java 8上，您可以使用双功能：

    public static class Outer {

    Map<MyEnum, Double> results = new EnumMap(MyEnum.class);

    public enum MyEnum {
        X(defaultdoStuff1()),
        Y(defaultdoStuff1()),
        Z(defaultdoStuff2());

        MyEnum(BiFunction<Object, Integer, Boolean> objectIntegerBooleanBiFunction) {
            this.handler = objectIntegerBooleanBiFunction;
        }

        private BiFunction<Object, Integer, Boolean> handler;

        private static BiFunction<Object, Integer, Boolean> defaultdoStuff2() {
            //do stuff
            return (obj, age) -> (age > 0) || obj != null;
        }

        private static BiFunction<Object, Integer, Boolean> defaultdoStuff1() {
            //do stuff
            return (obj, age) -> false;
        }
    }

}

公共静态类外部{
映射结果=新的EnumMap（MyEnum.class）；
公共枚举髓鞘{
X（defaultdoStuff1（）），
Y（defaultdoStuff1（）），
Z（defaultdoStuff2（））；
MyEnum（双功能对象布尔双功能）{
this.handler=objectIntegerBooleanBiFunction；
}
专用双功能处理器；
私有静态双函数defaultdoStuff2（）{
//做事
return（obj，age）->（age>0）| | obj！=null；
}
私有静态双函数defaultdoStuff1（）{
//做事
返回值（obj，年龄）->false；
}
}
}

令人惊讶的是，我们的代码示例看起来多么相似！尽管我对OP的设计提出了质疑，但我给出了+1，这完全是正确的：）。还有，击败了我：（@Perception:+1用于质疑OP的设计，这正是我所想的。我很有兴趣知道这里的意图。哦，别忘了，伟大的头脑都是一样的。-）在考虑我的答案时，完全没有考虑到这种可能性，但这当然会更好。虽然仍然对一些设计感到疑惑，但这是一种丑陋的方式，但我想效果很好+1。

    public static class Outer {

    Map<MyEnum, Double> results = new EnumMap(MyEnum.class);

    public enum MyEnum {
        X(defaultdoStuff1()),
        Y(defaultdoStuff1()),
        Z(defaultdoStuff2());

        MyEnum(BiFunction<Object, Integer, Boolean> objectIntegerBooleanBiFunction) {
            this.handler = objectIntegerBooleanBiFunction;
        }

        private BiFunction<Object, Integer, Boolean> handler;

        private static BiFunction<Object, Integer, Boolean> defaultdoStuff2() {
            //do stuff
            return (obj, age) -> (age > 0) || obj != null;
        }

        private static BiFunction<Object, Integer, Boolean> defaultdoStuff1() {
            //do stuff
            return (obj, age) -> false;
        }
    }

}