Java知识总结—第三篇（程序结构）

3.1 顺序控制

顺序控制流程是一种程序执行的基本控制流程，它按照代码编写的顺序依次执行每一条语句。在顺序控制流程中，程序会从第一条语句开始执行，直到执行完最后一条语句，才会结束程序的执行。

例如，下面是一个简单的顺序控制流程的示例程序：

a = 5
b = 10
c = a + b
print(c)

这个程序中，首先执行第一条语句，将变量a赋值为5；然后执行第二条语句，将变量b赋值为10；接着执行第三条语句，将a和b的值相加并赋值给变量c；最后执行最后一条语句，输出变量c的值。整个程序的执行过程就是按照代码编写的顺序依次执行每一条语句的过程。
顺序控制流程是所有程序中最基本的控制流程，它对于程序的执行顺序有着决定性的影响。在程序的设计中，程序员需要充分考虑顺序控制流程的作用，合理安排每一条语句的顺序，以达到预期的程序执行效果。

3.2 分支控制

分支控制是指在编程中根据不同的条件执行不同的代码分支的能力。在许多编程语言中，分支控制通常使用条件语句来实现。常见的条件语句包括if语句、switch语句等。

3.2.1 分支控制if-else

分支控制是编程中常用的一种流程控制语句，if-else语句是其中一种常见的分支控制语句。
if-else语句用于根据条件执行不同的代码块。其基本形式如下

if (condition) {
    // 当条件为真时执行的代码块
} else {
    // 当条件为假时执行的代码块
}

其中，condition是一个布尔表达式，当其值为true时执行if语句块中的代码，否则执行else语句块中的代码。
在需要多个条件判断的情况下，可以使用if-else if语句，其基本形式如下：

if (condition1) {
    // 当条件1为真时执行的代码块
} else if (condition2) {
    // 当条件2为真时执行的代码块
} else {
    // 所有条件均为假时执行的代码块
}

在此结构中，如果条件1为真，则执行if语句块中的代码，否则继续判断条件2，如果条件2为真，则执行else if语句块中的代码，否则执行else语句块中的代码。
需要注意的是，if-else语句块中的代码只有当条件为真时才会被执行，否则不会执行。因此，在使用if-else语句时，需要仔细考虑所有可能的情况，确保代码逻辑正确无误。

3.2.2 switch分支结构

switch 分支结构是一种流程控制结构，用于根据不同的情况执行不同的代码块。在 switch 结构中，您可以列出一组可能的选项（称为 case），并针对每个选项编写相应的代码块。然后，您可以将变量或表达式与这些选项进行比较，以确定应该执行哪个代码块。

下面是一个 switch 分支结构的示例：

switch (variable) {
  case value1:
    // 执行代码块1
    break;
  case value2:
    // 执行代码块2
    break;
  case value3:
    // 执行代码块3
    break;
  default:
    // 如果 variable 不匹配任何值，则执行默认代码块
}

在上面的示例中，variable 是要与每个 case 选项进行比较的变量或表达式。如果 variable 的值与 value1 匹配，则执行代码块1，如果与 value2 匹配，则执行代码块2，以此类推。如果 variable 的值不匹配任何选项，则执行默认代码块。
需要注意的是，在每个代码块的结尾都有一个 break 语句，这是为了防止执行下一个代码块。如果省略了 break 语句，switch 结构将会执行所有匹配的代码块，而不是只执行第一个匹配的代码块。

3.3 循环控制

3.3.1 for循环控制

在Java中，for循环是一种常用的循环结构，通常用于对数组或集合进行遍历，其基本语法如下：

for (初始化表达式; 布尔表达式; 更新表达式) {
    // 循环体语句
}

其中，初始化表达式用于初始化循环控制变量；布尔表达式用于判断循环条件是否满足，如果满足，则执行循环体语句，否则跳出循环；更新表达式用于更新循环控制变量的值。
在for循环中，可以使用break语句和continue语句来控制循环的执行。break语句可以用于跳出循环，而continue语句可以用于跳过本次循环，直接执行下一次循环。
另外，在Java 5中引入了增强的for循环，也叫foreach循环，用于简化数组或集合的遍历操作。其基本语法如下：

for (元素类型 元素变量 : 数组或集合) {
    // 循环体语句
}

其中，元素类型是数组或集合中元素的类型，元素变量是用于接收每个元素的变量名。在foreach循环中，循环体语句会针对每个元素执行一次。

3.3.2 while循环控制

在Java中，while循环是一种常见的控制结构，用于重复执行某个代码块，直到指定的条件不再满足为止。它的语法如下：

while (condition) {
  // 循环体代码
}

