【Java启程】语句结构

顺序结构

一般而言，程序是在 main 函数内从上到下逐条执行的，遵循这样的执行顺序我们称之为顺序结构。

• ~用游戏的思路来理解，顺序结构可以理解为从头到尾一条主线，没有任何支线。每执行一条语句相当于过了一个剧情，紧接着唯一一个后续剧情，直到游戏结束。或者用地牢迷宫的思路来理解，把执行一条语句视为进入一个房间且每进入一个房间后返回的路会被关闭，那么顺序结构从第一个房间开始，每进入一个房间都会关闭返回的门且提供一扇向前的门，直到游戏结束或者说 main 函数结束。~

分支结构

分支结构又称选择结构，它表示程序在执行某一语句时根据条件状态的不同从而执行不同的结果。

• _{分支语句可以理解成地牢迷宫到达某一阶段时进行的条件判定，满足条件才能进入这一阶段的房间，不满足则会直接跳过这个房间。进阶一点的分支语句会根据你条件的执行情况给你开启不同的房间，可以理解为游戏进入了不同的世界线。}

三元运算符可以实现较为简单的分支结构，不过本节我们主要介绍通过条件语句 if 和 switch 来实现分支结构。

• if语句

“if” 表示 “如果” ，那么显然 “if语句” 就是 “如果怎么怎么样，就怎样怎样” 的意思。 if语句常与 “else” 连用， “else” 这里理解为 “其他情况” 。完整的 if 语句格式如下：

if (条件1) {
	语句块1;
} else if (条件2) {
	语句块2;
} ...  //这里假装省略一下§(*￣▽￣*)§
else if (条件n) {
	语句块n;
} else {
	语句块；
}

建议将 “else if” 和 “else” 直接跟在大括号后面而不是另起一行。
逐条分析一下：

if (条件1) {
	语句块1;
}

这条语句是说如果条件1成立，则执行语句块1，那么显然条件1的最终结果需要告诉我们条件1成立与否，所以条件1可以是单个表达式也可以是通过运算符衔接的任意多的表达式，但它的结果必须为确定的布尔值。
语句块1只有条件成立时才会执行。若条件不成立，则跳过整个 if大括号而继续执行后续语句。
事实上，单个的 if语句块已经可以作为一个完整分支语句来执行，后续的 “else if” 块和 “else” 块均是可省略的。
需要特别说明一点，如果 if语句条件成立后执行的代码只有一行，则可以省略大括号并写成如下形式：

if (条件1) 语句1;

但是，强烈不推荐这种写法！

继续往下看代码：

else if (条件2) {
	语句块2;
} ...
else if (条件n) {
	语句块n;
}

我们已经说过， “else” 表 “其他情况” ，它是常与 if 连用的一个词，当 if 语句块成立时就根本不会执行。 “else” 不能脱离 “if” 单独出现在程序中。 “else if” 表在先前的 if 条件不成立的情况下继续提出 “如果” ，再往后的 “else if” 也以此类推。

else {
	语句块；
}

最后，用一个 “else” 语句块表示在上述所有 if 全都不成立的情况下剩余的所有情况该执行的情况，执行完毕后程序会继续执行下面的语句。若一个大的 if 结构最后没有 else 语句块且所有判断条件均不成立，则程序会跳过整个 if 结构直接去执行后续语句。

下面我们设计一个案例，用于演示三种 if 语句结构：

public class IfDemo {
    public static void main(String[] args) {
        int i = 10, j = 10;
        boolean a,b; // boolean初始值默认为false

		/*--- 单分支语句结构 ---*/
        if (i >= 10) {
            System.out.println("条件1达成 🗡");
            a = true;
        }

		/*--- 双分支语句结构 ---*/
        if (j >= 10) {
            System.out.println("条件2达成 🛡");
            b = true;
        } else {
            System.out.println("条件2未达成 ☻");
        }

		/*--- 多分支语句结构 ---*/
        if (a = true && b = true) {
            System.out.println("你正是天选之人！");
            System.out.println("得到了奖品大凶残！");
        } else if (a = true || b = true) {
            System.out.println("你有资格接受我的试炼！");
            System.out.println("是否立即接受考研？");
        } else {
            System.out.println("晚点再来吧。");
        }
    }
}

• switch语句

“switch” 是 “开关，闸” 的意思。使用 switch 语句的完整格式如下：

