一、前言

在Java编程中，分支语句和循环语句是实现程序流程控制的重要工具，它们可以根据不同的条件执行不同的代码块，或者多次执行同一段代码。合理使用分支语句和循环语句可以使程序结构更加清晰、代码更加简洁、逻辑更加严谨，同时也可以提高程序的执行效率和性能。在本文中，我们将会详细介绍Java中分支循环语句。

二、顺序结构

在Java编程语言中，顺序结构是一种最简单的程序结构。它指的是程序按照代码编写的顺序，一行一行地执行，从上往下依次执行，不会跳过任何一行代码。

在顺序结构中，每一条语句都会在前一条语句执行完成之后才会执行。这种执行方式非常直观，也很容易理解。

1
2
3
4
5
6
7
System.out.println("aaa");
System.out.println("bbb");
System.out.println("ccc");
// 运行结果
aaa
bbb
ccc

如果调整代码的书写顺序, 则执行顺序也发生变化

1
2
3
4
5
6
7
System.out.println("aaa");
System.out.println("ccc");
System.out.println("bbb");
// 运行结果
aaa
ccc
bbb

三、分支结构

在Java编程语言中，分支语句是一种根据条件选择不同执行路径的程序结构。Java提供了多种分支语句，包括if语句、if-else语句、switch语句。

1、if语句

Ⅰ、语法格式1

1
2
3
if(布尔表达式){
// 语句
}

如果布尔表达式结果为true，执行if中的语句，否则不执行。

比如：小明，如果这次考试考到90分或以上，给你奖励一个鸡腿。

1
2
3
4
int score = 92;
if(score >= 90){
System.out.println("吃个大鸡腿!!!");
}

Ⅱ、语法格式2

1
2
3
4
5
if(布尔表达式){
// 语句1
}else{
// 语句2
}

如果布尔表达式结果为true，则执行if中语句，否则执行else中语句。

比如：小明，如果这次考到90分以上，给你奖励一个大鸡腿，否则奖你一个大嘴巴子。

1
2
3
4
5
6
int score = 92;
if(score >= 90){
System.out.println("吃个大鸡腿!!!");
}else{
System.out.println("挨大嘴巴子!!!");
}

Ⅲ、语法格式3

1
2
3
4
5
6
7
if(布尔表达式1){
// 语句1
}else if(布尔表达式2){
// 语句2
}else{
// 语句3
}

表达式1成立，执行语句1，否则表达式2成立，执行语句2，否则执行语句3

比如：考虑到学生自尊，不公开分数排名，因此：

分数在 [90, 100] 之间的，为优秀，分数在 [80, 90) 之前的，为良好，分数在 [70, 80) 之间的，为中等，分数在 [60, 70) 之间的，为及格，分数在 [ 0, 60) 之间的，为不及格，错误数据。按照上述办法通知学生成绩。

1
2
3
4
5
6
7
8
9
10
11
12
13
if(score >= 90){
System.out.println("优秀");
}else if(score >= 80 && score < 90){
System.out.println("良好");
}else if(score >= 70 && score < 80){
System.out.println("中等");
}else if(score >= 60 && score < 70){
System.out.println("及格");
}else if(score >= 0 && score < 60){
System.out.println("不及格");
}else{
System.out.println("错误数据");
}

2、switch语句

1
2
3
4
5
6
7
8
9
10
11
12
switch (表达式) {
    case 常量1:
        // 执行语句块1
        break;
    case 常量2:
        // 执行语句块2
        break;
    // more cases...
    default:
        // 执行默认语句块
        break;
}

执行流程：

  • 先计算表达式的值

  • 和case依次比较，一旦有响应的匹配就执行该项下的语句，直到遇到break时结束

  • 当表达式的值没有与所列项匹配时，执行default

代码示例： 根据 day 的值输出星期

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
int day = 1;
switch(day) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("输入有误");
break;
}

【注意事项】

  • 多个case后的常量值不可以重复

  • switch的括号内只能是以下类型的表达式：

    • 基本类型：byte、char、short、int，注意不能是long类型

    • 引用类型：String常量串、枚举类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
