一、Java控制语句概述
Java 中的控制语句主要分为选择结构、循环结构和跳转语句三大类，它们在程序中起着至关重要的作用，能够决定程序的执行流程。
选择结构用于根据不同的条件执行不同的代码路径，主要包括 if 语句和 switch 语句。if 语句有多种形式，如 if 单选择结构、if 双选择结构、if 多选择结构和嵌套的 if 结构。switch 语句则用于多值判断，根据变量与一系列值的匹配情况执行相应的代码。
循环结构用于重复执行一段代码，主要包括 for 循环、while 循环和 do...while 循环。for 循环是计数型循环，通过初始值、结束值和增量来控制循环次数。while 循环是条件型循环，只要给定的条件为真，就会一直执行循环体。do...while 循环与 while 循环相似，但至少会执行一次循环体。
跳转语句用于实现程序执行流程的有目的转移，主要包括 break 语句、continue 语句和 return 语句。break 语句用于跳出当前的循环或 switch 语句；continue 语句用于跳过当前循环的剩余部分，开始下一次循环迭代；return 语句用于从方法返回一个值，并退出当前方法。
二、选择结构
1. if语句
- if单选择结构：语法结构为 if(布尔表达式){语句块;}。例如在掷骰子小程序中，可以根据点数判断是否获奖。通过生成随机数模拟掷骰子的结果，如果点数满足特定条件，就可以执行相应的操作，如输出"今天手气不错"等。
- if - else双选择结构：语法结构为 if(布尔表达式){语句块1;}else{语句块2;}。如判断圆的面积和周长大小，可以随机产生一个半径，根据半径计算圆的面积和周长，然后通过 if - else 结构判断面积和周长的大小关系，输出相应的结果。
- if - else if - else 多选择结构：可用于多种情况的判断，语法为 if(布尔表达式1){语句块1;}else if(布尔表达式2){语句块2;}......else if(布尔表达式n){语句块n;}else{语句块 n + 1;}。如根据分数输出对应等级，可以生成一个随机数模拟分数，然后通过多个 if - else if - else 结构判断分数所在的区间，输出对应的评级，如"A""B""C""D"等。
2. switch语句
- 常用来对多值进行判断并选择，语法格式为 switch(表达式){case 值1:语句块1;[break];case 值2:语句块2;[break];......[default:默认语句;]}。例如根据字符判断是元音、半元音还是辅音，或者根据随机生成的数字判断是星期几等。如以下代码示例：
int week = 1;
switch(week){
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("没有此星期");
}
switch 语句还有几个注意点：
（1）. case 与 default 之间没有顺序，但是无论 default 与 case 的位置如何。总是先执行第一个 case，与 default 的放置位置没关系。
（2）. 穿透：当 case 内没有 break 的时候，程序会继续往下走，会将 case2 的输出语句也执行，将会跳过 case2 的判断语句；直到 break 出现才跳出语句。如下：程序将会输出打印：今天是星期一今天是星期二。
case 1：System.out.println("今天是星期一");
case 2:System.out.println("今天是星期二");break；
（3）.当使用的是 char 类型的变量时：需要对 case 中的值加单引号' '。
从 Java 12 开始，switch 语法支持函数式接口和 lambda 表达式，使用"->"方法更加简单，"->"的用法其实只是相当于不用输入 break 就可以跳出判断，保证其只有一条分支可走。示例：
int dayOfWeek = 2;
switch (dayOfWeek) {
case 1 -> System.out.println("星期一");
case 2 -> System.out.println("星期二");
case 3 -> System.out.println("星期三");
case 4 -> System.out.println("星期四");
case 5 -> System.out.println("星期五");
case 6 -> System.out.println("星期六");
default -> System.out.println("星期日");
}
Java 12 之后还可以多条件合并：
int dayOfWeek = 2;
switch (dayOfWeek) {
case 1,2,3,4,5 -> System.out.println("工作日");
default -> System.out.println("其他");
}
Java 14 新特性，增加了 yield 用法：
int numLetters = switch(seasonName){
case "Spring" ->{System.out.println("spring time");yield 6;}
case "Summer","Winter" -> 6;
case "Fall" -> 4;
default -> -1;
};
示例：
int dayOfWeek = 2;
String weekday = switch (dayOfWeek) {
case 1:yield "星期一";
case 2:yield "星期二";
case 3:yield "星期三";
case 4:yield "星期四";
case 5:yield "星期五";
case 6:yield "星期六";
default:yield "星期日";
};
System.out.println(weekday);
三、循环结构
循环结构在 Java 中用于重复执行一段代码，主要包括 while 循环、do-while 循环和 for 循环。
1. while 循环
while 循环是条件型循环，语法结构为while(布尔表达式){循环体;}。只要给定的条件为真，就会一直执行循环体。例如求 1 到 100 的累加和：
int result = 0;
int i = 1;
while(i <= 100) {
result += i;
i++;
}
System.out.println(result);
2. do-while 循环
do-while 循环会先执行循环体，再判断布尔表达式的值，至少执行一次。语法结构为do{循环体;}while(布尔表达式);。
int i = 100;
do {
System.out.println("Hello world");
i++;
} while(i < 10);
System.out.println("--------");
3. for 循环
for 循环是支持迭代的通用结构，语法格式为for(初始表达式;布尔表达式;迭代因子){循环体;}。
- 可用于多种场景，如无限循环：
for(;;) {
// 循环体
}
- 打印九九乘法表：
for (int i=1;i <= 9;i++){
for (int j=1;j <= i;j++){
System.out.print(j + "*" + i + "=" + (i*j) + "\t");
}
System.out.println();
}
4. 循环的嵌套
在一个循环里面嵌套一个或多个循环，如九九乘法表的实现就是通过循环的嵌套来完成的。外层循环控制行数，内层循环控制列数。
for (int i=1;i <= 9;i++){
for (int j=1;j <= i;j++){
System.out.print(j + "*" + i + "=" + (i*j) + "\t");
}
System.out.println();
}
四、跳转语句
1. break和continue语句
- break用于强行退出循环，不执行循环中剩余的语句。break语句通常在循环或switch语句中使用，其作用是立即终止当前循环或switch语句块的执行，程序将从循环或switch语句块之后的语句继续执行。例如在嵌套循环中，当满足特定条件时，可以使用带标签的break语句来跳出多层循环。如下代码所示：
outer:for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
if (j == 5) {
break outer;
}
System.out.println("i=" + i + ", j=" + j);
}
}
System.out.println("程序运行结束！");
在这个例子中，当内层循环的变量j等于5时，使用带标签的break语句跳出了外层循环和内层循环，程序直接执行System.out.println("程序运行结束！");。
- continue用于退出本次循环。continue语句只能在循环语句中使用，其作用是结束本次循环，直接进入下一次循环迭代。例如在打印100以内奇数的例子中：
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) {
continue;
}
System.out.println(i);
}
在这个例子中，当变量i是偶数时，使用continue语句跳过当前循环，不执行System.out.println(i);，直接进入下一次循环迭代。带标签的break和continue可以控制嵌套循环的跳转。例如：
outer:for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
if (j == 5) {
continue outer;
}
System.out.println("i=" + i + ", j=" + j);
}
System.out.println("--- LOOP2END ---");
}
System.out.println("程序运行结束！");
在这个例子中，当内层循环的变量j等于5时，使用带标签的continue语句跳过外层循环的当前迭代，直接进入下一次迭代。
五、语句块和方法
1. 语句块
语句块即用花括号{}括起来的任意数量 Java 语句，它确定了局部变量的作用域。在 Java 中，语句块可以嵌套在另一个语句块中，但不能在嵌套的两个块内声明同名的变量。例如：
public class StatementBlockExample {
public static void main(String[] args) {
int n;
{
int k;
}
// k 变量只在内部块中有作用，在这里无法访问。
}
}
2. 方法
方法是一段带名字的语句块，可反复被调用，用于定义该类或该类的实例的行为特征和功能实现。
在 Java 中，方法通常定义在类中，并通过类的实例调用。定义方法的基本语法为：修饰符 返回类型 方法名(参数类型1 参数名1, 参数类型2 参数名2,...) {方法体}。
其中，修饰符指定了该方法访问修饰符，如 public、private、static 等；返回类型指定方法返回的数据类型，如 int、double 等；方法名是指定方法的名字；参数列表指定传入的参数类型和参数名；方法体则是指定该方法要执行的代码。
例如，以下是一个简单的加法方法：
public class MethodExample {
public int add(int a, int b) {
int sum = a + b;
return sum;
}
public static void main(String[] args) {
MethodExample example = new MethodExample();
int result = example.add(3, 4);
System.out.println(result);
}
}
方法的调用方式有多种，当方法返回一个值的时候，方法调用通常被当做一个值。如果方法返回值是 void，方法调用一定是一条语句。
方法还可以重载，即在一个类中，有相同的函数名称，但形参不同的函数。方法重载的规则包括方法名称必须相同、参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）、方法的返回类型可以相同也可以不相同，但仅仅返回类型不同不足以成为方法的重载。
例如：
public class OverloadExample {
public static int add(int n1, int n2) {
int sum = n1 + n2;
return sum;
}
public static int add(int n1, int n2, int n3) {
int sum = n1 + n2 + n3;
return sum;
}
public static double add(double n1, int n2) {
double sum = n1 + n2;
return sum;
}
public static double add(int n1, double n2) {
double sum = n1 + n2;
return sum;
}
public static void main(String[] args) {
System.out.println(add(3, 5));
System.out.println(add(3, 4, 5));
System.out.println(add(3.05, 5));
System.out.println(add(3, 5.05));
}
}