替换switch语句Java

Question

我一直想知道是否有办法让我替换当前的switch语句。下面是我所拥有的代码示例，虽然我的声明要长得多，而且只会变大。 switch方法通过文件读取器调用，因此它读取一行，然后调用此函数并赋值。

public static void example(String action, String from, String to){
 switch (action) {
           case ("run"):
                runTo(from,to);
                break;
           case ("walk"):
                walkTo(from,to);
                break;
           case ("hide"):
                hideAt(to);
                break;
            }
 }

编辑：我很好奇是否有更好的方法，而不是像上面的场景一样使用switch语句。

我已经更新了一些示例以使其更有意义。一些方法调用不需要使用所有参数。

Answer 1

对于Java 7及更低版本，我们可以为函数实现声明一个接口。

对于Java 8+，我们可以使用Function接口。

接口：

public interface FunctionExecutor {
    public Object execute(String from,String to);

}

功能背景：

public class FunctionContect {
   HashMap<String, FunctionExecutor> context=new HashMap<String, FunctionExecutor>();

    public void register(String name,FunctionExecutor function){
        context.put(name, function);
    }

   public Object call(String name,String from,String to){
      return    context.get(name).execute(from, to);
   }

   public FunctionExecutor get(String name){
      return context.get(name);
   }

  }

功能实现：

public class RunFunctionImpl implements FunctionExecutor{

    @Override
    public Object execute(String from, String to) {
       System.out.println("function run");
        return null;
   }

}

// OTHER FUCNTIONS

注册功能：

    FunctionContect contex = new FunctionContect();
    contex.register("run", new RunFunctionImpl());
    contex.register("walk", new WalkFunctionImpl());
    contex.register("hide", new HideFunctionImpl());

呼叫功能

 context.call(action, from, to);

要么

 context.get(action).execute(from,to);

Answer 2

我不完全确定你想要达到的目标。如果您不想继续添加新内容

case ("ccc"):
  Lmn(b,c,i);
  break;         

块。

您可以在HashMap<string, method>中散列方法，并使用键从地图中获取方法并执行它。

Answer 3

如果你在同一个变量上重复切换案例，请使用方法qazxsw poi，qazxsw poi和qazxsw poi。然后你可以把内心翻出来：

f

可以面向对象处理为：

g

然后，一旦必须提供特定的C：

h

这看起来是间接的，但实际上提高了开发质量。添加新案例并不意味着搜索所有交换机案例。

一个案例（“aaa”）的代码全部在一个类中，具有自己的专用字段。这可以简化事情并提供更好的概述。

Answer 4

摆脱开关的一个可能选择是使用函数的hashmap：

void f(String a) {
    switch (a) {
    case "aaa": ... ; break;
    ...
    }
}

void g(String a) {
    switch (a) {
    case "aaa": ... ; break;
    case "bbb": ... ; break;
    case "ccc": ... ; break;
    ...
    }
}

void h(String a) {
    switch (a) {
    case "aaa": ... ; break;
    ...
    }
}

Answer 5

用方法调用替换开关肯定不是完全没有意义的@Stultuske。通常使用方法继承，因此具有相同父类的不同子类会覆盖常规方法，您不必检查子类的类型。

另一方面，您的案例看起来像工厂方法，但参数有点疯狂混合。我会建议

class C {
    public f() { }
    public g() { }
    public h() { }
}

class Aaa extends C {
    @Override
    public f() { test3(b,c); } // Or even just the body of test3
    @Override
    public g() { }
    @Override
    public h() { }
}

class Bbb extends C {}
class Ccc extends C {}

与

    C c;
    switch (a) {
    case "aaa": c = new Aaa(); break;
    case "bbb": c = new Bbb(); break;
    case "ccc": c = new Ccc(); break;
    ...
    }

    c.f(...);

    c.g(...);

    c.h(...);

到包装构造函数。对于“ccc”情况，你必须考虑别的东西（例如默认参数），或者你总是有未使用的参数

private String stringMethod(final String action, final String source) {

    final Function<String, String> toLowerFunction = String::toLowerCase;
    final Function<String, String> toUpperFunction = String::toUpperCase;

    final HashMap<String, Function<String, String>> stringFunctions = new HashMap<>();
    stringFunctions.put("toLower", toLowerFunction);
    stringFunctions.put("toUpper", toUpperFunction);

    return stringFunctions.get(action).apply(source);
}

。