switch (表达式) {
	case 值1:
		语句体1;
		break;
	case 值2:
		语句体2;
		break;
	...
	default:
		语句体;
}

当 switch 后表达式的值和 case 语句后的值相同时，从该位置开始向下执行，直到遇到 break 语句或者 switch 语句块结束；如果没有匹配的 case 语句则执行 default 块的代码。switch 后面小括号中表达式的值必须是整型或字符型，case 后面的值可以是常量数值也可以是一个常量表达式，但不能是变量或带有变量的表达式。
特别说明，当一旦判定成立，则在遇到 break 语句或者 switch 语句块前程序不会从语句块里跳出。演示如下：

public class SwitchDemo {
    public static void main(String[] args) {
        // 判断布尔值
        switch (0) {
            case 0:
                System.out.println(false);
            case 1:
                System.out.println(true);
                break;
            default:
                System.out.println("wrong boolean");
        }
    }
}

其输出结果却为：

false
true

因为在 case 0 判定成功进入 switch 结构后，程序并不会在碰到 case 1 时截止，而是绕过 case 1 的判定直接执行后面的代码，直到遇到 break 或 switch 结束。

这一特性我们也能加以利用，如设置三等奖只有一件奖品，二等奖能拿到专属奖品以及三等奖的奖品，一等奖特等奖以此类推，演示代码如下：

public class SwitchDemo {
    public static void main(String[] args) {
        // 判断布尔值
        switch (1) {
            case 0: // 用 0 代指特等奖
                System.out.println("你得到了特等奖品 ♕ ！！！！！");
            case 1: // 用 1 代指一等奖
                System.out.println("你得到了一等奖品 ♔ ！！！");
            case 2: // 用 2 代指二等奖
                System.out.println("你得到了二等奖品 ♖ ！！");
            case 3: // 用 3 代指三等奖
                System.out.println("你得到了三等奖品 ♙ ！");
                break; // 获奖与不获奖是两种状态，在这里必须截止了
            default: // 这个……不用说了吧。。。。。
                System.out.println("你没得到奖品 ☻");
        }
    }
}

^{小声bb，在代码行后直接加备注似乎不是一个好习惯……}

输出结果为：

你得到了一等奖品 ♔ ！！！
你得到了二等奖品 ♖ ！！
你得到了三等奖品 ♙ ！

循环结构

在设计程序时，有时我们不仅要面临多种情况进行选择的问题，还会面临要求某一步骤多次执行的情况，于是循环结构应运而生。

• _{循环结构的具象理解就是卡剧情了，需要重复刷副本练级直到达到要求为止。}

虽然循环执行的内部重复过程很枯燥，但循环结构是必要的。有时我们需要对某一步骤重复进行几十上百次或者更多，如果不使用循环结构，那么所需的代码数量是极为庞大的。

• for 循环

for 循环是最常用的循环结构，其格式如下：

for (初始化语句; 条件判断语句; 条件控制语句) {
   循环体语句:
}

初始化语句：用于在第一次循环开始之前初始化一个循环变量，该变量只存在于该次循环中，循环结束后该变量不再存在；
条件判断语句：是循环的执行条件，每次循环前都会先判断该次循环是否满足该条件，若true则继续进行循环，若false则循环结束；
条件控制语句：用于改变变量控制条件，如每执行一次循环让循环变量加1或每执行一次循环让循环变量乘2等。
for循环条件里的三个表达式均可被省略，但相隔的 “;” 不可以被省略！

案例：用 for 循环实现在控制台输出五次 “武汉加油！中国加油！”

public class ForDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("武汉加油！中国加油！");
        }
    }
}

• while 循环

while 循环也是常用的一种循环体，其格式如下：

while (条件判断语句) {
	循环体语句;
	条件控制语句;
}

其中条件判断语句与条件控制语句的作用同 for 循环。
可见 while 语句没有专属的循环变量。若要实现类似 for 循环的结构，需在 while 循环前自行定义一个变量充当循环变量，且该变量在循环结束后继续存在。
大多数情况下， while 循环和 for 循环能够实现相互转换，其区别仅在于循环变量是局部变量还是全局变量。

案例：用 while 循环实现在控制台输出五次 “武汉加油！中国加油！”

public class WhileDemo {
    public static void main(String[] args) {
        int j = 1;
        while (j <= 5) {
            System.out.println("武汉加油！中国加油！");
            j++;
        }
    }
}

