本节学习目标

• 掌握Java中分支结构、循环结构、循环控制语法的使用；
  
  

1️⃣ 程序逻辑控制

一般来说程序的结构包含顺序结构、选择结构、循环结构3种。 这3种不同的结构有一个共同点，就是它们都只有一个入口，也只有一个出口。程序中使用了上面这些结构有什么好处呢? 这些单一入口和出口可以让程序易读、好维护，也可以减少调试的时间。

1.1 顺序结构

前面文章中所讲的案例采用的都是顺序结构，程序至上而下逐行执行， 一条语句执行完后继续执行下一条语句， 一直到程序的末尾，这种结构就叫顺序结构。如下图所示：

顺序结构在程序设计中是最常使用的结构，在程序中扮演了非常重要的角色，因为大部分程序基本上都是依照这种由上而下的流程来设计的，由于之前一直都是按照顺序结构编写程序，所以本节主要针对选择和循环结构进行详细讲解。

1.2 分支结构

选择(分支)结构是根据条件的成立与否，再决定要执行哪些语句的一种结构，其执行流程如下图所示。

这种结构可以依据判断条件的结果，来决定要执行的语句。 当判断条件的值为真（true）时，就运行“语句体”；当判断条件的值为假（false）时，则不执行“语句体"。不论执行哪一个分支逻辑，最后都会回到“其他语句"继续执行。

分支结构为程序增加了选择的逻辑结构，就像做人生抉择一样，不同的抉择有不同的结果。对于分支结构有两类语法支持： if、switch。

1.2.1 if 选择结构

if 选择结构有如下三种使用方式：if、if…else、if…else if…else，这3种结构的执行流程图示如下（结合后面的代码案例更好理解呦）。

• if 语句
  if 语句一般用于在某个条件为真时执行特定的代码块。它的特征是只包含一个条件和一个相应的代码块，如果条件为真，将执行该代码块；否则，跳过整个 if 语句。其完整语法如下：

  //	1、if语法
  if(布尔表达式){
  	条件满足时执行的程序;
  }
  

  下面以代码案例演示对于以上这种选择结构的使用方式及其作用：

  // 案例 1：使用 if 语句进行判断
  public class TestDemo{
  	public static void main(String args[]){
  		double score =90.0;                         //定义变量
  		if(score>=60.0){                              //设置判断条件
  			System.outprintln("恭喜考试成绩及格了!");
  		}
  	}
  }
  

  程序执行结果：

  恭喜考试成绩及格了!
  

  此程序首先定义了一个 double 类型的变量score ，然后使用 if 语句判断此变量的内容是否大于 “60.0”，如果条件满足，则执行输出操作。

