java中的流程控制语句详解

1. 流程控制语句

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。

流程控制语句分类

​ •顺序结构

​ •选择结构

​ •循环结构

##2. 顺序结构概述

•是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

•总的来说：写在前面的先执行，写在后面的后执行

2. 选择结构

选择结构：

​ •也被称为分支结构。

​ •选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断， 逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。

​ •Java语言提供了两种选择结构语句

2.1 if语句

if语句有三种格式：

​ 我们前面学习过三元运算符，它根据比较判断后，给出的也是两个结果，所以，这种情况和if语句的第二种格式很相似，他们在某些情况下应该是可以相互转换的。

if语句第二种格式和三元运算符：

​ •三元运算符的操作都可以使用if语句改进，反之不成立

​ •什么时候不成立呢?

​ •当if语句控制的语句体是一条输出语句的时候，就不成立。因为三元运 算符是一个运算符，必须要求有一个结果返回。

而输出语句却不能作为一个返回结果。

if语句第一种格式：

​ if(关系表达式) {

​ 语句体

}

执行流程:

​ •首先判断关系表达式看其结果是true还是false

​ •如果是true就执行语句体

​ •如果是false就不执行语句体

注意事项

•关系表达式无论简单还是复杂，结果必须是boolean类型

•if语句控制的语句体如果是一条语句，大括号可以省略；如果是多条语句，就不能省略。建议永远不要省略。

•一般来说：有左大括号就没有分号，有分号就没有左大括号

if语句第二种格式：

if(关系表达式) {

​ 语句体1;

}else {

​ 语句体2;

}

执行流程:

•首先判断关系表达式看其结果是true还是false

•如果是true就执行语句体1

•如果是false就执行语句体2

if语句第三种格式：

•if(关系表达式1) {

​ 语句体1;

}else if (关系表达式2) {

​ 语句体2;

}

​ …

else {

​ 语句体n+1;

}

执行流程:

​ •首先判断关系表达式1看其结果是true还是false

​ •如果是true就执行语句体1

​ •如果是false就继续判断关系表达式2看其结果是true还是false

​ •如果是true就执行语句体2

​ •如果是false就继续判断关系表达式…看其结果是true还是false

​ •如果没有任何关系表达式为true，就执行语句体n+1。

2.2 switch语句

格式解释:

​ •switch表示这是switch语句

​ •表达式的取值：byte,short,int,char

​ •JDK5以后可以是枚举

​ •JDK7以后可以是String

​ •case后面跟的是要和表达式进行比较的值

​ •语句体部分可以是一条或多条语句

​ •break表示中断，结束的意思，可以结束switch语句

​ •default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

switch语句格式

•switch(表达式) {

​ case 值1：

语句体1;

break;

​ case 值2：

语句体2;

break;

​ …

​ default：

语句体n+1;

break;

​ }

执行流程

•首先计算出表达式的值

•其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。

•最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

注意事项

case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的

default可以省略吗?

​ •可以省略。一般不建议。除非判断的值是固定的。(单选题)

break可以省略吗?

​ •可以省略，一般不建议。否则结果可能不是你想要的

default的位置一定要在最后吗?

​ •可以出现在switch语句任意位置。

switch语句的结束条件

​ •遇到break

​ •执行到程序的末尾

switch(){
    case 值1：
        语句体1：
        break；
    case 值1：
        语句体1：
        break；
    case 值1：
        语句体1：
        break；
      ...
    default:
        语句体N+1;
            break;
}

面试题

byte可以作为switch的表达式吗？

可以

long可以作为switch的表达式吗？

可以

String可以作为switch的表达式吗？

jdk7以后可以

2.3 if语句和switch的使用场景

if语句：

​ A:针对结果是boolean类型的判断

​ B:针对一个范围的判断

​ C:针对几个常量值的判断

switch语句

​ A:针对几个常量值的判断

案例1

package com.wsy;
/*
 switch语句的注意事项
 	1.case 后面只能是常量，不能是变量，case后面的值不能重复，
 	2.break（终止）最后一个可以省略中间不建议省略会出现case穿透
 	3.default可以省略但不建议因为它的作用是对不正确的情况作出提醒
 	 default无论在哪个位置都先执行case再执行default
 */