其中，condition是一个布尔表达式，如果它的值为true，则循环体代码将继续执行；否则，循环将结束。

以下是一个简单的示例，演示了如何使用while循环输出1到10之间的所有奇数：

int i = 1;
while (i <= 10) {
  if (i % 2 == 1) {
    System.out.println(i);
  }
  i++;
}

在这个例子中，循环首先初始化变量i为1。然后，每次循环时，它检查i是否小于或等于10，如果是，则执行循环体代码。在循环体中，它检查i是否是奇数，如果是，则输出i的值。最后，它递增i的值，使循环可以继续执行下一次迭代，直到i的值大于10为止。

3.3.3 do…while循环控制

在Java中，do…while循环用于重复执行一组语句，直到给定的布尔表达式变为false为止。该循环会至少执行一次，因为它的判断条件是在循环体的最后面进行判断的。

do…while循环的语法如下：

do {
    // 循环体语句
} while (布尔表达式);

其中，循环体语句是需要重复执行的一组语句，布尔表达式是用于控制循环是否继续执行的条件。
do…while循环的执行过程如下：
1.执行循环体语句。
2.判断布尔表达式的值是否为true，如果为true，则返回步骤1继续执行循环体语句；否则，结束循环。
需要注意的是，do…while循环至少会执行一次循环体语句，即使布尔表达式一开始就是false。因此，如果你需要在循环之前对一些变量进行初始化或执行一些操作，do…while循环可能是一个不错的选择。

3.4 跳转控制语句

3.4.1 continue

在Java中，continue是一种控制流语句，用于在循环结构（如for、while、do-while）中跳过当前迭代并继续下一次迭代。当程序执行到continue语句时，它将立即跳过循环体中continue语句后面的所有语句，并开始下一次循环迭代。

下面是一个简单的示例，演示了如何使用continue语句在循环中跳过某些迭代：

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        continue; // 跳过 i = 5 的迭代
    }
    System.out.print(i + " ");
}

在上面的代码中，当i等于5时，continue语句将跳过该迭代并继续下一次迭代。因此，该代码将输出以下内容：

1 2 3 4 6 7 8 9 10

3.4.2 break

在Java中，break是一种控制流语句，用于立即退出一个循环语句（for、while、do-while）或一个switch语句。break语句通常与条件语句结合使用，例如，在一个循环语句中，当满足某个条件时，就可以使用break语句来跳出循环。

下面是一个使用break语句的示例：

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;
    }
    System.out.println(i);
}

在上面的示例中，当i等于5时，break语句被执行，循环立即退出，因此只输出了0到4这五个数字。

在switch语句中，break语句可以用来终止case分支，防止执行下一个case分支。例如：

int num = 2;
switch (num) {
    case 1:
        System.out.println("num is 1");
        break;
    case 2:
        System.out.println("num is 2");
        break;
    case 3:
        System.out.println("num is 3");
        break;
    default:
        System.out.println("num is not 1, 2 or 3");
        break;
}

在上面的示例中，当num等于2时，只会输出"num is 2"，而不会执行下一个case分支。

3.4.3 return

在 Java 中，return 是一个关键字，用于结束当前方法的执行并返回一个值（如果方法定义了返回类型）。return 关键字可以在任何时候使用，它会立即结束当前方法的执行，并将控制权返回给调用该方法的代码。

如果方法定义了返回类型，则 return 语句必须返回与该类型兼容的值。例如，如果方法定义了 int 类型的返回值，则 return 语句必须返回一个 int 值。

以下是一个简单的 Java 方法，演示了 return 的用法：

public int add(int a, int b) {
    int sum = a + b;
    return sum;
}

在上面的示例中，add 方法接受两个参数 a 和 b，将它们相加并将结果存储在 sum 变量中。然后，return 语句返回 sum 变量的值作为方法的结果。

请注意，return 语句可以出现在方法的任何位置。如果 return 语句出现在方法的任何位置之前，它将会导致方法立即返回并不执行后续的代码。例如：

public int divide(int a, int b) {
    if (b == 0) {
        System.out.println("Cannot divide by zero");
        return 0;
    }
    return a / b;
}

在上面的示例中，divide 方法接受两个参数 a 和 b，并在执行除法之前检查 b 是否为零。如果 b 为零，则方法输出一条错误消息并立即返回 0。否则，方法将执行除法并返回结果。

配套习题小练

习题一 CommandBySwitch命令解析程序

/*
任务要求：
    CommandBySwitch命令解析程序：
    要求：接收用户输入的命令，依据命令做不同的操作
 */

