# Java 控制流程

原文：http://zetcode.com/lang/java/flow/

在 Java 教程的这一部分中，我们将讨论程序流控制。 我们将使用几个关键字来使我们能够控制 Java 程序的流程。

## Java 控制流语句

在 Java 语言中，有几个关键字用于更改程序的流程。 语句可以多次执行，也可以仅在特定条件下执行。 `if`，`else`和`switch`语句用于测试条件，`while`和`for`语句用于创建循环，而`break`和`continue`语句用于更改循环。

当程序运行时，语句从源文件的顶部到底部执行。 逐一。

## Java `if`语句

`if`语句具有以下一般形式：

```java
if (expression) {

    statement;
}

```

`if`关键字用于检查表达式是否为真。 如果为`true`，则执行一条语句。 该语句可以是单个语句或复合语句。 复合语句由一个块包围的多个语句组成。 块是用大括号括起来的代码。 如果主体中只有一个语句，则括号是可选的。

`IfStatement.java`

```java
package com.zetcode;

import java.util.Random;

public class IfStatement {

    public static void main(String[] args) {

        Random r = new Random();
        int num = r.nextInt();

        if (num > 0) {

            System.out.println("The number is positive");
        }
    }
}

```

生成一个随机数。 如果数字大于零，我们将向终端打印一条消息。

```java
Random r = new Random();
int num = r.nextInt();

```

这两行生成一个随机整数。 该数字可以是正数或负数。

```java
if (num > 0) {

    System.out.println("The number is positive");
}

```

使用`if`关键字，我们检查生成的数字是否大于零。 `if`关键字后跟一对圆括号。 在方括号内，我们放置一个表达式。 该表达式产生布尔值。 如果布尔值是`true`，则执行两个大括号括起来的块。 在我们的例子中，字符串“`The number is positive`”被打印到终端上。 如果随机值为负，则不执行任何操作。 如果我们只有一个表达式，则大括号是可选的。

## Java `else`关键字

我们可以使用`else`关键字来创建一个简单的分支。 如果`if`关键字后方括号内的表达式的值为假，则将自动执行`else`关键字后方的语句。

`Branch.java`

```java
package com.zetcode;

import java.util.Random;

public class Branch {

    public static void main(String[] args) {

        Random r = new Random();        
        int num = r.nextInt();

        if (num > 0) {

            System.out.println("The number is positive");

        } else {

            System.out.println("The number is negative");
        }
    }
}

```

`if`关键字后面的块或`else`关键字后面的块都被执行。

```java
if (num > 0) {

    System.out.println("The number is positive");

} else {

    System.out.println("The number is negative");
}

```

`else`关键字紧随`if`块的右大括号。 它有自己的块，用大括号括起来。

```java
$ java com.zetcode.Branch 
The number is positive
$ java com.zetcode.Branch 
The number is negative
$ java com.zetcode.Branch 
The number is negative

```

我们运行该示例三次。 这是一个示例输出。

## 具有多个分支的`if`

我们可以使用`else if`关键字创建多个分支。 仅当不满足先前条件时，`else if`关键字才会测试其他条件。 请注意，我们可以在测试中使用多个`else if`关键字。

以前的程序有一个小问题。 负值设为零。 以下程序将解决此问题。

`MultipleBranches.java`

```java
package com.zetcode;

import java.util.Scanner;

public class MultipleBranches {

    public static void main(String[] args) {

        System.out.print("Enter an integer:");

        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();

        if (num < 0) {

            System.out.println("The integer is negative");
        } else if (num == 0) {

            System.out.println("The integer equals to zero");            
        } else {

            System.out.println("The integer is positive");
        }
    }
}

```

我们从用户那里收到一个测试值，如果它是负数或正数，或者等于零。

```java
System.out.print("Enter an integer:");

```

输入整数的提示将写入标准输出。

```java
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();

```

使用`java.util`包的`Scanner`类，我们从标准输入中读取一个整数值。

```java
if (num < 0) {

    System.out.println("The integer is negative");
} else if (num == 0) {

    System.out.println("The integer equals to zero");            
} else {

    System.out.println("The integer is positive");
}

```

