1

我有一个带有switch语句的 Java 方法。

它工作正常，但我有很多案例，可能有 20 个或更多，如下所示。

switch (result)  // result is of type Enum
{
    case 1:
        break;

    case 2:
        break;

    //----
    //----
    //----

    default:
        break;
}  // End of Switch 

请让我知道如何将这些案例转移到另一个文件中。

4

6 回答 6

6

不，Java 没有像 C 那样的#include 工具。

你最好简单地重构你的逻辑。你问的事实告诉我你很可能需要一些更好的抽象。

但是，至少你可以这样做：

public class HandleCases {

    public static Result handleCase1(...parameters...) {
        ...
    }

    public static Result handleCase2(...parameters...) {
        ...
    }

    public static Result handleCase3(...parameters...) {
        ...
    }
}

进而：

Result r = null;

switch(flag) {

    case 1:
        r = HandleCases.handleCase1( ... );
        break;

    case 2:
        r = HandleCases.handleCase1( ... );
        break;

    case 3:
        r = HandleCases.handleCase1( ... );
        break;
    ...
 }

Result holder 是您可以取回所需值的地方。

但总的来说，这是一个拼凑而成的作品，您的设计可能需要一些工作。

于 2012-04-13T13:56:49.380 回答
4

如果切换条件是一个实际的枚举，您可以在枚举上实现一个方法，例如

public enum Colors {
    RED { public void run() { /* do stuff for red */ } },
    GREEN { public void run() { /* do stuff for green */ } },
    BLUE { public void run() { /* do stuff for blue */ } },

    public abstract void run();  
}

你的开关将是一个方法调用：

Color result = ...;
// was switch (result) { case RED: ... }
result.run();

结果是“开关”在一个单独的文件中。枚举使它变得容易，但仍然将所有“切换”代码放在一个文件中，现在就是枚举的文件。您可以遵循相同的模式，在其自己的单例类中定义每个常量，并且都实现相同的接口/抽象类，以在单独的文件中获取每个条件。

如果你有很多开关用相同的常量做不同的事情，另一个探索的选择是访问者模式。 http://en.wikipedia.org/wiki/Visitor_pattern

于 2012-04-13T14:00:51.047 回答
3

你不能那样做。但是，您可以做的是，如果您有多个针对同一条件的 case 语句，那么您可以将它们组合在一起。这称为Fall Through。

switch(flag) {
    case 1:
    case 3:
    case 5:
        System.out.println("Odd");
        break;
    case 2:
    case 4:
    case 6:
        System.out.println("Even");
        break;
}
于 2012-04-13T13:52:46.603 回答
3

对于无需重新设计的直接解决方案，您可以使用Will 的解决方案。但正如他已经指出的那样，您似乎应该重新设计。

为此，请考虑以下来自http://c2.com/cgi/wiki?SwitchStatementsSmell的代码示例，它使用动态调度而不是手动 switch 语句：

method foo(int thingType) {
    switch (thingType) {
        case TYPE_ONE:
            oneFoo();
            break;
        case TYPE_TWO:
            twoFoo();
            break;
        case TYPE_THREE:
            threeFoo();
            break;
        case TYPE_FOUR:
            fourFoo();
            break;
    }
}


method oneFoo() {
}


method twoFoo() {
}


method threeFoo() {
}


method fourFoo() {
}


method bar(int thingType) {
    switch (thingType) {
        case TYPE_ONE:
            oneBar();
            break;
        case TYPE_TWO:
            twoBar();
            break;
        case TYPE_THREE:
            threeBar();
            break;
        case TYPE_FOUR:
            fourBar();
            break;
    }
}


method oneBar() {
}


method twoBar() {
}


method threeBar() {
}


method fourBar() {
}

相对

class one extends base {
    method foo() {
    }
    method bar() {
    }
}
class two extends base {
    method foo() {
    }
    method bar() {
    }
}
class three extends base {
    method foo() {
    }
    method bar() {
    }
}
class four extends base {
    method foo() {
    }
    method bar() {
    }
}

然后你可以简单地调用anObjectOfTypeBase.foo()and anObjectOfTypeBase.bar()。

于 2012-04-13T14:12:55.897 回答
1

不，你不能。在 Java 中，同一个类的全部代码必须在同一个文件中，更何况是同一个方法或语句的代码。

如果您有很多情况，您可以做的就是在一种方法中改变您的“切换”HashMap方法。例如，您可以创建一个抽象Action类，并放入Map许多动作，它们是不同文件上的不同类。然后在您的代码中，您可以执行以下操作：

Action action = map.get(result);
if (action != null)
   action.execute();
else
   // default case

这种模式称为命令模式。

于 2012-04-13T13:53:01.170 回答
1

这取决于你想怎么做。

首先，如果逻辑与同一个类相关（并且它是紧密耦合的），那么不，你不能把它转移到另一个类。但是，如果您想将这个类的逻辑分离到另一个类中，则可以在另一个类中创建一个静态方法来执行该switch语句。

或者，您可以重新访问和重构您的代码，这样就不需要 20 的 switch 语句。

于 2012-04-13T13:55:13.923 回答