Question

我的目的是在同一个switch语句中调用另一个案例中的两个案例，

switch (orderType) {
        case 1: 
            statement 1;
            break;
       case 2:
            statement 2;
            break;
       case 3:
             **call case 1;**
             **Call case 2;**
             break;
       default:
            break;`
}

我们可以用Java做到吗？

Answer 1

虽然您无法直接影响switch个案例，但您可以从一个案例中调用switch的父方法并传递不同的参数。例如，

void foo(int param1, String param2, ...) {
    switch (param1) {
        case 0:
            foo(1, "some string");
            break;

        case 1:
            //do something
            break;

        default:
            break;
    }
}

Answer 2

不，你不能跳转到另一个交换机案例中的代码片段。但是，您可以将代码提取到可以从另一个案例调用的自己的方法中：

switch (orderType) {
    case 1: 
        someMethod1();
        break;
    case 2:
        someMethod2();
        break;
    case 3:
        someMethod1();
        someMethod2();
        break;
    default:
        break;
}

void someMethod1() { ... }
void someMethod2() { ... }

Answer 3

你不能像这样调用另一个case块。但是，您可以做的是将每个块包装在一个方法中，并重用它们：

private void doSomething() {
    // implementation
}

private void doSomethingElse() {
    // implementation
}

private void runSwitch(int order) {

    switch (orderType) {
           case 1: 
                doSomething();
                break;
           case 2:
                doSomethingElse();
                break;
           case 3:
                doSomething();
                doSomethingElse();
                break;
           default:
                break;
    }
}

Answer 4

使用方法是最佳方法，如已接受的答案所述，但是由于某些原因，如果您无法创建方法，这是不使用方法的另一种方法

boolean isBreakTheLoop = false, isCase2Required = false;
while(!isBreakTheLoop){
    switch (orderType) {
       case 1: 
            statement 1;
            if(isCase2Required){
               orderType = 2;
               break;
            }
            isBreakTheLoop = true;
            break;
       case 2:
            statement 2;
            isBreakTheLoop = true;
            break;
       case 3:
            orderType = 1;
            isCase2Required = true;
            break;
       default:
            isBreakTheLoop = true;
            break;
    }
}

Answer 5

正如其他人所指出的，您可以在一个方法中实现您的开关案例，该方法接受一个参数，该参数对应于所需的开关案例。这些切换情况可以递归调用相同的方法，具有所需的切换情况。这是一个完整的例子，它允许您检查一年是否是闰年：

public class LeapYear {

    static int year = 2016;

    public static void main(String[] args) {

        leapSwitch(1);

    }

    public static void leapSwitch(int switchcase) {

        switch (switchcase) {

        case 1: {
            if (year % 4 == 0) {
                leapSwitch(2);
            } else {
                leapSwitch(5);
            }
        }
            break;

        case 2: {
            if (year % 100 == 0) {
                leapSwitch(3);

            } else {
                leapSwitch(4);
            }
        }
            break;

        case 3: {
            if (year % 400 == 0) {
                leapSwitch(4);

            } else {
                leapSwitch(5);
            }
        }
            break;

        case 4: {
            System.out.println(year+ " is a leap year!");
        }
            break;

        case 5: {
            System.out.println("Not a leap year...");
        }
            break;

        }
    }
}

Answer 6

如果这种情况是需要执行直到参数为止的所有情况（例如您有5个情况，但是情况2需要执行1和2，情况3需要执行1和2和3等）。，我有一个潜在的解决方案。我创建了一个嵌套在for循环中的switch语句，如下所示：

for (int i = 1; i <= orderType; i++) {
    switch (i) {
    case 1:
        statement1;
        break;
    case 2:
        statement2;
        break;
    case 3:
        statement3;
        break;
    default:
        break;
    }
}

这将导致导致有效案例的每条语句执行。效率并非最佳选择，但可以帮助少数情况或简单执行。

Answer 7

您可以在某些情况下使用此技巧：

var provider = new FileExtensionContentTypeProvider();
var contentType = provider.TryGetContentType(fileName, out var type)
    ? type
    : "application/octet-stream";

return File(stream, contentType);

}

我们可以在Java的同一个switch语句中调用另一个案例中的“case”吗？

7 个答案: