【知晓的丧day拯救计划】java基础学习笔记5 流程控制

笔记来自2019求知讲堂零基础Java入门编程视频教程 https://www.bilibili.com/video/av76235341

顺序结构

顺序结构：程序从上到下逐行执行。

• java中定义成员变量时，采用合法的向前引用，使用变量的时候一定要先定义。

int i = 0;
i++;            //正确
		
j++;
int j = 0;      //错误

分支结构

分支结构：程序根据判断条件，选择性的执行某段代码。

if…else

if(条件表达式) {
	//若条件表达式为真，执行此代码块
}

if (条件表达式) {
	//条件表达式为真，执行此代码块
} else {
	//条件表达式为假，执行此代码块
}

if (条件表达式1) {
	//条件表达式1为真，执行此代码块			
}
else if (条件表达式2) {
	//条件表达式1为假，条件表达式2为真，执行此代码块
} 		
else {
	//以上条件表达式均不成立，执行此代码块
}

switch

switch (变量) {
		case 常量1:
			语句1;	//如果变量==变量1，执行此代码	
			break;  //语句1执行后，直接跳出switch语句块
		case 常量2:
			语句2;	//如果变量==变量2，执行此代码
			break;  //语句2执行后，直接跳出switch语句块
		case 常量3:
			语句3;	//如果变量==变量3，执行此代码	
			break;  //语句3执行后，直接跳出switch语句块
		...
		default:
			语句; //以上分支都不成立，执行此代码	
			break;//跳出switch语句块
		}

注：
1.break的作用：用来在执行完一个case分支后使程序跳出switch语句块，case分支中如果没有break，某一分支成立后，后面的分支均会被执行，直到switch结束或遇到break才会退出switch语句块。

int month=2;
switch (month) {
case 1:
case 2:
case 3:
	System.out.print("春季");	
	break;					
case 4:
case 5:
case 6:
	System.out.print("夏季");		
	break;					
case 7:
case 8:
case 9:
	System.out.print("秋季");	
	break;		
case 10:
case 11:
case 12:
	System.out.print("冬季");	
	break;				
default:
	System.out.print("输入错误");				
		}
//运行结果：春季

2.switch (变量)中的变量必须是byte、short、char、int、枚举、String 中的一种。
3.case子句中的值必须是常量，且case字句中的值应是不同的。
4.default子句是可以缺省的。
5.如果判断的具体数值不多，且是符合switch的数据类型，建议使用switch语句，因为效率稍高；对于区间判断，和结果是boolean类型的判断，应该使用if语句。

循环结构

程序根据循环条件，重复执行某段代码。

• 循环结构的四个组成部分
  ①初始化部分
  ②循环条件部分
  ③循环体部分
  ④迭代部分
• 一般的循环过程：
  首先进行初始化①
  然后判断循环条件②是否成立
  若循环条件②为true，执行循环体③，并执行迭代表达式④，再次判断②是否成立，以此循环
  若循环条件②为false，结束循环

for循环

for(初始化表达式①；布尔测试表达式②；迭代表达式④){
语句或语句块③
}

//一个例子：输出所有水仙花数（各个位上数字的立方和等于数字本身的三位数）
for (int i = 100;i < 1000; i++) {
	int b = i / 100;//得到百位数
	int s =(i - 100 * b) / 10;//得到十位数
	int g = (i - 100 * b - 10 * s);//得到个位数
	int res = b * b * b + s * s * s + g * g * g;
//	int res = (int) (Math.pow(b, 3)+Math.pow(s, 3)+Math.pow(g, 3));
	if (i==res){
		System.out.println(i);
	}
}
//输出结果：153、370、371、407

while

[初始化表达式①]
while (布尔测试表达式②) {
　　循环体语句块③；
　　[迭代表达式④]；
}

do while

[初始化表达式①]
do {
　　循环体语句块③；
　　[迭代表达式④]；
}while (布尔测试表达式②) ；
}

注：
1.do while 循环与while循环的区别：
　while先判断条件再循环
　do while 不管条件如何先执行一次语句块，再进行判断是否循环
　
2.简单的无限循环：while(true){}、for( ; ; ){}，用于不知道循环多少次，需要其他控制语句跳出循环。

3.一个例子，用不同循环语句求1~100之间所有偶数的和

//求1~100之间所有偶数的和

//for 循环
for (int i = 0;i <= 100; i++) {
	if (i % 2 == 0) {
		sum += i;
	}
}
System.out.println(sum);

//while循环
int i = 1;
int sum = 0;
while (i<=100) {
	if (i % 2 == 0) {
		sum += i;
	}
	i++;
}
System.out.println(sum);