如果第一个条件的计算结果为`true`，例如输入的值小于零，将执行第一个程序段，并跳过其余两个程序段。 如果不满足第一个条件，则检查`if else`关键字之后的第二个条件。 如果第二个条件的值为真，则执行第二个块。 如果不是，则执行`else`关键字之后的第三个程序段。 如果不满足先前的条件，则始终执行`else`块。

```java
$ java com.zetcode.MultipleBranches 
Enter an integer:4
The integer is positive
$ java com.zetcode.MultipleBranches 
Enter an integer:0
The integer equals to zero
$ java com.zetcode.MultipleBranches 
Enter an integer:-3
The integer is negative

```

我们将示例运行三次，以便测试所有条件。 零被正确处理。

## Java `switch`语句

`switch`语句是选择控制流语句。 它允许变量或表达式的值通过多路分支控制程序执行的流程。 与使用`if`和`else if`语句的组合相比，它以更简单的方式创建多个分支。 每个分支以`break`关键字结尾。

我们使用变量或表达式。 `switch`关键字用于根据值列表测试变量或表达式中的值。 值列表用`case`关键字显示。 如果值匹配，则执行`case`之后的语句。 有一个可选的`default`语句。 如果找不到其他匹配项，则执行该命令。

`SwitchStatement.java`

```java
package com.zetcode;

import java.util.Scanner;

public class SwitchStatement {

    public static void main(String[] args) {

        System.out.print("Enter a domain:");

        Scanner sc = new Scanner(System.in);
        String domain = sc.nextLine();

        domain = domain.trim().toLowerCase();

        switch (domain) {

            case "us":
                System.out.println("United States");
                break;

            case "de":
                System.out.println("Germany");
                break;

            case "sk":
                System.out.println("Slovakia");
                break;

            case "hu":
                System.out.println("Hungary");
                break;

            default:
                System.out.println("Unknown");
                break;
        }
    }
}

```

要求用户输入域名。 读取域名并将其存储在变量中。 该变量使用`switch`关键字针对选项列表进行测试。 在我们的程序中，我们有一个域变量。 我们从命令行读取变量的值。 我们使用`case`语句测试变量的值。 有几种选择。 例如，如果该值等于“ us”，则将“ United States”字符串打印到控制台。

```java
Scanner sc = new Scanner(System.in);
String domain = sc.nextLine();

```

从控制台读取用户输入。

```java
domain = domain.trim().toLowerCase();

```

`trim()`方法从潜在的前导和尾随空白中剥离变量。 `toLowerCase()`将字符转换为小写。 现在，“ us”，“ US”或“ us”是美国域名的可行选项。

```java
switch (domain) {
    ...
}

```

在圆括号中，`switch`关键字采用将要测试的输入。 输入可以是`byte`，`short`，`char`，`int`，`enum`或`String`数据类型。 `switch`关键字的主体放在一对或大括号内。 在体内，我们可以放置多个`case`选项。 每个选项都以`break`关键字结尾。

```java
case "us":
    System.out.println("United States");
    break;

```

在这种情况下，我们测试域变量是否等于“`us`”字符串。 如果为`true`，则将消息打印到控制台。 该选项以`break`关键字结束。 如果成功求值了其中一个选项，则`break`关键字将终止`switch`块。

```java
default:
    System.out.println("Unknown");
    break;

```

`default`关键字是可选的。 如果没有求值`case`选项，则执行`default`部分。

```java
$ java com.zetcode.SwitchStatement
Enter a domain:us
United States

```

这是一个示例输出。

## Java `while`语句

`while`语句是一个控制流语句，它允许根据给定的布尔条件重复执行代码。

这是`while`循环的一般形式：

```java
while (expression) {

    statement;
}

```

`while`关键字在大括号括起来的块内执行语句。 每次将表达式求值为`true`时都会执行这些语句。

`WhileStatement.java`

```java
package com.zetcode;

public class WhileStatement {

    public static void main(String[] args) {

        int i = 0;
        int sum = 0;

        while (i < 10) {

            i++;
            sum += i;
        }

        System.out.println(sum);
    }
}

```