double num = 1.0;
switch(num) {
    case 1.0:
        System.out.println("hehe");
        break;
    case 2.0:
        System.out.println("haha");
        break;
}
// 编译出错
Test.java:4: 错误: 不兼容的类型: 从double转换到int可能会有损失
			switch(num) {
				^
			 1 个错误
  • break 不要遗漏, 否则会失去 “多分支选择” 的效果
1
2
3
4
5
6
7
8
9
10
11
12
int day = 1;
switch(day) {
case 1:
System.out.println("星期一");
// break;
case 2:
System.out.println("星期二");
break;
}
// 运行结果
星期一
星期二
  • switch 不能表达复杂的条件
1
2
3
4
5
// 例如: 如果 num 的值在 10 到 20 之间, 就打印 hehe
// 这样的代码使用 if 很容易表达, 但是使用 switch 就无法表示.
if (num > 10 && num < 20) {
	System.out.println("hehe");
}
  • switch 虽然支持嵌套, 但是很丑，一般不推荐
1
2
3
4
5
6
7
8
9
10
11
12
13
14
int x = 1;
int y = 1;
switch(x) {
    case 1:
    	switch(y) {
    		case 1:
            System.out.println("hehe");
            break;
   		 }
   		 break;
   	 case 2:
        System.out.println("haha");
        break;
}

四、循环结构

1、while循环

Ⅰ、基本语法格式

1
2
3
while(循环条件){
	循环语句;
}

循环条件为 true, 则执行循环语句; 否则结束循环

比如：计算 5 的阶乘

1
2
3
4
5
6
7
8
9
int n = 1;
int result = 1;
while (n <= 5) {
    result *= n;
    n++;
}
System.out.println(num);
// 执行结果
120

比如：计算 1! + 2! + 3! + 4! + 5!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int num = 1;
int sum = 0;
// 外层循环负责求阶乘的和
while (num <= 5) {
    int factorResult = 1;
    int tmp = 1;
    // 里层循环负责完成求阶乘的细节.
    while (tmp <= num) {
        factorResult *= tmp;
        tmp++;
    }
    sum += factorResult;
    num++;
}
System.out.println("sum = " + sum);

这里我们发现, 当一个代码中带有多重循环的时候, 代码的复杂程度就大大提高了. 而比较复杂的代码就更容易出错，后面我们会采用更简单的办法来解决这个问题

Ⅱ、注意事项

  • 和 if 类似, while 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }

  • 和 if 类似, while 后面的 { 建议和 while 写在同一行.

  • 和 if 类似, while 后面不要多写 分号, 否则可能导致循环不能正确执行.

1
2
3
4
5
6
7
int num = 1;
while (num <= 10); {
System.out.println(num);
num++;
}
// 执行结果
[无任何输出, 程序死循环]

此时 ; 为while的语句体(这是一个空语句), 实际的 { } 部分和循环无关. 此时循环条件 num <= 10 恒成立, 导致代码死循环了。

Ⅲ、break

break 的功能是让循环提前结束

代码示例: 找到 100 - 200 中第一个 3 的倍数

1
2
3
4
5
6
7
8
9
10
int num = 100;
while (num <= 200) {
if (num % 3 == 0) {
System.out.println("找到了 3 的倍数, 为:" + num);
break;
}
num++;
}
// 执行结果
找到了 3 的倍数, 为:102

执行到 break 就会让循环结束

Ⅳ、 continue

continue是一种用于跳过当前循环中剩余的语句并进入下一次循环的关键字。它通常用于在循环中跳过某些条件不符合的代码块，从而提高程序效率。

当在循环体内使用continue语句时，会立即跳过该循环体内剩余的语句，并开始下一次循环，直到循环结束或者遇到break语句为止。

代码示例: 找到 100 - 200 中第一个 3 的倍数

1
2
3
4
5
6
7
8
9
int num = 100;
while (num <= 200) {
if (num % 3 != 0) {
num++; // 这里的 ++ 不要忘记! 否则会死循环.
continue;
}
System.out.println("找到了 3 的倍数, 为:" + num);
num++;
}

执行到 continue 语句的时候, 就会立刻进入下次循环(判定循环条件), 从而不会执行到下方的打印语句。

需要注意的是，continue语句只会跳过当前循环的剩余语句，而不是跳出整个循环。如果需要在循环中完全跳过某些情况，可以使用if语句或者其他的条件语句。

2、for循环

Ⅰ、基本语法格式

1
2
3
for(表达式①;布尔表达式②;表达式③){
	表达式④;
}

  • 表达式1: 用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次

  • 表达式2: 循环条件，满则循环继续，否则循环结束

  • 表达式3: 循环变量更新方式

【执行过程】

①②③④—>②③④—>②③④—>②③④—>②③④—>②③④—>…—>②为false，循环结束。

比如：计算 5 的阶乘

1
2
3
4
5
int result = 1;
for (int i = 1; i <= 5; i++) {
	result *= i;
}
System.out.println("result = " + result);

比如：计算 1! + 2! + 3! + 4! + 5!

1
2
3
4
5
6
7
8
9
int sum = 0;
for (int i = 1; i <= 5; i++) {
    int tmp = 1;
    for (int j = 1; j <= i; j++) {
  		tmp *= j;
    }
	sum += tmp;
}
System.out.println("sum = " + sum);

Ⅱ、注意事项

(和while循环类似)

  • 和 if 类似, for 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }

  • 和 if 类似, for 后面的 { 建议和 while 写在同一行.

  • 和 if 类似, for 后面不要多写 分号, 否则可能导致循环不能正确执行.

  • 和while循环一样，结束单趟循环用continue，结束整个循环用break

3、do-while循环

Ⅰ、基本语法格式

1
2
3
do{
	循环语句;
}while(循环条件);

do-while循环是一种重复执行特定代码块的结构，与for和while循环不同的是，它先执行一次循环体，再根据循环条件决定是否继续执行循环。

下面是一个使用do-while循环的示例代码：

1
2
3
4
5
int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 10);

