java—流程控制语句（if判断语句，switch选择语句，for循环语句，while循环语句，do...while循环语句，循环控制语句，死循环，循环嵌套）

概述

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

顺序结构

1. 顺序结构

   public class Demo {
   	public static void main(String[] args) {\
   		// 谁在前面先执行，谁在后面后执行，1 2 3
   		System.out.println("1");
   		System.out.println("2");
   		System.out.println("3");
   	}
   }
   

2. 判断结构（语句）

   1. 第一种格式：if
   	if(关系表达式) {
   		语句体
   	}
   

   

   public class Demo {
   	public static void main(String[] args) {
   		System.out.println("想去网吧上网");
   		int age = 16; // 限制16岁以下未成年上网吧
   		if(age >= 18) {
   			System.out.println("进入网吧，开始操作");
   		}
   		System.out.println("回家");
   
   		// 输出结果：
   		// 想去网吧上网 
   		// 回家
   	}
   }
   

   2. if语句第二种格式：标准的 if...else语句
   	if(关系表达式) {
   		语句体1；
   	} else {
   		语句体2；
   	}
   

   

   public class Demo {
   	public static void main(String[] args) {
   		int num = 13;
   
   		if (num % 2 == 0) { // 被2整除为偶数
   			System.out.println("偶数");
   		} else {
   			System.out.println("奇数");
   		}
   
   		// 结果为： 奇数
   	}
   }
   

   3. if语句第三种格式：if ... else if ... else
   	if (判断条件1) {
   		执行语句1
   	} else if (判断条件2) {
   		执行语句2；
   	}
   	...
   	} else if (判断条件n) {
   		执行语句n;
   	} else {
   		执行语句n + 1;
   	}
   

   

   /* x和y关系如下：
   	如果x >= 3,那么y = 2x + 1;
   	如果-1 < x < 3,那么y = 2x;
   	如果x <= -1,那么y = 2x -1;
   */
   public class Demo {
   	public static void main(String[] args) {
   		int x = 10;
   		int y;
   		if (x >= 3) { 
   			y = 2 * x + 1;
   		} else if (-1 < x && x < 3) {
   			y = 2 * x;
   		} else {
   			y = 2 * x -1;
   		}
   		System.out.println(y); // 21
   	}
   }
   

3. 选择语句

   switch语句格式：
   	switch (表达式) {
   		case 常量值1；
   			语句体1；
   			break；
   		case 常量值2；
   			语句体2；
   			break；
   		...
   		default: 
   			语句体n+1；
   			break；// 最后一个break语句可以省略，但是强烈推荐不要省略
   	}
   

   

   public class Demo {
   	public static void main(String[] args) {
   		int num = 1;
   		
   		switch (num) {
   			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;
   		}
   	}
   }
   

   /*switch语句使用的注意事项：
   	1. 多个case后面的数值不可以重复
   	2. switch后面小括号当中只能是下列数据类型：
   		基本数据类型：byte/short/char/int
   		引用数据类型：String字符串、enum枚举
   	3. switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略
   		“匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止”
   */ 
   public class Demo {
   	public static void main(String[] args) {
   		int num = 1;
   		
   		switch (num) {
   			case 1:
   				System.out.println("aaa");
   				break;
   			case 1: // 报错
   				System.out.println("bbb");
   				break;
   			default:
   				System.out.println("ccc");
   				break;
   		}
   	}
   }
   

4. for循环结构（语句）

   循环结构的基本组成部分，一般可以分成四部分：
   	1. 初始化语句：在循环开始最初执行，而且只做唯一一次
   	2. 条件判断：如果成立，则循环继续；如果不成立，则循环退出
   	3. 循环体：重复要做的事情内容，若干行语句
   	4. 步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次
   
   for循环语句格式：
   	for (初始化表达式a；布尔表达式b；步进表达式d) {
   		循环体c
   	}
   	流程：abcd>bcd>bcd... b不满足为止
   

   

   public class Demo {
   	public static void main(String[] args) {
   		// 打印100次  aaa
   		for (int i = 1; i <= 100; i++) {
   			System.out.println("aaa");
   		}
   	}
   }
   

5. while循环语句

   while循环有一个标准格式，还有一个扩展格式：
   
   标准格式：
   	while (条件判断) {
   		循环体
   	}
   
   扩展格式：
   	初始化语句；
   	while (条件判断) {
   		循环体；
   		步进语句；
   	}
   

   

   public class Demo {
   	public static void main(String[] args) {
   		// 打印100次  aaa
   		/*for (int i = 1; i <= 100; i++) {
   			System.out.println("aaa");
   		}*/
   		
   		int i = 1; // 初始化语句
   		while (i<=100) { // 条件判断
   			System.out.println("aaa"); // 循环体
   			i++; // 步进语句
   		}
   	}
   }
   