在代码示例中，我们从一系列数字计算值的总和。

`while`循环包含三个部分：初始化，测试和更新。 语句的每次执行都称为循环。

```java
int i = 0;

```

我们启动 i 变量。 它用作计数器。

```java
while (i < 10) {
    ...
}

```

`while`关键字后的圆括号内的表达式是第二阶段，即测试。 执行主体中的语句，直到表达式的计算结果为`false`。

```java
i++;

```

`while`循环的最后阶段是更新。 我们增加计数器。 请注意，对`while`循环的不正确处理可能会导致循环不断。

```java
$ java com.zetcode.WhileStatement 
55

```

程序计算出 0、1，...，9 个值的总和。

`while`语句有一个修改的版本。 这是`do while`语句。 即使不满足条件，也可以保证块内的语句至少运行一次。

`DoWhile.java`

```java
package com.zetcode;

public class DoWhile {

    public static void main(String[] args) {

        int count = 0;

        do {
            System.out.println(count);
        } while (count != 0);
    }
}

```

首先执行该块，然后求值真值表达式。 在我们的情况下，条件不满足，`do while`语句终止。

## Java `for`语句

如果在启动循环之前知道周期数，则可以使用`for`语句。 在此构造中，我们声明一个计数器变量，该变量在每次循环重复期间都会自动增加或减少值。

`ForStatement.java`

```java
package com.zetcode;

public class ForStatement {

    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {

            System.out.println(i);
        }
    }
}

```

在此示例中，我们将数字`0..9`打印到控制台。

```java
for (int i = 0; i < 10; i++) {

    System.out.println(i);
}

```

`for`循环分为三个阶段。 首先，我们将计数器`i`初始化为零。 此阶段仅完成一次。 接下来是条件。 如果满足条件，则执行`for`块中的语句。 然后进入第三阶段：计数器增加。 现在我们重复 2 和 3 个阶段，直到不满足条件并终止`for`循环。 在我们的情况下，当计数器`i`等于 10 时，`for`循环停止执行。

`for`循环可用于轻松遍历数组。 从数组的`length`属性，我们知道数组的大小。

`ForStatement2.java`

```java
package com.zetcode;

public class ForStatement2 {

    public static void main(String[] args) {

        String[] planets = {"Mercury", "Venus", "Earth",
            "Mars", "Jupiter", "Saturn", "Uranus", "Pluto"};

        for (int i = 0; i < planets.length; i++) {

            System.out.println(planets[i]);
        }

        System.out.println("In reverse:");

        for (int i = planets.length - 1; i >= 0; i--) {

            System.out.println(planets[i]);
        }
    }
}

```

我们有一个数组，用于保存太阳系中行星的名称。 使用两个`for`循环，我们按升序和降序打印值。

```java
for (int i = 0; i < planets.length; i++) {

    System.out.println(planets[i]);
}

```

通过从零开始的索引访问数组。 第一项的索引为 0。因此，`i`变量被初始化为零。 条件检查`i`变量是否小于数组的长度。 在最后阶段，`i`变量增加。

```java
for (int i = planets.length - 1; i >= 0; i--) {

    System.out.println(planets[i]);
}

```

此`for`循环以相反顺序打印数组的元素。 `i`计数器被初始化为数组大小。 由于索引基于零，因此最后一个元素的索引数组大小为 1。 该条件确保计数器大于或等于零。 （数组索引不能为负数）。 在第三步中，`i`计数器递减 1。

可以在`for`循环的初始化和迭代阶段中放置更多表达式。

`ForStatement3.java`

```java
package com.zetcode;

import java.util.Arrays;
import java.util.Random;

public class ForStatement3 {

    public static void main(String[] args) {

        Random r = new Random();

        int[] values = new int[10];
        int num;
        int sum=0;

        for (int i = 0; i < 10; i++, sum += num) {

            num = r.nextInt(10);
            values[i] = num;
        }

        System.out.println(Arrays.toString(values));
        System.out.println("The sum of the values is " + sum);
    }
}

```

在我们的示例中，我们创建了一个十个随机数的数组。 计算这些数字的总和。

