// 顺序结构
public class Demo01Sequence {
	public static void main(String[] args) {
		System.out.println("今天天气不错");
		System.out.println("挺风和日丽的");
		System.out.println("我们下午没课");
		System.out.println("这的确挺爽的");
	}
}

判断语句

基本if语句

判断语句 if ，顾名思义就是通过判断表达式内的条件是否成立，来决定是否执行大括号内的代码，if语句可以说是很常见了，在我见过的所有编程语言中都有~

格式：

if(关系表达式){
    语句体;
}

执行流程：

在基本if语句中，他会首先判断条件表达式中的条件是true还是false，如果是true则执行大括号内的语句体，否则则不执行语句体。

实际代码段：

// 单if语句
public class Demo02If {
	public static void main(String[] args) {
		System.out.println("今天天气不错，正在压马路……突然发现一个快乐的地方：网吧");
		int age = 19;
		if (age >= 18) {
			System.out.println("进入网吧，开始high！");
			System.out.println("遇到了一群猪队友，开始骂街。");
			System.out.println("感觉不爽，结账走人。");
		}
		System.out.println("回家吃饭");
	}
}

拓展if语句

除了基本的if语句，他还能拓展！也就是加上else形成一个完整的判断！基本语句体中只是执行or不执行的区别，但是很多功能的实现实际需要对、错分别执行不同的代码，这个时候就需要用到拓展if语句啦！

格式：

if(关系表达式){
    语句体1;
}else{
    语句体2;
}

执行流程：

首先会判断关系表达式的结果是true还是false，如果是true则执行语句体1，如果是false则执行语句体2。

实际代码段：

// 标准的if-else语句
public class Demo03IfElse {
	public static void main(String[] args) {
		int num = 666;
		
		if (num % 2 == 0) { // 如果除以2能够余数为0，说明是偶数
			System.out.println("偶数");
		} else {
			System.out.println("奇数");
		}
	}
}

再拓展if语句

格式：

if(判断条件1){
    执行语句1;
}else if(判断条件2){
    执行语句2;
}
……
else if(判断条件n){
    执行语句n;    
}else{
    执行语句n+1;
}

执行流程：

会首先判断条件1，如果为true的话则执行语句1，如果是false的话就判断条件2是true还是false，如果是true就执行语句2，如果是false就继续判断后面的关系表达式，是true则执行，如果全都是false的话则执行语句n+1.

实际代码段：

// x和y的关系满足如下：
// 如果x >= 3，那么y = 2x + 1;
// 如果-1 < x < 3，那么y = 2x;
// 如果x <= -1，那么y = 2x – 1;
public class Demo04IfElseExt {
	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);
	}
}

小练习：

用if else语句实现成绩划分：

public class Demo05IfElsePractise {
	public static void main(String[] args) {
		int score = 120;
		if (score >= 90 && score <= 100) {
			System.out.println("优秀");
		} else if (score >= 80 && score < 90) {
			System.out.println("好");
		} else if (score >= 70 && score < 80) {
			System.out.println("良");
		} else if (score >= 60 && score < 70) {
			System.out.println("及格");
		} else if (score >= 0 && score < 60) {
			System.out.println("不及格");
		} else { // 单独处理边界之外的不合理情况
			System.out.println("数据错误");
		}
	}
}

用if语句替换三元运算符：

// 题目：使用三元运算符和标准的if-else语句分别实现：取两个数字当中的最大值
public class Demo06Max {
	public static void main(String[] args) {
		int a = 105;
		int b = 20;
		
		// 首先使用三元运算符
		// int max = a > b ? a : b;
		
		// 使用今天的if语句
		int max;
		if (a > b) {
			max = a;
		} else {
			max = b;
		}
		
		System.out.println("最大值：" + max);
	}
}

选择语句

在我们的程序执行中，除了按照正常顺序从上到下的执行，还有判断、选择和循环三种顺序，选择语句跟我们上面讲的判断语句可以说是大同小异，选择语句顾名思义就是根据条件判断，选择符合表达式条件的语句体进行执行。

swich语句

格式：

switch(表达式){
    case 常量值1:
      语句体1;
      break;
    case 常量值2:
      语句体2;
      break;    
    ……

    default:
      语句体n+1;
      break;
}

执行流程：

首先计算出表达式的值，与case后的值一一比对，有对应的值则执行相应的语句，遇到break结束流程，如果所有的值都不符合，则会执行default语句体部分，然后结束程序。

实际代码段：

public class Demo07Switch {
	public static void main(String[] args) {
		int num = 10;
		
		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; // 最后一个break语句可以省略，但是强烈推荐不要省略
		}
	}
}

需要注意的是，swich语句具有穿透性，如果没有写break，后面的case不会进行判断，直接执行里面的代码！直到遇到下一个break才会结束！

/*
switch语句使用的注意事项：

1. 多个case后面的数值不可以重复。

2. switch后面小括号当中只能是下列数据类型：
基本数据类型：byte/short/char/int
引用数据类型：String字符串、enum枚举

3. switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略。
“匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止。”
*/
public class Demo08SwitchNotice {
	public static void main(String[] args) {
		int num = 2;
		switch (num) {
			case 1:
				System.out.println("你好");
				break;
			case 2:
				System.out.println("我好");
				// break;
			case 3:
				System.out.println("大家好");
				break;
			default:
				System.out.println("他好，我也好。");
				break;
		} // switch
	}
}

循环语句

判断一个条件，如果条件满足的情况下重复执行一段代码，这就被称为循环体语句，需要注意的是，一定要在何时的时候及时打断循环，否则就进入死循环啦！

for循环

格式：

for(初始化表达式①;布尔表达式②;步进表达式④){
        循环体③
}

执行流程：

执行顺序：①②③④>②③④>②③④……直到②不满足为止。

①负责完成循环变量初始化

②负责判断是否满足循环条件，不满足则跳出循环

③具体执行的语句

④循环后，循环条件所涉及变量的变化情况

实际代码段：

/*
循环结构的基本组成部分，一般可以分成四部分：

1. 初始化语句：在循环开始最初执行，而且只做唯一一次。
2. 条件判断：如果成立，则循环继续；如果不成立，则循环退出。
3. 循环体：重复要做的事情内容，若干行语句。
4. 步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。
*/
public class Demo09For {
	public static void main(String[] args) {
		for (int i = 1; i <= 100; i++) {
			System.out.println("我错啦！原谅我吧！" + i);
		}
		System.out.println("程序停止");
	}
}

while循环

格式：

初始化表达式①
    while(布尔表达式②){
      循环体③
      步进表达式④
}

执行流程：

执行顺序：①②③④>②③④>②③④……直到②不满足为止。

①负责完成循环变量初始化

②负责判断是否满足循环条件，不满足则跳出循环。

③具体执行的语句

④循环后，循环变量的变化情况。

实际代码段：

/*
while循环有一个标准格式，还有一个扩展格式。

标准格式：
while (条件判断) {
	循环体
}

扩展格式：

初始化语句;
while (条件判断) {
	循环体;
	步进语句;
}
*/
public class Demo10While {
	public static void main(String[] args) {
		for (int i = 1; i <= 10; i++) {
			System.out.println("我错啦！" + i);
		}
		System.out.println("=================");
		
		int i = 1; // 1. 初始化语句
		while (i <= 10) { // 2. 条件判断
			System.out.println("我错啦！" + i); // 3. 循环体
			i++; // 4. 步进语句
		}
	}
}

do……while循环

格式：

do-while循环的标准格式：

do {
	循环体
} while (条件判断);

扩展格式：

初始化表达式①
do {
	循环体③
	步进语句④
} while (条件判断②);

执行流程：

执行顺序：①③④>②③④ >②③④……②不满足为止。

①负责完成循环变量初始化

②负责判断是否满足循环条件

③具体执行的语句

④循环后循环变量的变化情况

实际代码段：

/*
do-while循环的标准格式：

do {
	循环体
} while (条件判断);

扩展格式：

初始化语句
do {
	循环体
	步进语句
} while (条件判断);
*/
public class Demo11DoWhile {
	public static void main(String[] args) {
		for (int i = 1; i <= 10; i++) {
			System.out.println("原谅你啦！起来吧！地上怪凉！" + i);
		}
		System.out.println("===============");
		
		int i = 1; // 1. 初始化语句
		do {
			System.out.println("原谅你啦！起来吧！地上怪凉！" + i); // 3. 循环体
			i++; // 4. 步进语句
		} while (i <= 10); // 2. 条件判断
	}
}

