4.1顺序控制

程序从上到下逐行执行，中间没有任何判断和跳转（默认的控制顺序）

比如：Java 定义变量时采用合法的前向引用。

1
2
graph LR
A(A语句)-->B(B语句)-->C(C语句)-->D(D语句)-->E(...)

语句：Java 中最小的执行单位。语句分为 单语句 和 复合语句。

  • 单语句：通常意义的一条语句。语句间以分号 ; 分隔。

  • 复合语句：一对大括号括起来的语句组。也称为 “块”

    1
    2
    3
    4
    5
    {
        语句1; 
        语句2;
        ...
    }

    块中可以有多条语句。块后没有分号 ;

4.2 分支控制 if-else

让程序有选择的执行。主要分为：单分支控制、双分支控制

4.2.1 单分支控制

1
2
3
if (条件表达式) {
    语句;
}

特别地，把代码块（复合语句）作为语句的场合也能这样写：

1
2
3
if (条件表达式) {
 执行代码块;
}

当条件表达式为 ture，就会执行 {执行代码块;}；如果为 false 则不执行。特别地：如果 {执行代码块;} 中只有一条代码，也可以不写 { }（但还是建议写上）

4.2.2 双分支控制

1
2
3
4
5
if (条件表达式) {
 执行代码块;
} else {
 执行代码块2;
}

当条件表达式为 ture，就会执行 {执行代码块1;}；如果为 false 则执行 {执行代码块2;}。单条语句可以不用{}；

4.2.3 多分支控制

1
2
3
4
5
6
7
8
9
10
11
12
13
if (条件表达式) {
 执行代码块;
} 
else if (条件表达式2) {
 执行代码块2;
} 
else if (条件表达式3) {
 执行代码块3;
}
...
else {
 执行代码块n；
}

特别地：多分支可以没有 else。如果条件都不成立，有else则执行else的代码块。没有else 则无执行入口；

4.2.4 嵌套分支

在一个分支结构中又完整嵌套了另一个完整的分支结构。里面的分支称为内层分支，外面的分支称为外层分支。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if（）{
    if（）{
        if（）{   //三层嵌套
            
        }
        else{
            
        }
    }
    else{
        
    }
}
else{
    
}

Java 规定，else 子句属于逻辑上距其最近，且没有匹配 else 的 if 语句：

1
2
3
4
int n = 0;
if (n > 0) n++;
if (n > 1) n++;	//属于此条 if 语句
else n--;

这个场合，这个 else 语句属于上面的 if (n > 1) 这个语句

要想改变那个匹配关系，要使用 { } 改变语句结构：

1
2
3
4
5
int n = 0;
if (n > 0) {
    n++;
	if (n > 1) n++;  
} else n--;

规范：嵌套尽量不超过 3 层（可读性不好） l

4.3 switch 分支结构

1
2
3
4
5
6
7
8
9
10
11
12
switch(表达式){
	case 常量1:
		语句块1;
		break;			//break 语句可选
	case 常量2:
		语句块2;
		break;			//break 语句可选
	...
	default:			//default 语句可选
		default语句块;
		break;			//break 语句可选
}
  1. switch 关键字，表示 switch 分支。
  2. 表达式 对应一个值。该值必须是 int 或 char（char 可以转化为 int）。是 byte 或 short 的场合，要提升为 int。不允许 long、double 或 float
  3. case 常量1; 表示：当 表达式 的值等于 常量1 ，则执行 语句块1。
  4. break; 表示退出 switch 分支。
  5. 当 表达式 的值匹配 常量1 ，则执行 语句块1，如果不匹配，则继续匹配 常量2 ，以此类推。
  6. 如果全都不匹配，则执行 default。
  7. 如果不写 break; ，则会发生穿透，即不进行判断而继续执行下一语句块。

4.3.1 使用细节

  1. 表达式; 数据类型，应和 case 后的 常量 类型一致，或者是可以自动转换成可以比较的类型。如：输入的是 char 而 常量 是 int

  2. switch 中 表达式 的返回值必须是：byte short int char enum String

    ——enum 是什么？详见枚举

  3. case 语句中的值必须是 常量 或 常量表达式，不能是 变量。

  4. default 是可选的。没有就不执行。

  5. break; 用来跳出 switch 分支。如果不写，会持续执行语句，直到分支结束或遇到下一个 break;

4.3.2 与 if-else 分支结构的取舍

  • 如果判断的具体数值不多，且满足前后变量类型一致，推荐使用 switch。
  • 对区间判断的场合，对结果为 boolean 类型的判断，使用 if-else。

4.4 for 循环控制

让代码可以循环执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
for(循环变量初始化;循环条件;循环变量迭代){
循环操作（代码块）;
}
for(int i = 0;i < 100;i++){//正确，但是i的使用范围只能在循环内部
    代码块
}
int i=0;
for(;i<100;){  //正确，此处的i的使用范围不局限于循环内部
    代码块
}
for(;;){
    //无限循环
}
  • for 关键字，表示循环控制
  • 四个要素：1. 循环变量初始化 2. 循环的条件 3. 循环的操作 4. 循环变量迭代

