如何用引用每种情况下的变量的列表替换 Java 中的开关？

Question

我在这里找不到像这样的先前问题（这让我感到惊讶），所以..

我有一个有效的 Java 程序，其中一部分分析键入的输入。一些输入“选项”是以下情况下的字符串。

switch (varName.toLowerCase())  {
    case "steps":
        common.steps = true;
        break;
    case "scale":
        common.scale = true;
        break;
    case "float":
        common.fracts = false;
        break;
    case "fraction":
        common.fracts = true;
        break;
    case "spaces":
        common.spaces = false;
        break;
    ... etc.
}

在 C 或 C++ 中，我可以通过创建一个列表（它是一个包含字符串名称和变量指针的结构）来缩短这段代码，例如

LIST varAction[] = { { "steps", &common.steps },
                     { "scale", &common.scale },
                     .. etc.
                   };

然后简单地检查 i = 0 到列表大小的循环

if ( strcmp(varAction[i].name, input) == 0)  {
    *varAction[i].pointer = condition;
}

Java 切换不止一次，是维护问题，所以我想要更好的方法。

我可以使用字符串的散列在数组中使用散列索引，但这会阻止我根据需要通过代码使用特定的变量名，从而使该代码不太清晰......即我不想要做（伪代码）

hashTable[varName] instead of (for example)  

if ( common.fracts )
     { do something }

一定有更好的方法吗？有没有？提前致谢。

Answer 1

从你的问题来看，很明显你知道你不能做你说过你会在 C/C++ 中做的事情，但只是为了其他人提出这个问题：Java 没有对变量的引用。

把这个问题推到一个层次是很有诱惑力的：首先看看你为什么有varName，看看你是否可以避免它。

Java 切换不止一次，是维护问题，所以我想要更好的方法。

这表明common 应该具有此信息的访问器函数，因此开关只存在于一个地方（getter）或两个地方（getter 和 setter）。

void setThingy(String name, boolean value) {
    switch (name.toLowerCase())  {
        case "steps":
            this.steps = value;
            break;
        case "scale":
            this.scale = value;
            break;
        case "float":
            this.fracts = value;
            break;
        case "fraction":
            this.fracts = value;
            break;
        case "spaces":
            this.spaces = value;
            break;
        // ... etc.
    }
}

boolean getThingy(String name) {
    switch (name.toLowerCase())  {
        case "steps":
            return common.steps;
        case "scale":
            return common.scale;
        case "float":
            return this.fracts;
        case "fraction":
            return this.fracts;
        case "spaces":
            return this.spaces;
        // ... etc.
    }
}

如果 common 的类不是您可以更改的，那么某个地方的静态实用程序函数也可以工作，但如果可能的话，最好在类中。

Answer 2

在 Java 8+ 中，你可以使用类似的东西：

Map<String, Runnable> actions = new HashMap<> ();
actions.put("steps", () -> common.steps = true);
actions.put("scale", () -> common.scales = true);
//etc.

然后在您的代码中：

actions.get(varName.toLowerCase()).run(); //need null check

您也可以使用 Java 7 来做到这一点——也可以使用匿名类，但会更冗长。

Answer 3

这是一个选项，从评论中发展我的想法只是一点点。不知道你是否喜欢，我想提供它以防万一。

public class Common {

    private Map<String, Boolean> options = new HashMap<>();

    public void setOption(String varName, boolean condition) {
        options.put(varName.toLowerCase(), condition);
    }

    public boolean isSteps() { return options.get("steps"); }
    public boolean isFracts() { return options.get("fractions"); }
    public boolean isScale() { return options.get("scale"); }

}

您可能想要进行一些防御，例如避免设置不存在的选项。

编辑：借鉴 David Foerster 在枚举上的 cmets，这是使用它们的解决方案：

public enum Option {

    steps, scale, fraction;

    private boolean option = false;

    public static void setOption(String varName, boolean condition) {
        valueOf(varName.toLowerCase()).option = condition;
    }

    public boolean isSet() {
        return option;
    }

}

现在查找发生在 setter 中，而不是在 getter 中。对设置不存在的选项的防御是内置的：如果你尝试，你会得到一个异常，如果你愿意，当然可以修改这个行为。该解决方案具有很强的可扩展性，如果需要，可以轻松添加更多枚举常量。

Answer 4

警告：我上次写一些 Java 已经有一段时间了，这可能违反了最佳实践，所以请继续小心！也是just a quick and dirty example，我在（不是最新的）手机上写的……

你可以尝试使用反射：

class Common {
  public boolean a;
  public boolean b;
  public boolean tryToSet(String field, boolean value) throws java.lang.Exception {
    Class<?> cl = this.getClass();
    try {
      Field f = cl.getDeclaredField(field);
      f.setBoolean(this, value);
      return true;
    } catch(NoSuchFieldException e) {
      return false;
    }
  }
}

返回一个布尔值使您可以实现“默认情况”：

if (! c.tryToSet("x", false)) {
  System.out.println("some default case");
}

Answer 5

试试这个：

import java.util.Scanner;

public class TestCases 
{
    static boolean steps = false;
    static boolean fracts;
    static boolean scale;

    public static void  main( String[] args ) 
    {
        Scanner input = new Scanner( System.in );

        System.out.println( "Type the input" );
        String typedInput = input.nextLine();

        Object[][] tests = { { "steps", steps }, { "float", fracts }, { "scale", scale } };

        for( int i = 0; i < tests.length; i++ )
        {
            if( typedInput.equals( tests[ i ][ 0 ] ) )
            {
                tests[ i ][ 1 ] = true;
                break;
            }
        }

        for( int i = 0; i < tests.length; i++ )
        {
            for( int j = 0; j < tests[ i ].length; j++ )
            {
                    System.out.print( tests[ i ][ j ] + " " );
            }
            System.out.println();
        }


    }

}

所有必要的转换都会自动完成。