小练习：

用各种循环求出1-100之间的偶数和。

/*
题目：求出1-100之间的偶数和。

思路：
1. 既然范围已经确定了是1到100之间，那么我就从1、2、3……一直到100这么多数字一个一个进行检查。
2. 总共有100个数字，并非所有数字都能用。必须要是偶数才能用，判断（if语句）偶数：num % 2 == 0
3. 需要一个变量，用来进行累加操作。也就好比是一个存钱罐。
*/
public class Demo12HundredSum {
	public static void main(String[] args) {
		int sum = 0; // 用来累加的存钱罐
		
		for (int i = 1; i <= 100; i++) {
			if (i % 2 == 0) { // 如果是偶数
				sum += i;
			}
		}
		System.out.println("结果是：" + sum);
	}
}

小总结

三种循环差别：

/*
三种循环的区别。

1. 如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但是do-while循环会执行至少一次。
2. for循环的变量在小括号当中定义，只有循环内部才可以使用。while循环和do-while循环初始化语句本来就在外面，所以出来循环之后还可以继续使用。
*/
public class Demo13LoopDifference {
	public static void main(String[] args) {
		for (int i = 1; i < 0; i++) {
			System.out.println("Hello");
		}
		// System.out.println(i); // 这一行是错误写法！因为变量i定义在for循环小括号内，只有for循环自己才能用。
		System.out.println("================");
		
		int i = 1;
		do {
			System.out.println("World");
			i++;
		} while (i < 0);
		// 现在已经超出了do-while循环的范围，我们仍然可以使用变量i
		System.out.println(i); // 2
	}
}

跳出语句

break

使用场景：终止switch或者循环

在选择结构wsitch语句中，或在循环语句中使用，离开使用场景的存在是没有意义的。

代码段：

/*
break关键字的用法有常见的两种：

1. 可以用在switch语句当中，一旦执行，整个switch语句立刻结束。
2. 还可以用在循环语句当中，一旦执行，整个循环语句立刻结束。打断循环。

关于循环的选择，有一个小建议：
凡是次数确定的场景多用for循环；否则多用while循环。
*/
public class Demo14Break {
	public static void main(String[] args) {
		for (int i = 1; i <= 10; i++) {
			// 如果希望从第4次开始，后续全都不要了，就要打断循环
			if (i == 4) { // 如果当前是第4次
				break; // 那么就打断整个循环
			}
			System.out.println("Hello" + i);
		}
	}
}

continue

使用场景：结束本次循环，继续下一次的循环

代码段：

/*
另一种循环控制语句是continue关键字。
一旦执行，立刻跳过当前次循环剩余内容，马上开始下一次循环。
*/
public class Demo15Continue {
	public static void main(String[] args) {
		for (int i = 1; i <= 10; i++) {
			if (i == 4) { // 如果当前是第4层
				continue; // 那么跳过当前次循环，马上开始下一次（第5层）
			}
			System.out.println(i + "层到了。");
		}
	}
}

其他

死循环

永远停不下来的循环叫做死循环，也就是循环中的条件永远为true，如while(true){}。

在后期开发中可能会出现死循环的使用场景，但是即便是死循环也要预留跳出缺口！！

/*
永远停不下来的循环，叫做死循环。

死循环的标准格式：
while (true) {
	循环体
}
*/
public class Demo16DeadLoop {
	public static void main(String[] args) {
		while (true) {
			System.out.println("I Love Java!");
		}
		
		// System.out.println("Hello");
	}
}

嵌套循环

所谓嵌套循环，就是一个循环套着另外一个循环，比如一个for循环里面套着一个for循环。总循环次数=外循环次数*内循环次数

格式：

for(初始表达式①;循环条件②;步进表达式⑦){
    for(初始化表达式③;循环条件④;步进表达式⑥){
        执行语句⑤;
    }
}

执行流程：

执行顺序：①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥

外循环一次，内循环多次。

实际代码段：

public class Demo17LoopHourAndMinute {
	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 + "分");
			}

		}
	}
}