import java.util.Scanner;//键盘录入导包
public class SwitchDemo {
	public static void main(String[] args) {
		 //创建键盘录入对象
		 Scanner sc = new Scanner(System.in);
		 
		 //控制键盘录入数据
		 System.out.println("请输入第(1-7)的数据：");
		 int week = sc.nextInt();
		 
		 //switch判断语句
		 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("你输入的信息有误");
		 		break;
		 }
	}
}

``

### 案例2

```java
package com.wsy;
import java.util.Scanner;//导包
public class switchDemo1 {
	public static void main(String[] args) {
		System.out.println("下面选型哪个是正确的？");
		System.out.println("A:猫抓耗子");
		System.out.println("B:耗子抓猫");
		System.out.println("C:狗抓耗子");
		System.out.println("D:耗子尾汁");
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		//调用对象的方法接收一个String类型的返回值
		String next = sc.nextLine();
		
		/*如果返回值对象为int就强转为char''一个字符型
		也可以sc.next(String)
		int a = sc.nextInt();
		强制转换为字符型
		char b = (char)a;*/
		
		//switch语句
		switch(next) {
			case "A":
				System.out.println("选择正确");
			break;
			case "B":
				System.out.println("选择错误");
				break;
			case "C":
				System.out.println("选择错误");
				break;
			case "D":
				System.out.println("选择错误");
				break;
			default:
				System.out.println("没有该选项");
		}
	}
}

案例

输入一个月份查询对应的季节

package com.wsy;
//要求用switch语句实现键盘录入月份，输出对应的季节
import java.util.Scanner;
public class switchDemo2 {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入想要查询的月份：");
		int month = sc.nextInt();
		
		switch(month) {
		
			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;
			case 8:
				System.out.println("夏");
				break;
			case 9:
				System.out.println("秋");
				break;
			case 10:
				System.out.println("秋");
				break;
			case 11:
				System.out.println("秋");
				break;
			case 12:
				System.out.println("冬");
				break;
			case 1:
				System.out.println("冬");
				break;
			case 2:
				System.out.println("冬");
				break;
			default:
				System.out.println("你输入的月份有误");
				
		}
	
	}
}

3. 循环结构

3.1 for循环

格式：

​ for（初始化语句；判断条件语句；控制条件语句）{

​ 循环体语句；

}

执行流程：

1. 执行初始化语句

2. 执行判断条件语句，看其返回结果是true还是false

   如果是true，就继续执行

   如果是false，就结束循环

3. 执行循环体语句

4. 执行控制条件语句

5. 回到1继续下一次循环

注意事项：

1. 判断条件是一个boolean类型
2. 循环体语句如果是一条语句，大括号可以省略；如果是多条语句大括号不能省略，建议永远不要省略
3. 一般来说；有左大括号就没有分号；有分号就没有左大括号

案例1

package com.wsy;

public class ForDemo {
	public static void main(String[] args) {
		//1.在控制台输出十次HelloWorld
//		for(int i = 0;i <= 10;i++) {
//			System.out.println("HelloWorld");
		//2.在控制台输出数据1-10
//		for(int i = 1; i <= 10;i++) {
//			System.out.println(i);	
//		}
		//3.在控制台输出10-1
//		for(int a = 10; a >=1;a--) {
//			System.out.println(a);
//		}
		//4.求出1-10之间数据之和
		//定义一个变量用来储存加数
//		int sum = 0;
//		for(int s = 1;s <= 10;s++) {
//			sum +=s;			
//		}
//		System.out.println("和:"+sum);
		
		//5.求出1-100之间偶数和
//		int sum = 0;
//		for(int a = 1;a <= 100;a++) {
//			if(0 == a%2) {
//				sum += a;
//			}
//		}
//		System.out.println("1-100之间的偶数和："+sum);
		
		//6.求出1-100之间奇数和
//		int sum = 0;
//		for(int a = 1;a <= 100;a++) {
//			if(0 != a%2) {
//				sum += a;
//			}
//		}
//		System.out.println("1-100之间的奇数和："+sum);
		
		//7.求5的阶乘 从一乘到五 
		//什么是阶乘呢？
		//规则: x! = x*(x-1)
//		int jc = 1;
		//这里的i可以直接从2 开始因为任何数*1还是本身
//		for(int i = 2;i <= 5;i++) {
//			jc *= i;
//		}
//		System.out.println("5的阶乘："+jc);
        
		//8.在控制台输出所有的"水仙花数"
		/*所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身，
		 比如：153就是一个水仙花数
		 153 = 1*1*1 + 5*5*5 + 3*3*3
		 如何得到个位数的值
		 个：153%10 = 3
		 十：153/10%10 = 5
		 百：153/10/10%10 = 1
		 千：153/10/10/10%10
			……
			
		 */
		//三位数其实告诉了我们范围
		for(int i = 100;i < 1000;i++) {
			int ge = i%10;
			int shi = i/10%10;
			int bai = i/10/10%10;
		//让ge*ge*ge+shi*shi*shi+bai*bai*bai和该范围的数据比较
		if(i == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
				//如果相同，就把数据输出在控制台
			System.out.println("所有的水仙花数有"+i);
			}
		}
		/*请在控制台输出满足条件的五位数
		 * 个数等于万位
		 * 十位等于千位
		 *个位+个位+个位+万位 = 百位 
		 */
		for(int i = 10000;i <100000;i++) {
			int ge = i%10;
			int shi = i/10%10;
			int bai = i/10/10%10;
			int qian = i/10/10/10%10;
			int wan = i/10/10/10/10%10;
	if(ge == wan && shi == qian && ge+ge+ge+wan == bai) {
			System.out.println(i);
			}
		}	
        
        /统计1-1000之间同时满足一下条件的数据有多少个
		//对3整除余2
		//对5整除余3
		//对7整除余2
		int count = 0;
		for(int a = 1;a <= 1000;a++) {
			if(a%3 == 2 && a%5 == 3 && a%7 == 2) {
				count++;
			}
		}
		System.out.println("满足条件的数据有"+count+"个");
	}
}

3.2 while循环

while循环语句格式：

• 基本格式

​ while(判断条件语句){

​ 循环体语句;

​ }

• 拓展格式

  ​ 初始化语句：

  ​ while（判断条件语句）{

  ​ 循环体语句；

  ​ 控制条件语句；

  }

3.3 while和for循环的区别

/*
	while循环和for循环的区别?
		使用区别：如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用for循环。
		          因为变量及早的从内存中消失，可以提高内存的使用效率。
				  
		其实还有一种场景的理解:
			如果是一个范围的，用for循环非常明确。
			如果是不明确要做多少次，用while循环较为合适。
				举例：吃葡萄。
*/
class WhileDemo4 {
	public static void main(String[] args) {
		//for循环实现
		for(int x=0; x<10; x++) {
			System.out.println("学习Java技术哪家强,中国北京传智播客");
		}
		//这里不能在继续访问了
		//System.out.println(x);
		
		//while循环实现
		int y = 0;
		while(y<10) {
			System.out.println("学习Java技术哪家强,中国北京传智播客");
			y++;
		}
		//这里是可以继续访问的
		System.out.println(y);
	}
} 

案例

/*
	我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。
	请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?

	分析：
		A:定义一个统计变量，默认值是0
		B:最高山峰是珠穆朗玛峰：8848m这是最终的厚度
		  我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度
		C:我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
		  折叠一次有什么变化呢?就是厚度是以前的2倍。
		D:只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++
		E:输出统计变量。
*/

class WhileDemo5 {
	public static void main(String[] args) {
		//定义一个统计变量，默认值是0
		int count = 0;
		
		//最高山峰是珠穆朗玛峰：8848m这是最终的厚度
		//我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度
		//为了简单，我把0.01变成1，同理8848就变成了884800
		int end = 884800;
		int start = 1;
		
		while(start<end) {
			//只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++
			count++;
			
			//折叠一次有什么变化呢?就是厚度是以前的2倍。
			start *= 2;
			
			System.out.println("第"+count+"次厚度是"+start);
		}
		
		//输出统计变量。
		System.out.println("要叠"+count+"次");
	}
}

3.4 do while循环

do…while循环的基本格式：
​ do {
​ 循环体语句;
​ }while(判断条件语句);
扩展格式；
​ 初始化语句;
​ do {
​ 循环体语句;
​ 控制条件语句;
​ }while(判断条件语句);

案例

package com.wsy;

public class DoWhileDemo {
public static void main(String[] args) {
//do while判断条件循环
//输出十次"HelloWorld"
int i = 0;
do {
System.out.println(“HelloWorld”);
i++;
}while(i < 10);

	//求和1-100
	int sum = 0;
	int x = 1;
	do {
		sum += x;
		x++;
	}while(x <= 100);
	System.out.println(sum);
}

}

3.5 循环语句的区别

循环语句的区别:
​ do…while循环至少执行一次循环体。
​ 而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
​

那么，我们一般使用哪种循环呢?
​ 优先考虑for，其次考虑while，最后考虑do…while

class DoWhileDemo2 {
	public static void main(String[] args) {
		int x = 3;
		while(x < 3) {
			System.out.println("我爱java");
			x++;
		}
		
		System.out.println("--------------");
		
		int y = 3;
		do {
			System.out.println("我爱java");
			y++;
		}while(y < 3);
	}
}

3.6 死循环

注意死循环：
​ A:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
​ B:两种最简单的死循环格式
​ while(true){…}
​ for(;😉{…}

案例：

class DoWhileDemo3 {
	public static void main(String[] args) {
		int x = 0;
		while(x < 10) {
			System.out.println(x);
			x++;
		}
		System.out.println("--------------");
		
		/*
		while(true) {
			System.out.println("今天我很高兴，学习了死循环");
		}
		*/
		
		for(;;){
			System.out.println("今天我很高兴，学习了死循环");
		}
		
		//System.out.println("--------------");
	}
}

3.7 循环嵌套

循环嵌套：就是循环语句的循环体本身是一个循环语句。

通过结果我们知道这样的一个结论：
​ 外循环控制行数
​ 内循环控制列数

案例1

/*
	需求：请输出一个4行5列的星星(*)图案。
	结果：
		*****
		*****
		*****
		*****
		
	循环嵌套：就是循环语句的循环体本身是一个循环语句。
	
	通过结果我们知道这样的一个结论：
		外循环控制行数
		内循环控制列数
*/
class ForForDemo {
	public static void main(String[] args) {
		//原始做法
		System.out.println("*****");
		System.out.println("*****");
		System.out.println("*****");
		System.out.println("*****");
		System.out.println("-------------");
		
		//虽然可以完成需求，但是不是很好
		//如果是多行多列就会比较麻烦
		//所以我们准备改进
		//如何改进呢?
		//我先考虑如何实现一行*的问题
		//System.out.println("*****");
		//我们要想的是如何实现一次输出一颗*的问题
		//System.out.println("*");
		//System.out.println("*");
		//现在虽然可以一次一颗*，但是却换行了，我要求不能换行，怎么办呢?
		//输出语句的另一种格式：System.out.print(); 这个是不带换行的
		//System.out.print("*");
		//System.out.print("*");
		//System.out.print("*");
		//System.out.print("*");
		//System.out.print("*");
		//如果我要在一行上打出多颗*，比较麻烦，而代码是重复的，所以我决定用循环改进
		for(int x=0; x<5; x++) {
			System.out.print("*");
		}
		//我们可以通过空的输出语句实现换行：System.out.println();
		System.out.println();
		
		//既然我可以打出一行，我就可以打出第二行
		for(int x=0; x<5; x++) {
			System.out.print("*");
		}
		//我们可以通过空的输出语句实现换行：System.out.println();
		System.out.println();
	
		//同理打出第三行，第四行
		for(int x=0; x<5; x++) {
			System.out.print("*");
		}
		//我们可以通过空的输出语句实现换行：System.out.println();
		System.out.println();
		
		//既然我可以打出一行，我就可以打出第二行
		for(int x=0; x<5; x++) {
			System.out.print("*");
		}
		//我们可以通过空的输出语句实现换行：System.out.println();
		System.out.println();
		System.out.println("-----------------");
		//同样的代码出现了4次，说明我们程序写的不好，用循环改进
		for(int y=0; y<4; y++) {
			for(int x=0; x<5; x++) {
				System.out.print("*");
			}
			//我们可以通过空的输出语句实现换行：System.out.println();
			System.out.println();
		}
	}
}

案例2

/*
	需求：请输出下列的形状
		*
		**
		***
		****
		*****
*/
class ForForDemo2 {
	public static void main(String[] args) {
		//通过简单的观察，我们看到这是一个行是5，列数是变化的形状
		//我们先打印出一个5行5列的形状
		for(int x=0; x<5; x++) {
			for(int y=0; y<5; y++) {
				System.out.print("*");
			}
			System.out.println();
		}
		
		System.out.println("--------------");
		
		//我们实现了一个5行5列的形状
		//但是这不是我们想要的
		//我们要的是列数变化的
		//列数是如何变化的呢?
		//第一行：1列	y=0,y<=0,y++
		//第二行：2列	y=0,y<=1,y++
		//第三行：3列	y=0,y<=2,y++
		//第四行：4列	y=0,y<=3,y++
		//第五行：5列	y=0,y<=4,y++
		//在看外循环x的变化，恰好就是x=0,1,2,3,4
		//所以这个最终版的程序就是如下
		for(int x=0; x<5; x++) {
			for(int y=0; y<=x; y++) {
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

案例3

/*
	需求：在控制台输出九九乘法表。
	
	首先我们写出九九乘法表：
		1*1=1
		1*2=2	2*2=4
		1*3=3	2*3=6	3*3=9
		1*4=4	2*4=8	3*4=12	4*4=16
		...
		1*9=9	2*9=18	3*9=27	...
		
	我们先把这个九九乘法表看出是这样的一个形状：
		*
		**
		***
		****
		*****
		******
		*******
		********
		*********
		
	注意：
		'\x' x表示任意，这种做法叫转义字符。
		
		'\t'	tab键的位置
		'\r'	回车
		'\n'	换行
*/
class ForForDemo3 {
	public static void main(String[] args) {
		for(int x=0; x<9; x++) {
			for(int y=0; y<=x; y++) {
				System.out.print("*");
			}
			System.out.println();
		}
		System.out.println("--------------");
		//为了使用数据，我们从1开始
		for(int x=1; x<=9; x++) {
			for(int y=1; y<=x; y++) {
				System.out.print(y+"*"+x+"="+y*x+"\t");
			}
			System.out.println();
		}
	}
}

3.8 跳转语句

前面我们已经说过了，Java中的goto是保留字，目前不能使用。虽然没有goto语句可以增强程序的安全性，但是也带来很多不便，比如说，我想在某个循环知道到某一步的时候就结束，现在就做不了这件事情。为了弥补这个缺陷，Java就提供了break，continue和return来实现控制语句的跳转和中断。

break 中断

continue 继续

return 返回

3.8.1 break

break的使用场景：

•在选择结构switch语句中

•在循环语句中

•离开使用场景的存在是没有意义的

break的作用：

•跳出单层循环

•跳出多层循环

•带标签的跳出

•格式：标签名: 循环语句

•标签名要符合Java的命名规则

3.8.2 continue

continue的使用场景：

•在循环语句中

•离开使用场景的存在是没有意义的

continue的作用：

•单层循环对比break，然后总结两个的区别

•break 退出当前循环

•continue 退出本次循环继续下一次循环

•也可以带标签的使用

3.8.3 return

return关键字不是为了跳转出循环体，更常用的功能是结束一个方法，也就是退出一个方法。跳转到上层调用的方法。

•结束循环其实是结束了main方法

案例

/*
	需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是，
	      每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，
		  请问，经过多少天，小芳才可以存到100元钱。

	分析：
		A:小芳的妈妈每天给她2.5元钱
			double dayMoney = 2.5;
		B:她都会存起来
			double daySum = 0;
		C:从第一天开始存储
			int dayCount = 1;
		D:经过多少天，小芳才可以存到100元钱。
			double result = 100;
		E:这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，
			说明要判断dayCount的值，如果对5整除就减去6元钱。
				daySum -= 6;
		  由此还隐含了一个问题，就是如果不是5的倍数天的话，钱要累加
				daySum += dayMoney;
		F:因为不知道是多少天，所以我用死循环，一旦超过100元我就退出循环。
*/
class WhileDemo {
	public static void main(String[] args) {
		//每天要存储的钱是2.5元
		double dayMoney = 2.5;
		
		//存钱的初始化值是0
		double daySum = 0;
		
		//从第一天开始存储
		int dayCount = 1;
		
		//最终存储不小于100就不存储了
		int result = 100;
		
		//因为不知道是多少天，所以我用死循环，
		while(true) {
			//累加钱
			daySum += dayMoney;
			
			//一旦超过100元我就退出循环。
			if(daySum >= result) {
				System.out.println("共花了"+dayCount+"天存储了100元");
				break;
			}
			
			if(dayCount%5 == 0) {
				//花去6元钱
				daySum -= 6;
				System.out.println("第"+dayCount+"天花了6元钱");
			}
			
			//天数变化
			dayCount++;
		}
	}
}