```java
for (int i = 0; i < 10; i++, sum += num) {

    num = r.nextInt(10);
    values[i] = num;
}

```

在`for`循环的第三部分中，我们有两个用逗号分隔的表达式。 `i`计数器增加，并且当前编号添加到`sum`变量中。

```java
$ java com.zetcode.ForStatement3 
[1, 9, 2, 9, 0, 9, 8, 5, 5, 3]
The sum of the values is 51

```

这是程序的示例执行。

## Java 增强`for`语句

增强的`for`语句简化了遍历数据集合的过程。 它没有明确的计数器。 该语句一一遍历数组或集合，并将当前值复制到构造中定义的变量中。

`EnhancedFor.java`

```java
package com.zetcode;

public class EnhancedFor {

    public static void main(String[] args) {

        String[] planets = {
            "Mercury", "Venus", "Earth",
            "Mars", "Jupiter", "Saturn", "Uranus", "Pluto"
        };

        for (String planet : planets) {

            System.out.println(planet);
        }
    }
}

```

在此示例中，我们使用增强的`for`语句遍历一系列行星。

```java
for (String planet : planets) {

    System.out.println(planet);
}

```

`for`语句的用法很简单。 行星是我们迭代经过的阵列。 `planet`是具有数组中当前值的临时变量。 `for`语句遍历所有行星并将它们打印到控制台。

```java
$ java com.zetcode.EnhancedFor 
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Pluto

```

运行上面的 Java 程序将给出此输出。

## Java `break`语句

`break`语句可用于终止由`while`，`for`或`switch`语句定义的块。

`BreakStatement.java`

```java
package com.zetcode;

import java.util.Random;

public class BreakStatement {

    public static void main(String[] args) {

        Random random = new Random();

        while (true) {

            int num = random.nextInt(30);
            System.out.print(num + " ");

            if (num == 22) {

                break;
            }
        }

        System.out.print('\n');
    }
}

```

我们定义了一个无限的`while`循环。 我们使用`break`语句退出此循环。 我们从 1 到 30 中选择一个随机值并打印出来。 如果该值等于 22，则结束无穷的`while`循环。

```java
while (true) {    
    ...
}

```

在`while`语句的括号内放置`true`会创建一个无限循环。 我们必须自己终止循环。 请注意，这样的代码容易出错。 我们应该小心使用这样的循环。

```java
if (num == 22) {

    break;
}

```

当随机选择的值等于 22 时，将执行`break`语句，并终止`while`循环。

```java
$ java com.zetcode.BreakStatement 
23 12 0 4 13 16 6 12 11 9 24 23 23 19 15 26 3 3 27 28 25 3 3 25 6 22 
$ java com.zetcode.BreakStatement 
23 19 29 27 3 28 2 2 26 0 0 24 17 4 7 12 8 20 22 
$ java com.zetcode.BreakStatement 
15 20 10 25 2 19 26 4 13 21 15 21 21 24 3 22 

```

在这里，我们看到了该程序的三个示例执行。

## Java `continue`语句

`continue`语句用于跳过循环的一部分，并继续循环的下一个迭代。 它可以与`for`和`while`语句结合使用。

在下面的示例中，我们将打印一个数字列表，这些数字不能除以 2 而没有余数。

`ContinueStatement.java`

```java
package com.zetcode;

public class ContinueStatement {

    public static void main(String[] args) {

        int num = 0;

        while (num < 100) {

            num++;

            if ((num % 2) == 0) {
                continue;
            }

            System.out.print(num + " ");
        }

        System.out.print('\n');
    }
}

```

我们使用`while`循环遍历数字`1..99`。

```java
if ((num % 2) == 0) {
    continue;
}

```

如果表达式`num % 2`返回 0，则可以将所讨论的数字除以 2。执行`continue`语句，并跳过循环的其余部分。 在我们的例子中，循环的最后一条语句将被跳过，并且数字不会输出到控制台。 下一个迭代开始。

在 Java 教程的这一部分中，我们正在讨论控制流结构。 我们已经介绍了`if`，`if else`，`else`，`while`，`switch`，`for`，`break`和`continue`语句。