• do…while循环

do… while 循环有别于前两种循环，它其实是 while 循环的变体，其格式如下：

do {
	循环体语句;
	条件控制语句;
} while (条件判断语句);

其各成分的作用同 while 循环。相应的，它的循环变量也需提前定义且循环结束后会保留。
注意到这种写法的条件判断语句是在大括号后面的，而前两种循环结构的条件判断语句都是在大括号前，我们分别称之为后验循环和前验循环。后验循环的特点就是不管条件判断语句是否成立，循环都会先执行一次。
最后，注意 do…while 循环的结尾处有一个 “;” 。

案例：用 do…while 循环实现在控制台输出五次 “武汉加油！中国加油！”

public class WhileDemo {
    public static void main(String[] args) {
        int i = 1;
        do {
            System.out.println("武汉加油！中国加油！");
            i++;
        } while (i <= 5);
    }
}

• 循环结构中的跳转控制语句

break：该关键词单独使用可用于跳出switch分支语句，在上文中已做过演示。除此之外，它还可以用于终止单重循环。

continue：该关键词用于在循环结构中，作用为跳过当此循环、继续执行下一次循环。

以水仙花数的案例为例：
案例：一个三位数，若其个位数的三次方、十位数的三次方以及百位数的三次方之和等于这个数本身，则称其为水仙花数。

public class ControlDemo {
    public static void main(String[] args) {
        int start = 100;
        int end = 1000;
        for (int i = start; ; i++) {
            int g = i % 10;
            int s = i / 10 % 10;
            int b = i / 100 % 10;
            if (g * g * g + s * s * s + b * b * b != i) {
                continue; // 该数不是水仙花数，跳过本次循环，转到下次循环的判断
            } else if (i >= end) {
                break; // 越界了，终止循环
            }
            System.out.println(i); // 没被上面的条件刷掉，该数是水仙花数了
        }
    }
}

break 和 continue 并非正常的跳出循环的途径，而是对某些特殊情况的处理。像上例就可以通过调节语句结构从而省掉 break 和continue。但在某些时候，跳转控制语句是非常好用的。

语句结构的灵活运用

• 结构嵌套

分支嵌套结构案例：输入一个两位整数，用 if 语句判断该数是否是三的倍数或在某一位为三。若满足上述条件，在控制台输出 “过” ；若不满足，则在控制台输出该数。

import java.util.Scanner; // 输入操作要导包

public class Demo1 {
    public static void main(String[] args) {
    	Scanner sc = new Scanner(System.in);
        System.out.print("请输入你的序号：");
        int num = sc.nextInt();
        if (num > 0 && num < 100) {
        	System.out.print("你该报的是：");
        	if (num % 3 == 0 || num % 10 == 3 || num / 10 % 10 == 3) {
        		System.out.println("过");
        	} else {
            	System.out.println(num);
        	}
        } else {
        	System.out.println("你说的数可能越界了");
        }
    }
}

循环嵌套结构案例：用循环实现在控制台输出 1~100 内的质数。

public class Demo2 {
	public static void main(String[] args) {
		int n = 0;
		for (int i = 1; i < 100; i++) {
			n = 0; // 因数归零
			for (int j = 1; j <= i; j++) {
				if (i % j == 0) {
					n++;
				}
			}
			if (n == 2) { // 质数只有它本身和1两个因数
				System.out.println(i);
			}
		}
	}
}

• 跳转控制语句跳出多层循环：

break 和 continue 单独使用时都只能作用于一重循环。若 break 还在 switch 结构中，则它只对 单重 switch 起作用，但我们可以通过加标签来实现跳出任意层循环。
仍以水仙花数的题目为例：

public class ControlDemo {
    public static void main(String[] args) {
    	OUTER:
        for (int a = 1; a < 10; a++) {
        	OUT:
        	for (int b = 0; b < 10; b++) {
        		if(a * a * a + b * b * b > a * 100 + b * 10) {
        			continue OUTER; // 这次循环没必要往下执行了
        		}
        		for (int c = 0; c < 10; c++) {
        			int num = (a * a * a) + (b * b * b) + (c * c * c);
        			int n = a * 100 + b * 10 + c;
        			if (num == n) {
        				System.out.println(num);
        			} else if (num > n) {
        				continue OUT; // 这次循环没必要往下执行了
        			}
        		}
        	}
        }
    }
}

^{新人上路，求给意见。}