//do while循环
int i = 1;
int sum = 0;
do {
	if (i % 2 == 0) {
		sum += i;
	}
	i++;
}while (i <= 100);
System.out.println(sum);

嵌套循环

1.for、while、do while 之间可以互相嵌套
2.设外层循环次数m，外层循环次数为n，则内层循环体实际执行次数为m*n次
3.在写嵌套循环的时候，要尽量保证外层循环的循环次数小于内层的循环次数

//九九乘法表
for(int i = 1; i < 10;i++) {
	for (int j = 1;j <= i ;j++) {
		System.out.print(j + "×" + i + "=" + i*j + "   ");
	}
	System.out.println();
}

//输出100以内的质数
for (int i = 1;i <= 100;i++) {     //循环计算1到100
	int count = 0;                //计数器，用来存放一个数因数的个数
	for (int j = 1;j <= i;j++) {  //一个数循环除以1到他自己
		if(i % j == 0) {          //若余数为零，该数因数个数加1
			count++;
		}
		if(count >2) {            //若因数个数大于2，那它就不是质数，停止循环，直接进入下一个数
			break;
		}
	}
	if(count == 2)	{             //若一个数因数个数只有两个，那么它是质数，输出
		System.out.print(i+"   ");
	}
}

特殊流程控制语句

break语句

break语句用于终止某个语句块的执行

1.用于终止switch
2.用于终止循环

continue语句

continue语句用于跳过某个循环的某一次执行

return语句

return语句用于结束方法。
程序运行到return，后面的内容就不再执行了。

break、continue、return之间的区别

1.break和continue：
break用于结束整个循环过程，continue结束的则是循环中的某一次执行

public class BreakContinue {
	public static void main(String[] args) {
		//输出结果0 1 
		//由此可见，程序运行到i=2的时候，循环终止
		for (int i = 0;i < 5;i++) {
			if(i == 2) {
				break;
			}
			System.out.println(i);			
		}

		//输出结果0 1 3 4
		//由此可见，程序运行到i=2的时候，停止本次循环没有输出2，但继续了之后的循环
		for (int i = 0;i < 5;i++) {
			if(i == 2) {
				continue;
			}
			System.out.println(i);			
		}
	}
}
}

2.多层嵌套循环中的break、continue和return
当存在于多层嵌套循环中时，break和continue默认都是结束其当前所在的最内层循环，而return不论处在什么位置，都是直接跳出整个方法

public class BreakContinueReturn {
	public static void main(String[] args) {
	
		//break部分
		System.out .println("break");
		for (int i = 0;i < 2;i++) {
			for (int j = 0;j < 5;j++) {
				if(j == 2) {
					break;
				}
				System.out .println("这是内层循环"+j);
			}
			System.out .println("这是外层循环"+i);
		}
		
		//return部分
		System.out .println("return");
		for (int i = 0;i < 2;i++) {
			for (int j = 0;j < 5;j++) {
				if(j == 2) {
					return;
				}
				System.out .println("这是内层循环"+j);
			}
			System.out .println("这是外层循环"+i);
		}
		
		//continue部分
		System.out .println("continue");
		for (int i = 0;i < 2;i++) {
			for (int j = 0;j < 5;j++) {
				if(j == 2) {
					continue;
				}
				System.out .println("这是内层循环"+j);
			}
			System.out .println("这是外层循环"+i);
		}
	}
}

运行结果：

可以看出：
①break只结束了内层循环，没有影响外层循环（continue同理）
②return不仅内外层循环，在其之后的continue部分也没有运行，实际上continue结束的是整个main方法

3.break和continue配合标签使用
break和continue语句出现在嵌套循环中时，若果想要跳出外层循环，可以通过标签指明要跳过的是哪一层循环

public class BreakContinueLabel {
	public static void main(String[] args) {
		System.out .println("break");
		outer1:                            //给外层循环添加标签
		for (int i = 0;i < 2;i++) {
			for (int j = 0;j < 5;j++) {
				if(j == 2) {
					break outer1;         //指明break起作用的是outer1循环
				}
				System.out .println("这是内层循环"+j);
			}
			System.out .println("这是外层循环"+i);
		}
				
		System.out .println("");
		System.out .println("continue");
		outer2:
		for (int i = 0;i < 2;i++) {
			for (int j = 0;j < 5;j++) {
				if(j == 2) {
					continue outer2;
				}
				System.out .println("这是内层循环"+j);
			}
			System.out .println("这是外层循环"+i);
		}
	}
}

运行结果：

可以看出：
①break部分：第一次内层j=2的时候，break直接结束了整个外层循环
②continue部分：每次内层j=2的时候，continue结束本次大循环，所以外层输出一直没有被执行。