• if...else 语句
  if...else 语句也用于根据条件执行不同的代码块，但它提供了两种选择。它的特征是有两个代码块，即 if 部分和 else 部分，如果条件为真，将执行 if 部分的代码块；如果条件为假，则执行 else 部分的代码块。其完整语法如下：

  //	2、if..else语法
  if(布尔表达式){
  	条件满足时执行的程序;
  }else{
  	条件不满足时执行的程序;
  }
  

  下面以代码案例演示对于以上这种选择结构的使用方式及其作用：

  // 案例 2：使用 if…else 语句进行判断
  public class TestDemo{
  	public static void main(String args[){
  		double score =30.0;                                 //定义变量
  		if(score>=60.0){                                              //条件判断满足
  			System.out println("恭喜考试成绩及格了!");
  		} else{                                                 //条件判断不满足
  			System.out println("很遗憾考试成绩未及格!");
  		}
  	}
  }
  

  程序执行结果：

  很遗憾考试成绩未及格!
  

  此程序使用了if…else结构，如果在if语句中的判断条件不满足，那么将执行 else 分支中的代码。

• if...else if...else 语句
  if...else if...else 语句用于在多个条件下进行选择执行不同的代码块。它的特征是包含一个初始的 if 条件和代码块，后续可以有任意数量的 else if 条件和代码块，以及最后一个可选的 else 代码块。
  如果初始 if 条件为真，则执行相关的代码块，并跳过其他 else if 和 else 部分；
  如果初始 if 条件为假，则依次检查每个 else if 条件，直到找到第一个为真的条件，并执行该代码块；
  如果所有的条件都为假，则执行最后的 else 代码块（如果有）。其完整语法如下：

  //	3、if...else if...else语法
  if(布尔表达式1){
  	条件满足时执行的程序;	
  } else if(布尔表达式2){
  	条件满足时执行的程序;
  } else{
  	以上所有条件都不满足时执行的程序;
  }
  

  下面以代码案例演示对于以上这种选择结构的使用方式及其作用：

  // 案例 3：使用 if…else if…else 语句进行判断
  public class TestDemo(
  	public static void main(String args[]){
  		double score =91.0;
  		if (score<60.0){					//条件判断
  			System.out.println("较差成绩!");
  		}else if (score>=60 && score <=90){  //条件判断
  			System.out.println("中等成绩！");
  		}else if (score>90 && score<=100){   //条件判断         
  			System.out.println("优秀成绩！");
  		}else{                               //条件判断都不满足                         
  			System.out.println("无效成绩！");
  		}
  	}
  }
  

  程序执行结果：

  优秀成绩！
  

  此程序使用了多个判断条件判断给定的score变量的内容，如果满足条件，则执行相应的信息输出。

1.2.2 switch 选择结构

对于多条件判断使用 if…else if…else 是可以判断布尔条件的。如果是多数值判断，则可以通过 switch 完成，其语法以及执行流程如下所示。

switch(整数 |字符 |枚举 |String)(
	case 内容:{
		内容满足时执行；
		[break;]
	}
	case 内容:{
		内容满足时执行；
		[break;]
	}
	case 内容:{
		内容满足时执行
		[break;]
	}…
	[default:{
		内容都不满足时执行；
		[break;]
	}]
}

需要注意的是，if可以判断布尔表达式，而switch只能够判断内容。在分支结构中，使用if语句结构可以判断指定布尔表达式的结果。但是switch的判断不能使用布尔表达式，它最早的时候只能进行整数或字符的判断，从JDK 1.5开始支持了枚举判断，在JDK 1.7的时候支持了String的判断。

switch语句体结构中，在每一个 case 里出现的 break 语句，表示停止 case 的执行，因为 switch 语句默认情况下会从第一个满足的 case 语句开始执行全部的语句代码， 一直到整个switch 执行完毕或者遇见break。

// 案例 4：使用 switch  判断
public class TestDemo{
	public static void main(String args[]){
		int ch=1;
		switch (ch){                      //判断的是数字
			case 2:{                      //判断内容是否是2
				System.out println("内容是2");
				break;
			}
			case 1:{                        //判断内容是否是1
				System.out.println("内容是1");
				break;
			}
			case 3:{                          //判断内容是否是3
				System.out.println("内容是3");
				break;
			}
			default:{     // 判断都不满足
				System.out.println("没有匹配内容");
				break;
			}
		}
	}
}

程序执行结果：

内容是1

此程序使用了 switch 语句判断ch 变量的内容，如果某一个ch 变量符合于 case判断、满足定义的比较内容，则执行相应的 case 语句。可以发现，在每一个case语句后都加上了一个"break"语句，如果不加入此语句的话，则switch语句会从第一个满足条件的case语句开始依次执行操作，示例如下：

// 案例 5：使用 switch  判断，不加入break时的操作
public class TestDemo (
	public static void main(String args[]){
		int ch=1;
		switch(ch){           //判断的是数字
			case 2:{          //判断内容是否是2
				System.out.println("内容是2");
			}
			case 1:{          //判断内容是否是1
				System.out.println("内容是1");
			}
			case 3:{          //判断内容是否是3
				System.out.println("内容是3");
			}
			default:{         //判断都不满足
				System.out.println("没有匹配内容");
			}
		}
	}
}

程序运行结果：

内容是1
内容是3
没有匹配内容

从运行结果可以发现，程序在第一个条件满足之后，由于没有设置相应的break语句，则从第一个满足条件开始就一直依次向下继续执行到了末尾。

上边提到了从JDK 1.7开始switch支持字符串的直接判断，即可以利用switch判断是否是某一个字符串内容。但是在字符串的判断中是严格区分字母大小写的。

// 案例 6：使用`switch`做字符串判断
public class TestDemo (
	public static void main(String  args[]){
		String str="HELLO";
		switch (str){                      //判断的是字符串
			case "HELLO":{
				System.out.println("内容是 HELLO");
				break;
			}
			case "hello":{
				System.out.println("内容是 hello");
				break;
			}
			case "xiaoshan":{
				System.out.println("内容是 xiaoshan");
				break;
			}
			default:{
				System.out.println("没有匹配内容");
				break;
			}
		}
	}
}

程序执行结果：

内容是 HELLO

程序采用了字符串的方式进行判断，如果判断的内容是case 中定义的内容，则执行对应的代码。

1.3 循环结构

循环结构是根据判断条件的成立与否，决定程序段落的执行次数，而这个程序段落就称为循环主体。循环结构的流程图如下图所示：

当某段代码需要一直重复执行时，可以使用循环结构来实现控制，对于循环结构有两种循环：while循环和 for循环。

1.3.1 while 循环

while 循环分为 while 循环和 do-while 循环两种语法形式，其完整语法如下所示。

1、while循环

while(循环判断){
	循环语句;
	修改循环结束条件;	
}

2、do...while循环

do {
	循环语句;
	修改循环结束条件;
}while(循环判断);

通过以上两种循环语法可以发现，实际上 do...while表示先执行后判断，而 while 循环表示先判断后执行。如果循环条件都不满足的情况下， do...while 至少执行一次，而 while 一次都不会执行，这两种操作语法的流程如下图所示。

需要特别注意的是，所有的循环语句里面都必须有循环的初始化条件，每次循环的时候都要去修改这个条件，以判断循环是否结束。修改条件是为了避免死循环，造成死循环的原因也很好理解，就是循环条件一直都满足，每次循环执行时没有修改循环的结束条件，所以循环体一直都会被执行。

// 案例 7：实现 1~100的累加 — 使用while 循环
public class TestDemo{
	public static void main(String args[]){
		int sum=0;			//保存总和
		int current=1;		//循环的初始化条件
		while(current <= 100){		//循环结束条件
			sum+=current;			//累加
			current++;				//改变循环条件
		}
		System.out.println(sum);
	}
}

程序执行结果：

5050

此程序首先定义了一个 sum 的变量用于保存累加的结果，然后声明了一个 current 变量作为当前计算数值的保存变量(如果计算到1,则 current 值为1 ; 如果计算到 2 , 则 current 的值为2)。同时 current 也作为循环结束的判断条件，在每次执行循环体之前都会进行 current 变量的判断 (while (current <= 100)), 如果该变量的内容小于等于100,则表示判断通过，执行循环体，在循环体中会进行累加的计算 (sum += current), 同时也会修改当前的操作数值 (current++)。

此程序的执行流程如下图所示：

接下来使用 do...while 循环来完成同上边案例一样的功能。

// 案例 8：实现 1~100的累加 — 使用 do...while 循环
public class TestDemo  {
	public static void main(String  args[]){
		int sum=0;		//保存总和
		int current=1;	//循环的初始化条件
		do{					
			sum += current;	//累加
			current++;		//改变循环条件
		}while(current  <=  100); 	//循环结束判断
		System.out.println(sum);
	}
}

此程序同样实现了累加操作，而与前一个范例程序最大的不同在于，在第一次执行循环体时并不会进行循环条件的判断 (while(current <= 100)), 而执行完一次循环体之后才会进行循环条件的判断， 以判断是否还要继续执行该循环。

此程序的执行流程如下图所示：

1.3.2 for 循环

for 循环的最大特点是已经明确地知道循环次数， for 循环的完整语法如下：

for(循环初始化条件; 循环判断; 循环条件变更){
	循环语句;
}

通过语法格式可以看到， for 循环在定义时，将 循环初始化条件、循环判断、循环条件变更 三个操作都放在一行语句中，而在执行的时候循环初始化条件只会执行一次，而后循环判断在每次执行循环体之前都会判断，并且每当循环体执行完毕后都会自动执行循环条件变更。 for 循环的执行流程结构图如下图所示：

// 案例 9：实现 1~100的累加 — 使用 for 循环实现
public class TestDemo  {
	public static void main(String args[]){
		int sum=0                        //保存总和
		//设置循环初始化条件 current,同时此变量作为累加操作使用
		//每次执行循环体前都要进行循环判断(current<=100)
		//循环体执行完毕后会自动执行 “current++”改变循环条件
		for(int current=1; current<=100; current++){
			sum += current;  //  循环体中实现累加操作
		}
		System.out.println(sum);
	}
}

程序执行结果：

5050

此程序直接在 for 语句中初始化循环条件、循环判断以及循环条件变更的操作，而在循环体中只是 实现核心的累加操作。

🔍 用哪一种循环结构体语句更好?

本节介绍了3种循环的操作，那么在实际工作中，如何去选择该使用哪一种循环呢?
就工作实际运用经验来讲，在开发中，while循环和 for循环的使用次数较多，而这两种循环的使用环境如下：

• while循环：在不确定循环次数，但是确定循环结束条件的情况下使用;
• for循环：确定循环次数的情况下使用。

例如：现在要求一口一口的吃饭， 一直吃到饱为止，可是并不知道到底要吃多少口，只知道 结束条件，所以使用`while`循环会比较好；而如果要求围着操场跑两圈步，已经明确知道了循环的次数，那么使用`for`循环就更加方便了；而对于`do..while循环在开发中使用较少。

以上给出的循环是最为基础的单层循环，但是很多时候考虑到业务的需求可能会出现多层循环的嵌套操作，下面范例中的代码作用是进行乘法口诀表的输出，采用的就是双层循环。

// 案例 10：输出乘法口诀表
public class TestDemo {
	public static void main(String args[])(
		for(int x=1; x<=9; x++){          //控制循环的行数
			for(int y=1; y<=x; y++)(        //控制列数
				System.out.print(x + "*" + y + "=" + (x*y) + "\t);
				System.out.println();             //换行
			}
		}
	}
}

程序运行结果：

1*1=1
2*1=2	2*2=4
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12	4*4=16	
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
6*1=6	6*2=12 	6*3=18	6*4=24	6*5=30	6*6=36
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81

此程序使用了两层循环控制输出，其中第一层循环是控制输出行，即乘法口诀表中左边的数字(7* 3=21,x 控制的是这个数字7,而y 控制的是数字3)，而另外一层循环是控制输出的列，并且为了防止不出现重复数据(例如：“1*2” 和 “2*1” 计算结果重复)，让y 每次的循环次数受到x 的限制，每次里面的循环执行完毕后就输出一个换行。

此程序执行流程如下图所示：

1.3.3 循环控制

正常情况下只要执行了循环，且满足循环条件，循环体的代码就会一直执行， 但是在程序中也提供有两个循环停止的控制语句：

• continue (退出本次循环)
• break (退出整个循环)。

此类语句在使用时往往要结合分支语句进行判断。

// 案例 11：观察 continue的作用
public class TestDemo    {
	public static void main(String args[])(
		for(int x=0; x<10; x++){
			if(x ==3){
				continue;// 之后的代码不执行，直接结束本次循环
			}
			System.out.print("x=" + x + " 、");
		}
	}
}

程序执行结果：

x=0、x=1、x=2、x=4、x=5、x=6、x=7、x=8、x=9、

此程序使用了 continue 语句，而结果中可以发现缺少了“x=3”的内容打印，这是因为使用continue 表示当前一次循环结束执行，而直接进行下一次循环的操作，程序执行流程如下图所示。

// 案例 12：观察 break的作用
public class TestDemo {
	public static void main(String args[]){
		for (int x=0; x<10; x++){
			if (x ==3){
				break;//退出整个循环
			}
			System.out.print("x=" + x +"、");
		}
	}
}

程序执行结果：

x=0、x=1、x=2、

此程序在 for 循环中使用了一个分支语句 (x == 3)判断是否需要结束循环，而通过运行结果可以 发现，当x 的内容为2后，循环不再执行，程序执行的流程如下图所示：

🌾 总结

本文讨论了Java的程序逻辑控制，包括顺序结构、分支结构（if 选择结构和switch 选择结构）以及循环结构（while 循环、for 循环和循环控制）。

通过顺序结构，我们可以按照代码的书写顺序执行语句。

分支结构允许我们根据条件的真假来选择执行不同的代码块，其中if 选择结构适用于多个互斥的条件，而switch 选择结构适用于多个固定值的比较。

循环结构使我们能够重复执行一段代码块，直到满足特定条件。while 循环适用于未知循环次数的情况，而for 循环适用于已知循环次数的情况。此外，我们还介绍了循环控制语句（break 和 continue），它们可以用于提前结束循环或跳过循环中的某些迭代。

掌握程序逻辑控制是Java编程中至关重要的一部分，它使我们能够根据不同的条件执行不同的操作，并且可以有效地处理循环操作。在正确使用这些结构的同时，我们还需要注意避免出现死循环以及嵌套结构过于复杂导致代码难以理解。通过充分利用Java的程序逻辑控制，我们可以编写出更灵活、高效和可维护的代码。

---

⏪ 温习回顾上一篇（点击跳转）： 《【Java基础教程】（四）程序概念篇 · 中》
⏩ 继续阅读下一篇（点击跳转）： 《【Java基础教程】（六）程序概念篇 · 末》

---

本文部分案例及图片来源：
《第一行代码JAVA》