public class CommandBySwitch {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入数字1~4：");
        int command = scanner.nextInt();
        commandBySwitch(command);
    }

    public static void commandBySwitch(int command) {
        switch (command) {
            case 1: System.out.println("执行输出 1");
                    break;
            case 2: System.out.println("执行输出 2");
                    break;
            case 3: System.out.println("执行输出 3");
                    break;
            case 4: System.out.println("执行输出 4");
                    break;
            default: System.out.println("Error");
                    break;
        }
    }
}

习题二 for循环：输出5次"行动是成功的阶梯"、输出9的乘法表(1到9、1/3/5/7/9、9到1)、1到100的累加和

/*
任务要求：
    for循环：输出5次"行动是成功的阶梯"、
    输出9的乘法表(1到9、1/3/5/7/9、9到1)、
    1到100的累加和
 */
public class ForLoop {

    public static void main(String[] args) {
        // 输出5次"行动是成功的阶梯"
        System.out.println("输出5次\"行动是成功的阶梯\"");
        for (int i = 0; i < 5; i++) {
            System.out.println("行动是成功的阶梯");
        }
        System.out.println();

        // 输出9的乘法表（1到9）
        System.out.println("输出9的乘法表（1到9）");
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= 9; j++) {
                System.out.printf("%d×%d=%d\t", i, j, i*j);
            }
            System.out.println();
        }
        System.out.println();

        // 输出9的乘法表（1/3/5/7/9）
        System.out.println("输出9的乘法表（1/3/5/7/9）");
        for (int i = 1; i <= 9; i += 2) {
            for (int j = 1; j <= 9; j++) {
                System.out.printf("%d×%d=%d\t", i, j, i*j);
            }
            System.out.println();
        }
        System.out.println();

        // 输出9的乘法表（9到1）
        System.out.println("输出9的乘法表（9到1）");
        for (int i = 9; i >= 1; i--) {
            for (int j = 1; j <= 9; j++) {
                System.out.printf("%d×%d=%d\t", i, j, i*j);
            }
            System.out.println();
        }
        System.out.println();

        // 1到100的累加和
        System.out.println("输出1到100的累加和");
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        System.out.println(sum);
    }
}

习题三 Guessing猜数字之do…while版

/*
任务要求
    Guessing猜数字之do...while版
    要求：随机生成一个数，由用户来猜，猜不对则反复猜，并给出大小提示，猜对的则结束，用do...while来实现。
 */
public class GuessingDoWhile {

    public static void main(String[] args) {
        Random random = new Random();
        int number = random.nextInt(100) + 1;
        Scanner scanner = new Scanner(System.in);
        do {
            System.out.print("请输入你猜测的数字（1-100）：");
            int guess = scanner.nextInt();
            if (guess > number) {
                System.out.println("猜大了");
            } else if (guess < number) {
                System.out.println("猜小了");
            } else {
                System.out.println("恭喜你，猜对了！");
                break;
            }
        } while (true);
    }
}

习题四 Guessing猜数字之while版

/*
任务要求：
    Guessing猜数字之while版：
    要求：随机生成一个数，由用户来猜，猜不对则反复猜，并给出大小提示，猜对的则结束，用while来实现。
 */
public class GuessingWhile {

    public static void main(String[] args) {
        Random random = new Random();
        int number = (int)(1 + Math.random() * 100 - 1 + 1);
        System.out.println(number);
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.print("请输入你猜测的数字（1-100）：");
            int guess = scanner.nextInt();
            if (guess > number) {
                System.out.println("猜大了");
            } else if (guess < number) {
                System.out.println("猜小了");
            } else {
                System.out.println("恭喜你，猜对了！");
                break;
            }
        }
    }
}

习题五 Addition随机加法运算器

/*
任务要求：
    Addition随机加法运算器，
    要求：由系统随机出10道加法题，而后由用户来答题，答题后输出"答对
 */
public class AdditionCalculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int score = 0;
        for (int i = 0; i < 10; i++) {
            // 随机生成两个数字，在[1,100]之间
            int num1 = (int)(1 + Math.random()*(100 - 1 + 1));
            int num2 = (int)(1 + Math.random()*(100 - 1 + 1));

            // 让用户输入答案
            System.out.println("第" + (i+1) + "题");
            System.out.print(num1 + " + " + num2 + " = ");
            int answer = scanner.nextInt();

            // 判断答案是否正确，并更新分数
            if (answer == num1 + num2) {
                System.out.println("答对了");
                score += 10;
            } else {
                System.out.println("答错了");
            }
        }

        System.out.println("总分数：" + score);
    }
}

习题六 MultiTable九九乘法表

/*
任务要求：
    MultiTable九九乘法表，要求：输出九九乘法表
 */
public class MultiTable {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + " x " + i + " = " + (i*j) + "\t");
            }
            System.out.println();
        }
    }
}