基于java中依赖枚举的某些条件逻辑设置类变量的最佳方法是什么？

Question

我试图根据我需要执行的一些计算或条件逻辑将值从一个枚举映射到另一个枚举，以便为类变量设置正确的枚举值。 如果不使用太多的if / else，switch语句，我怎么能这样做呢？

Enum BRAND {
 MINI, FERRARI, PAGANI
}

和另一个枚举

Enum ENGINE {
LEVEL1, LEVEL2, LEVEL3
}

我有一个类：

Class Car() {

 int model;
 int year;
 Engine engine;

 // I want to calculate set the engine depending on the brand based on conditional logic
 public carEngineCalculator (Brand b) {
   Car mycar = new Car();

   if (mycar.isSuperCar(b) {
    if (mycar.isCrazyGood(b)) {
        mycar.engine = ENGINE.LEVEL1;
    } else {
        mycar.engine = ENGINE.LEVEL2;
    }
   } else {
    mycar.engine = ENGINE.LEVEL3;
   }
   ... //And the conditions can be more complex
 }

 public boolean isSuperCar(Brand b) {
    if (b.FERRARI || b.PAGANI) {
     return true;
    } 
    return false;
 }

 public boolean isCrazyGood(Brand b) {
    return ...;
 }
} 

可能需要检查多个这样的条件才能设置值，我想避免讨厌if / else / switch语句，如上所示。 有没有更实用的方法来做到这一点。

Answer 1

首先，将您的isSuperCar和isCrazyGood方法移动到Brand ，而不是让它们采用Brand参数。 您可以类似地向Engine添加一个静态工厂方法，该方法封装了您尝试编码的逻辑。 这并不完全避免“令人讨厌的if / else / switch语句”，但它可能更具可读性。

例如：

public Car(Brand b) {
  this.engine = Engine.forBrand(b);
}

接着：

enum Engine {
  LEVEL1, LEVEL2, LEVEL3

  public static Engine forBrand(Brand b) {
    if (b.isSuperCar()) {
      return b.isCrazyGood() ? LEVEL1 : LEVEL2;
    }
    return LEVEL3;
  }
}

另请注意，您的isSuperCar方法可以简单地为：

return b.equals(Brand.FERRARI) || b.equals(Brand.PAGANI);

if (...) return true; else return false;永远不需要写if (...) return true; else return false; if (...) return true; else return false; 或类似的东西 - 直接在if语句中使用布尔表达式。

Answer 2

如果映射是Brand和Engine的一对一，您可以执行以下操作：

enum Brand {
    MINI(Engine.LEVEL1),
    FERRARI(Engine.LEVEL2),
    PAGANI(Engine.LEVEL3);

    private final Engine engine;

    private Brand(Engine engine) {
        this.engine = engine;
    }

    public final Engine getEngine() {
        return engine;
    }
}

另外一个选项：

enum Brand {
    MINI(false, false),
    FERRARI(true, true),
    PAGANI(false, true);

    private final boolean superCar;
    private final boolean crazyGood;

    private Brand(boolean superCar, boolean crazyGood) {
        this.superCar = superCar;
        this.crazyGood = crazyGood;
    }

    public final Engine getEngine() {
        if (superCar) {
            return (crazyGood) ? Engine.LEVEL1 : Engine.LEVEL2;
        }
        return Engine.LEVEL3;
    }
}

如果映射不是一对一的，并且您需要以某种方式根据某些参数动态计算引擎，您还可以使用：

enum Brand {
    MINI {
        @Override
        public Engine getEngine(boolean superCar, boolean crazyGood) {
            return (superCar && crazyGood) ? Engine.LEVEL1 : Engine.LEVEL2;
        }
    },
    FERRARI {
        @Override
        public Engine getEngine(boolean superCar, boolean crazyGood) {
            return superCar ? Engine.LEVEL1 : Engine.LEVEL3;
        }
    },
    PAGANI {
        @Override
        public Engine getEngine(boolean superCar, boolean crazyGood) {
            return Engine.LEVEL3;
        }
    };

    public abstract Engine getEngine(boolean superCar, boolean crazyGood);
}

或类似的东西，你有一些默认值，并覆盖特殊情况：

enum Brand {
    MINI,
    FERRARI {
        @Override
        public Engine getEngine(boolean superCar, boolean crazyGood) {
            return superCar ? Engine.LEVEL1 : Engine.LEVEL3;
        }
    },
    PAGANI;

    public Engine getEngine(boolean superCar, boolean crazyGood) {
        return Engine.LEVEL3;
    }
}

使用枚举有很多可能性，我实际上更喜欢复杂if / else或switch语句。 当然这取决于你想要做什么，因为没有提供太多的信息，我真的无法给出最好的答案。 希望这对你有所帮助。

Answer 3

正如我所说的那样使用谓词看起来像这样：

public enum Brand {
    MINI,
    FERRARI,
    PAGANI
}

public enum Engine {
    LEVEL1,
    LEVEL2,
    LEVEL3
}

public class Entry {
    public final Predicate<Car> pred;
    public final Engine engine;

    public Entry(Predicate<Car> pred, Engine engine) {
        this.pred = pred;
        this.engine = engine;
    }
}

public class Car {
    int model;
    int year;
    Engine engine;

    public void carEngineCalculator(Brand b) {
        Car mycar = new Car();

        List<Entry> cases = new ArrayList<>();
        cases.add(new Entry(c -> c.isSuperCar(b) && c.isCrazyGood(b), Engine.LEVEL1));
        cases.add(new Entry(c -> c.isSuperCar(b) && !c.isCrazyGood(b), Engine.LEVEL2));
        cases.add(new Entry(c -> !c.isSuperCar(b), Engine.LEVEL3));

        mycar.engine = cases.stream().filter(x -> x.pred.test(mycar)).findFirst().get().engine;

    }

    public boolean isSuperCar(Brand b) {
        if ((b == Brand.FERRARI) || (b == Brand.PAGANI)) {
            return true;
        }
        return false;
    }

    public boolean isCrazyGood(Brand b) {
        return false;
    }
}

您创建一个包含谓词和结果的列表，并使用stream，filter和findFirst来浏览列表并找到正确的结果。 如果条件比你不需要谓词更简单并且测试它有点不同。

Answer 4

我可能会把这个品牌存放在Car类中，但这是另一个问题。 我会在Car类中有一个静态地图，跟踪每个品牌的引擎（正如Ralf Renz建议的那样）：

Class Car {

 int model;
 int year;
 Engine engine;
 static Map<Brand, Engine> carEngineMap = new HashMap<>();

 public static void setBrandEngine(Brand b, Engine e) {
   carEngineMap.put(b, e);
 }

 // I want to calculate set the engine depending on the brand based on conditional logic
 public carEngineCalculator (Brand b) {
   Car mycar = new Car();

   mycar.engine = carEngineMap.get(b);
 }

 public boolean isSuperCar(Brand b) {
    if (b.FERRARI || b.PAGANI) {
     return true;
    } 
    return false;
 }

 public boolean isCrazyGood(Brand b) {
    return ...;
 }
}

然后，您将为每个品牌分别设置条件，例如

Car.setBrandEngine(Brand.FERRARI, Engine.LEVEL2);
Car.setBrandEngine(Brand.PAGANI, Engine.LEVEL1);
...

Answer 5

使用谓词创建枚举，CONDITION（品牌，引擎，条件）并在那里提供您的条件。 然后：

Conditions.values().foreach(condition -> {
    condition.isApplicable(variblesDto) ? return condition.apply() : continue;
});

并且您在需要新条件时随时更新您的Enum。 它也将按照Enum的顺序排列，所以你可以玩它