6

对于我的项目，我将许多对象分为 10 个类。每个对象都可以执行一些操作，这些操作必须事先注册（每个类只注册一次操作）。为每个类定义的操作表示为public final static整数。我想在运行时动态分配操作的ID（每个类的操作数目前约为20，并且数量会增加）。

问题出现了，当执行操作时，我必须找到正在执行的操作（我使用 switch 语句）。

这是一个简单的工作代码示例：

public class Test {
    final static int foo = 8;
    final static int bar = 10;

    public static void main(String[] args)
    {
        int x=10;

        switch(x)
        {
        case foo:
            System.out.println("FOO");
            break;
        case bar:
            System.out.println("BAR");
            break;
        default:
            System.out.println("PROBLEM");
        }
    }
}

此代码通常会编译并显示BAR.

但是这个稍微转换的代码会产生一个Unresolved compilation problemwith case expressions must be constant expressions。

public class Test {
    final static int foo;
    final static int bar;

    static
    {
        foo=8;
        bar=10;
    }
    public static void main(String[] args)
    {
        int x=10;

        switch(x)
        {
        case foo:
            System.out.println("FOO");
            break;
        case bar:
            System.out.println("BAR");
            break;
        default:
            System.out.println("PROBLEM");
        }
    }
}

这些代码不应该实际工作和编译吗？在解决此问题之前，我无法动态执行任何操作？或者还有其他方法吗？

谢谢

编辑：由于使用枚举的想法，我想解决这个问题：

public class Test {
  enum OperationSet1 {
    FOO, BAR, THESE, ARE, ALL, DIFFERENT, OPERATIONS
  }
  enum OperationSet2 {
    FOO, BAR, NOW, SOME, OTHER, OPS
  }

  public static void main(String[] args) {
    OperationSet1[] ops = new OperationSet1[10];
    for (int i=0; i<ops.length; i++)
      ops[i] = OperationSet1.values()[(int)(Math.random()*OperationSet1.values().length)];

    OperationSet2[] ops2 = new OperationSet2[10];
    for (int i=0; i<ops.length; i++)
      ops[i] = OperationSet2.values()[(int)(Math.random()*OperationSet2.values().length)];

    for (OperationSet1 op:ops)
      handleOperation(op);
  }
    for (OperationSet2 op:ops2)
      handleOperation(op);
  }
  public static void handleOperation(Object? op) {
    switch(op) {
        /**code to handle**/
    }
  }
}

我们有两个枚举，我想要一个处理函数（最好使用 switch 语句），它可以处理这两个枚举中出现的所有情况。

EDIT2：所以这里。我有 10 个类(C1, C2, ..., C10)和这些类的大约 40 个对象。这些对象中有些是所谓的所有者，有些是共享的。每个共享对象都有一个所有者（这是基本关系——它与 java 继承没有任何关系）。

现在每个共享对象都会obj不时发生变化，这obj需要询问其所有者own是否可能发生变化（这只是其中一种操作）然后它会发生变化（并再次通知所有者）。对象obj还有一组他可以执行的预定义操作，C1由enum. 因此own必须有一个处理类的对象操作的函数C1。现在我们有一个obj2属于类的对象C2，具有不同的操作集和相同的所有者own。obj只能执行 中定义的操作，C1并且obj2只能执行 中定义的操作C2。

如何概括处理函数，以便将其编写整齐？我什至应该使用枚举吗？

4

4 回答 4

4

您只能在 switch 语句中使用编译时已知的常量。这是因为开关代码是静态检查和构建的。

在第二种情况下，你可以做

static
{
    foo=8;
    bar=foo;
}

但由于这些值直到运行时才知道，因此无法构建 switch 语句或检查它是否正确。

于 2012-09-03T13:33:30.630 回答
2

static variables or blocks or methods在类初始化（运行时）时加载。

您的问题是在编译时，远在加载/初始化类之前。所以字段是最终的并且它们没有被初始化（当然在编译时）。

在第一种情况下，foo和的值bar在编译时是已知的。

于 2012-09-03T13:34:44.803 回答
0

我建议为此使用枚举。这样就不再需要 ID 处理了。

public class Test {
  enum Operation {
    FOO, BAR, THESE, ARE, ALL, DIFFERENT, OPERATIONS
  }

  public static void main(String[] args) {
    Operation[] ops = new Operation[10];
    for (int i=0; i<ops.length; i++)
      ops[i] = Operation.values()[(int)(Math.random()*Operation.values().length)];

    for (Operation op:ops)
      handleOperation(op);
  }

  public static void handleOperation(Operation op) {
    switch(op) {
    case FOO:
      System.out.println("FOO");
      break;
    case BAR:
      System.out.println("BAR");
      break;
    case THESE:
      System.out.println("THESE");
      break;
    case ARE:
      System.out.println("ARE");
      break;
    case ALL:
      System.out.println("ALL");
      break;
    case DIFFERENT:
      System.out.println("DIFFERENT");
      break;
    case OPERATIONS:
      System.out.println("OPERATIONS");
      break;
    default:
      System.out.println("PROBLEM");
    }
  }
}
于 2012-09-03T13:49:20.653 回答
0

或者简单地使用 if-elseif 案例：

private final static int ONE = 1;
private final static int TWO = 2;

public static void main(String[] args) {
int value = 1;

  if(value==ONE){

  }
  else if(value==TWO){

  }

}

于 2014-10-16T10:08:29.583 回答