6. do…while循环语句

   do...while循环的标准格式
   do {
   	循环体
   } while (条件判断)；
   
   扩展格式：
   	初始化语句；
   	do{
   		循环体；
   		步进语句；
   	} while (条件判断)；
   

   

   public class Demo {
   	public static void main(String[] args) {
   		// 打印100次  aaa
   		/*for (int i = 1; i <= 100; i++) {
   			System.out.println("aaa");
   		}*/
   		
   		int i = 1; // 初始化语句
   		do {
   			System.out.println("aaa"); // 循环体
   			i++; // 步进语句
   		} while (i<=100); // 条件判断
   	}
   }
   

   // 题目：求出1-100之间的偶数和
   public class Demo {
   	public static void main(String[] args) {
   		int sum = 0;
   			
   		// 打印100次  aaa
   		for (int i = 1; i <= 100; i++) {
   			if(i % 2 ==0){
   				sum += i;
   			}
   		}
   		System.out.println(sum); // 2250
   		
   		/*
   		int i = 1; // 初始化语句
   		while (i<=100) {
   			if(i % 2 ==0){
   				sum += i;
   			};
   			i++;
   		}*/
   
   		/*
   		int i = 1;
   		do {
   			if(i % 2 ==0){
   				sum += i;
   			};
   			i++; // 步进语句
   		} while (i<=100);
   		*/
   	}
   }
   

7. 三种循环的区别：

   1. 如果条件判断从来没有满足过，那么for循环和while循环会执行0次。
   	但是do-while会执行至少一次
   2. for循环的变量在小括号当中定义，只有循环内部可以使用。
   	while循环和do...while循环初始化语句本来就在外面，所以出来循环出来之后还可以使用
   3. 
   

   public class Demo {
   	public static void main(String[] args) {
   		for (int i = 1; i < 0; i++) {
   			System.out.println("aaa");
   		}
   		// 结果 不打印
   		// System.out.println(i); // 报错
   		
   		int i = 1; // 初始化语句
   		do {
   			System.out.println("aaa");
   			i++;
   		} while (i < 0);
   		// 结果 aaa
   		System.out.println(i); // 2
   	}
   }
   

8. 循环控制语句

   break关键字的用法有常见的两种：
   	1. 可以在switch语句中，一旦执行，整个switch语句立刻结束
   	2. 还可以用在循环语句中，一旦执行，整个循环语句立刻结束。打断循环
   
   关于循环的选择，小建议：
   	凡是次数确定的场景多用for循环；否则多用while循环
   

   public class Demo {
   	public static void main(String[] args) {
   		for (int i = 1; i <= 5; i++) {
   			// 如果希望从第4次开始，后续全都不要了，打断循环
   			if (i == 4) {
   				break;
   			}
   			System.out.println("aaa");
   		}
   		// 结果打印3次 aaa
   	}
   }
   

   另一种循环控制语句是continue关键字
   	一旦执行，立刻跳过当前循环剩余内容，马上开始下一次循环。
   

   public class Demo {
   	public static void main(String[] args) {
   		for (int i = 1; i <= 5; i++) {
   			// 电梯场景希望到4时，跳过4层
   			if (i == 4) {
   				continue;
   			}
   			System.out.println(i + "层到了");
   		}
   		// 结果 1层到了 2层到了 3层到了 5层到了
   	}
   }
   

9. 死循环

   永远停不下来的循环，叫死循环。
   
   死循环的标准格式： 
   		while( true ) {
   			循环体
   		}
   
   注意事项：在死循环后写语句代码，会报错：无法访问语句
   

   public class Demo {
   	public static void main(String[] args) {
   		for (int i = 1; i <= 5; i++) {
   			// 电梯场景希望到4时，跳过4层
   			if (i == 4) {
   				continue;
   			}
   			System.out.println(i + "层到了");
   		}
   		// 结果 1层到了 2层到了 3层到了 5层到了
   	}
   }
   

10. 循环嵌套

    循环时间
    

    public class Demo {
    	public static void main(String[] args) {
    		for (int hour = 0; hour < 24 ; hour++) {
    			for (int minute = 0; minute < 60; minute++){
    			System.out.println(hour + "小时" + minute + "分钟");
    			}
    		}
    	}
    }