所有循环开始前仅一次进行初始化。直到循环条件变为 false 前，执行循环操作。每轮循环结束后，进行循环变量迭代。

  • 循环操作可以有多条语句
  • 如果循环操作只有一条语句，可以省略 " {}"，但建议不省略

4.4.1 使用细节

  1. 循环条件是返回一个 boolean 值（ture 或 false）的公式。

    循环条件可以为空。这个场合，默认为真（true）

  2. for(;循环条件;){ } 其中的初始化和变量迭代可以写在别处，但 ; 不能省略。如果不写在别处，那个 循环变量初始化 中声明的变量只能在该 for 循环中使用。

  3. 控制台用 ctrl + c 强制结束一个流程

  4. 循环初始值可以有多条初始化语句，但要求类型一样，并用 , 隔开。

    变量迭代也可以有多条代码，用 , 隔开。

4.4.2 for each（泛型 for 循环）

泛型 for 循环（增强 for 循环）能用来依次处理数组（或其他元素集合）中的每个元素，而不必考虑下标值

1
2
3
for(int i : nums){						//其中 nums 是一个一维 int 数组
	System.out.println(i);
}

上述写法（增强 for 写法）类似于以下写法

1
2
3
for(int i = 0; i < nums.length; i++){
	System.out.println(nums[i]);
}

泛型 for 循环适用于数组或一个实现了Iterable接口的对象。泛型for循环的本质是一个 Iterator（迭代器）

—— 迭代器，见 [[13.2.2.1 用 Iterator 遍历元素]]

4.5 while 循环控制

1
2
3
4
while(循环条件){
 循环体(代码块);
 循环变量迭代;
}

while 也有四要素，只是位置和 for 不同

4.5.1 使用细节

  1. 循环条件是返回一个 boolean 值（ture 或 false）的公式。

    while 循环中，循环条件不能为空。

  2. while 循环是先判断再执行语句。

4.6 do..while 循环控制

1
2
3
4
do{
循环体;
循环变量迭代;
}while(循环条件);
  1. do while 是关键字
  2. 也有四要素，位置不同
  3. 先执行，再判断。也就是说，一定会至少执行一次
  4. 最后有一个 ;
  5. while 与 do..while 区别：do..while先不管循环条件执行一次，while是循环条件为真则执行；

4.6.1 使用细节

  1. 循环条件是返回一个 boolean 值（ture 或 false）的公式。
  2. do..while 循环是先执行再判断的语句。因此至少执行一次。

4.7 多重循环控制

将一个循环放在另一个循环体内，就形成了嵌套循环。建议一般使用两层，最多不超过三层。

嵌套循环 是把 内层循环 当成 外层循环 的 循环体。只有内层 false 时才可能结束当层循环。

若内层执行 n 次，外层 m 次，则合计会循环 n*m 次

以下是一个示例（乘法口诀）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class project{
   public static void main(String[] args){
      int a = 1;	//声明第一个乘数
      int b = 1;	//声明第二个乘数
      do{
               //直到 a > b 为止，a 不断增长，并让两数相乘，输出公式
          	do{
                  System.out.print(a + " * " + b + " = " + a * b + "\t");
                   a++;
             } while (a <= b);
               //把 a 重置为 1，让 b 增长，然后循环
           a = 1;
           System.out.println();
           b++;
      } while (b <= 9);
   }
}

4.8 跳转控制语句

跳转控制语句用于分支或循环中，以便程序员更好控制程序执行方向

4.8.1 标签

1
2
3
4
5
6
7
8
a:{
b:	{
c:		{
   ...
		 berak b;
		}
	}
}
  1. a: b: c: 是标签，名字由程序员指定
  2. break 后指定哪个标签就退出到哪里,如果没有指定标签，默认退出最近的循环体。
  3. 实际开发中，尽量不要使用标签

4.8.2 break

用于中止一个语句块的执行

语法：break;

break 可以被用在三种场合中

  • switch 语句中，以跳出判断（结束穿透）

  • for、while、do…while 循环语句中，以跳出循环

  • 语句块中，以跳过本块中所有剩余语句

    break 语句出现在多层嵌套的语句块中时，可以通过 标签 指明要终止的时哪一层语句块，如果没有标签，则会跳出最近的语句块（循环等等）。

4.8.3 continue

在循环中出现。用于结束本次循环，继续下一次循环

语法：continue;

进行下次循环前，仍会判断循环条件是否满足

在多层嵌套循环中，可以通过标签指出跳出哪次循环（同 break）

4.8.4 return

用于方法。表示跳出所在的方法

语法：return;

方法有返回值的场合，将返回值写在 return 后：return 值;

——见 [[6.2 成员方法])

如果写在 主方法 则跳出程序（程序执行结束）。