在这个示例中，先初始化变量i的值为0，然后执行循环体，输出变量i的值，然后将i自增1。执行完一次循环体后，再根据条件i < 10决定是否继续执行循环。如果条件为true，则继续执行循环体；否则，跳出循环体。

需要注意的是，do-while循环至少会执行一次循环体，即使循环条件一开始就为false。这与while循环的执行方式不同，while循环在循环条件一开始就为false时，不会执行任何循环体。总之，do-while循环是Java中一种与for和while循环不同的重复执行代码块的结构，它先执行一次循环体，再根据循环条件决定是否继续执行循环。

Ⅲ、注意事项

  • do-while 循环最后的分号不要忘记

  • 一般 do-while 很少用到, 更推荐使用 for 和 while

五、猜数字游戏

1、输入输出

Ⅰ、输出到控制台

1
2
3
System.out.println(msg); // 输出一个字符串, 带换行
System.out.print(msg); // 输出一个字符串, 不带换行
System.out.printf(format, msg); // 格式化输出

  • println 输出的内容自带 \n, print 不带 \n

  • printf 的格式化输出方式和 C 语言的 printf 是基本一致的

Ⅱ、从键盘上输入

使用 Scanner 读取字符串/整数/浮点数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Scanner; // 需要导入 util 包
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的姓名：");
String name = sc.nextLine();
System.out.println("请输入你的年龄：");
int age = sc.nextInt();
System.out.println("请输入你的工资：");
float salary = sc.nextFloat();
System.out.println("你的信息如下：");
System.out.println("姓名: "+name+"\n"+"年龄："+age+"\n"+"工资："+salary);
sc.close(); // 注意, 要记得调用关闭方法
// 执行结果
请输入你的姓名：
张三
请输入你的年龄：
18
请输入你的工资：
1000
你的信息如下：
姓名: 张三
年龄：18
工资：1000.0

使用 Scanner 循环读取 N 个数字，并求取其平均值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Scanner sc = new Scanner(System.in);
int sum = 0;
int num = 0;
while (sc.hasNextInt()) {
    int tmp = sc.nextInt();
    sum += tmp;
    num++;
}
System.out.println("sum = " + sum);
System.out.println("avg = " + sum / num);
sc.close();
// 执行结果
10
40.0
50.5
^Z
sum = 150.5
avg = 30.1

sc.close()是Scanner类中的一个方法，用于关闭Scanner对象并释放与其关联的资源。调用这个方法可以确保程序在结束时释放Scanner对象和其它资源，以便下次使用时不会出现问题。

2、随机数生成

在Java编程语言中，随机生成0~100之间的随机数可以使用Java标准库中的java.util.Random类来实现。其中，Random类的nextInt()方法可以用于生成指定范围内的随机整数。

下面是一个示例代码，演示如何使用Random类生成0~100之间的随机整数：

1
2
3
4
5
6
7
8
import java.util.Random;
public class RandomDemo {
    public static void main(String[] args) {
        Random rand = new Random();
        int num = rand.nextInt(100) + 1; // 生成1~100之间的随机整数
        System.out.println("随机数是：" + num);
    }
}

在这个例子中，我们首先创建了一个Random对象rand，然后使用nextInt()方法生成0~100之间的随机整数，最后将生成的随机数输出到控制台。

需要注意的是，nextInt()方法返回的随机数范围是从0开始，不包括上限，因此生成的随机数可能是0~99之间的整数。为了包含100和1，我们应该在生成的随机数后面再加上1。

3、游戏实现

游戏规则

系统自动生成一个随机整数(1-100), 然后由用户输入一个猜测的数字. 如果输入的数字比该随机数小, 提示 “低了”, 如果输入的数字比该随机数大, 提示 “高了” , 如果输入的数字和随机数相等, 则提示 “猜对了” 。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Random;
import java.util.Scanner;;
class Test {
public static void main(String[] args) {
    Random random = new Random(); // 默认随机种子是系统时间
    Scanner sc = new Scanner(System.in);
    int toGuess = random.nextInt(100)+1;
    // System.out.println("toGuess: " + toGuess);
    while (true) {
        System.out.println("请输入要输入的数字: (1-100)");
        int num = sc.nextInt();
        if (num < toGuess) {
        	System.out.println("低了");
        } else if (num > toGuess) {
        	System.out.println("高了");
        } else {
        	System.out.println("猜对了");
        	break;
        }
      }
      sc.close();
	}
}