选择控制语句

if else

if选择结构是根据条件判断之后再做处理

if ( 条件 ) {

//代码块

}
if…else if…else 结构

语法

if(布尔表达式 1){

//如果布尔表达式 1的值为true执行代码

}else if(布尔表达式 2){

//如果布尔表达式 2的值为true执行代码

}else if(布尔表达式 3){

//如果布尔表达式 3的值为true执行代码

}else {

//如果以上布尔表达式都不为true执行代码

}
嵌套if

使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。

语法：

if(布尔表达式 1){

如果布尔表达式 1的值为true执行代码

if(布尔表达式 2){

如果布尔表达式 2的值为true执行代码

}

}

如以下实例

package com.lpl.demo;

import java.util.Scanner;

public class hello3 {
	public static void main(String [] arge){
		//创建sc对象
	    Scanner sc=new Scanner(System.in);
		System.out.println("张三的成绩是：");
		int score=sc.nextInt();//获取用户控制台输入的整数
		if(score>90){
			if(score>=95){
				System.out.println("奖励1000元");
			}else{
			    System.out.println("非常好，奖励一个MP4");
			}
			}else if(score>=60&&score<90){
				System.out.println("优秀！再接再厉");
			}else if(score>=50&&score<60){
				System.out.println("不及格，努力吧");
			}else{
				System.out.println("非常不好，叫家长！");
			}
			
		}
	
}

循环控制语句

while（特点：先判断，再执行）

while是最基本的循环，它的结构为：

while( 布尔表达式 ) {

//循环内容

}

public class Test {
   public static void main(String args[]) {
      int x = 10;
      while( x < 20 ) {
         System.out.print("value of x : " + x );
         x++;
         System.out.print("\n");
      }
   }
}


2.do while（特点：先执行，再判断）

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do…while 循环的结构如下：

do {

//代码语句

}while(布尔表达式);

public class Test {
   public static void main(String args[]){
      int x = 10;
 
      do{
         System.out.print("value of x : " + x );
         x++;
         System.out.print("\n");
      }while( x < 20 );
   }
}


For（非常重要）（特点：先判断，再执行）

例如，输出100次“好好学习！”

使用while循环结构：

int i=0;
while(i<100){
System.out.println("好好学习！");
i++;
}   

使用for循环结构：
for(int i=0;i<100;i++){ 
System.out.println("好好学习！");
}


break和continue

break用于do-while、while、for中时，可跳出循环而执行循环后面的语句

continue 适用于任何循环控制结构中。作用是跳过循环体中剩余的语句而执行下一次循环。

一、python课堂小习惯
带着问题去思考
带着问题去学习
带着问题去做题
二、带着问题，去文章中寻找答案
>>>《Python二级(06)——程序的控制结构》
问题1：python程序的三种基本结构是顺序结构、跳转结构和循环结构？
问题2：python 的在分支和循环语句里使用例如 x<=y<=z 的表达式是合法的？
问题3：while 循环如果设计不小心会出现死循环？
问题4：二分支结构的  if  else  形式，适合用来控制程序分支？
问题5：python程序二分结构由if-elif组成？
问题6：python 里，能用分支结构写出循环的算法？
问题7：确定次数的循环用 while 语句来实现，非确定次数的循环用 for 语句来实现？
问题8：用户输入整数的时候不合规导致程序出错，为了不让程序异常中断，需要用到的语句是？
问题9：print('True') if 0.2+0.1 == 0.3 else print('False')输出结果是？
问题10：分支结构中的判断条件可以使用任何能够产生 True或False的语句或函数？
问题11：print('True') if 0 else print('False')输出结果是？
问题12：print('True') if -1 else print('False')输出结果是？
问题13: print('True') if 'Hello' > 'hello' else print('False')
问题14：continue用来跳出最内层for或while循环，脱 离该循环后程序从循环后代码继续执行？
问题15：break用来结束当前当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环？
问题16：Python语言使用保留字try和catch进行异常处理?
三、学而不思则罔，思而不学则殆
如果你看完本章，不妨再看看刚刚的问题，相信你会有新的收获！
>>>《Python二级(06)——程序的控制结构》
四、上一课
>>>Python二级课堂02：《基本数据类型》

基本概念
Java中流程控制,包括分支语句,循环语句,循环控制语句
分支语句
if语句
switch语句
	判断表达式只能是int,short,byte,char,枚举
	判断case是否合法
		case后面的表达式必须和判断表达式相同
		case后面的表达式必须是常量
		不能有两个相同的case
案例
package com.itlwc;

public class Test {
	public static void main(String[] args) {
		int grade = 80;
		if (grade >= 80)
			System.out.println("优");
		else if (grade >= 60 && grade < 80)
			System.out.println("良");
		else if (grade < 60)
			System.out.println("差");
	}
}
流程图


循环语句
while循环语句
do-while循环语句
for循环语句
for循环针对有限的循环,while循环针对无限的循环

循环控制语句
break中断语句
continue继续语句
跳出多层循环
package com.itlwc;

public class Test {
	public static void main(String args[]) {
		ok: for (int i = 0; i < 10; i++) {
			if (i == 5) {
				break ok;
			}
			System.out.println(i);
		}
		System.out.println("执行完了!!!");
	}
}
/*
打印结果:
	0
	1
	2
	3
	4
	执行完了!!!
*/

教程视频来自B站韩顺平老师

零基础 快速学Java

目录
1. 顺序控制
2. 分支控制（if，else，switch）
2.1 switch
2.2 SwitchDetail
2.3 switch 和 if 的比较
3. for 循环控制（for，while，dowhile，**多重循环**）
3.1 For 基本语法
3.2 ForDetail
3.3 while循环控制
3.4 do...while基本语法
3.5 多重循环
4. break
4.1 跳转控制语句
4.2 BreakDetail
5. continue
6. return
7. Homework
题 1 ( 路口 )
题 2 ( 水仙花数 )
题 3 ( 5整除 )
题 4 ( A—Z )
题 5 ( 分数连加 )
题 6（1+2+...+100）
题 6（1+2+...+100）



三大流程控制语句

顺序控制
分支控制
循环控制


1. 顺序控制
合法的向前引用
2. 分支控制（if，else，switch）
让程序有选择性地执行
特别说明：

多分支，可以没有 else ，如果所有条件表达式都不成立，则一个执行入口都没有
如果有 else ，如果所有的表达式都不成立，则默认执行 else 代码块

嵌套分支：
最多不要超过 3 层（可读性不好）
2.1 switch



如果没有 break ，那就会一直执行下去
在java中，只要有值返回，就是一个表达式

2.2 SwitchDetail

public class SwitchDetail {
    public static void main(String[] args) {
        // 表达式数据类型，应与 case 后的常量类型一致
        // 或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int
        char c = 'a';
        switch(c) {
            case 'a' :
                System.out.println("ok1");
                break;
            case 'b' :
                System.out.println("ok2");
                break;
            default:
                System.out.println("ok3");
        }
    }
}

// 表达式数据类型，应与 case 后的常量类型一致
// 或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是 int
题 1：
// 对学生成绩大于60分，输出“合格”，低于60分的，输出不合格

// 注：输入的成绩不能大于100
// 对学生成绩大于60分，输出“合格”，低于60分的，输出不合格
// 注：输入的成绩不能大于100

import java.util.Scanner;
public class SwitchExersice1 {
	public static void main(String[] args) {
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入你的成绩:");
		double score = myScanner.nextDouble();
		// System.out.println(score);
		// 使用强转将 ((int)(score / 60)) 转为int类型,判断0或1

		if (score >= 0 && score <= 100) {
			switch ((int)(score / 60)) {
			case 0 :
				System.out.println("不及格");
				break;
			case 1 :
				System.out.println("及格了");
				break;
			// default :
			// 	System.out.println('输入错误');
			}
		}else {
			System.out.println("输入错误了");
		}
		
	}
}


题 2：
// 根据用于指定月份,打印该月份所属的季节

// 使用switch匹配，使用穿透来完成

// 根据用于指定月份,打印该月份所属的季节
// 使用switch匹配，使用穿透来完成	

import java.util.Scanner;
public class SwitchExersice3 {
	public static void main(String[] args) {
		Scanner myScanner = new Scanner(System.in);
		System.out.println("输入月份:");
		int month = myScanner.nextInt();

		switch(month) {
			case 3:
			case 4:
			case 5:
				System.out.println("春季");
				break;
			case 6:
			case 7:
			case 8:
				System.out.println("夏季");
				break;
			case 9:
			case 10:
			case 11:
				System.out.println("秋季");
				break;
			case 12:
			case 1:
			case 2:
				System.out.println("冬季");
				break;
			default:
				System.out.println("输入错误");
		}
	}
}

2.3 switch 和 if 的比较


如果判断的具体数值不多，而且符合 byte , short , int , char , enum[枚举] , String这6种类型。虽然两种语句都可以用，建议使用 switch 语句。

比如说星期，季节，性别，还有后面编写坦克大战（方向就几种），用switch



其他情况：对于区间判断，对结果为boolean类型判断，使用if，if 的使用范围更广


3. for 循环控制（for，while，dowhile，多重循环）
3.1 For 基本语法
for(循环变量初始化;循环条件;循环变量迭代){
    循环操作(可以多条语句);
}

注意点：


for 关键字，表示循环控制


for 有四要素：

循环变量初始化
循环条件
循环操作
循环变量迭代



循环操作，这里可以有多条语句，也就是我们要循环执行的代码


如果循环操作（语句）只有一条语句，就可以省略{}，但是建议不要省略


3.2 ForDetail

循环变量初始化和循环变量迭代可以写到其他地方，但两边的;不能省略

public class ForDetail {
	public static void main(String[] args) {
		int i = 1;
		for( ; i <= 10; ) {
			System.out.println("来了来了" + i);
			i++;
		}
        System.out.println(i);
	}
}


把循环变量放在外面的话，后续代码也可以使用



三个分号———死循环
for (; ; ) { // 表示一个死循环
    System.out.println("好耶" + (i++));
}



循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开
循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开


题 1 ：
//  打印1~100之间所有是9的倍数的整数，统计个数及总和
思路：…
// 打印1~100之间所有是9的倍数的整数，统计个数 及 总和
import java.util.Scanner;
public class ForExersice {
	public static void main(String[] args) {

		Scanner start = new Scanner(System.in);
		System.out.println("输入第一个数:");
		int num1 = start.nextInt();
		Scanner end = new Scanner(System.in);
		System.out.println("输入第二个数:");
		int num2 = end.nextInt();

		int count = 0;
		int sum = 0;
		for ( int i = num1; i <= num2 ; i++ ) {
			if (i % 9 == 0) { //9也可以替换成变量
				System.out.println(i);
				count++;
				sum += i;
			}
		}
		System.out.println("count=" + count);
		System.out.println("sum=" + sum);
	}
}


编程思想：

化繁为简：将复杂的需求拆解成简单的需求，逐步完成
先死后活：先考虑固定的值，然后转化成可以变化的值


题 2 ：
要求输出：
0+10=10
1+9=10

2+8=10

3+7=10

4+6=10

5+5=10

6+4=10

7+3=10

8+2=10

9+1=10

10+0=10
 public class ForExersice2 {
 	public static void main(String[] args) {

 		int num = 10; // num可以由用户输入
 		for ( int i = 0 ;i <= num ; i++ ) {
 			System.out.println(i + "+" + (num - i) + "=" + num);
 		}
 	}
 }

3.3 while循环控制
while(循环条件){
    循环体(循环语句);
    循环变量迭代;
}


注意：

循环条件是返回一个布尔值的表达式
while循环是先判断再执行语句


题 ：
// 打印1——100之间所有能被3整除的数
public class WhileExersice01 {
	public static void main(String[] args) {
		int num = 1; //num可以为变量输入
		while (num <=100) {
			if (num % 3 == 0) {
				System.out.println(num);
			}
			num++;
		}
	}
}

3.4 do…while基本语法
do{
    循环体(语句);
    循环变量迭代;
}while(循环条件);


do..while 适用于一开始就要有输出的语句中

注意：

do…while 只是一个关键字
也要有循环四要素，只是顺序不一样
先执行，再判断，也就是说至少会执行一次
最后有一个分号

题 1 :
//  打印1——200能被5整除但不能被3整除的数的个数

这里面的1 ,200 ,5 ,3 都可以改成变量输入

public class DoWhileExersice01 {
	public static void main(String[] args) {

		int num = 1;
		int count = 0;
		do {
			if (num % 5 == 0 && num % 3 != 0) {
				System.out.println(num);
				count++;

			}
			num++;
		}while (num <= 200);
		System.out.println("count="+ count);
	}
}

题 2 ：
//  如果张三不还钱，一直催，直到还钱(y/n)

注意这里不要将result定义到循环内部，会在判断'y'时识别不了

import java.util.Scanner;

public class DoWhileExersice02 {
	public static void main(String[] args) {

		char result = ' ';
		do {
			Scanner myScanner = new Scanner(System.in);
			System.out.println("还不还钱？  y/n\n再不还打死你");
			result = myScanner.next().charAt(0);
			
		} while(result != 'y');
		System.out.println("终于还钱了，真有你的");
	}
}

3.5 多重循环

题 1 ：
// 统计三个班的成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分 [学生的成绩从键盘输入]

// 统计三个班及格人数，每个班有5名同学
// (1)先计算一个班级的成绩
// (2)再就是其他班的循环

import java.util.Scanner;
public class MulForExersice {
    public static void main(String[] args) {

        int sum = 0;
        for ( int grade = 1; grade <= 3; grade++) {
            int sumScore = 0;
            for ( int num = 1 ; num <= 5 ; num++ ) {
                Scanner myScanner = new Scanner(System.in);
                System.out.println("请输入第" + grade +"个班 第" + num + "位同学的成绩");
                int score = myScanner.nextInt();
                sumScore += score;
            }
            System.out.println("第" + grade + "班的平均成绩为:" + (sumScore / 5));
            sum += sumScore;
        }
        System.out.println("所有同学的成绩平均分为:" + (sum / (3*5)));
    }
}

题 2 ：
// 打印一个空心金字塔 ***

println 表示打印完要换行
print表示打印完不换行

// println:表示执行完此次命令要换行
// print:表示不换行

// 打印一个空心金字塔
// 化繁为简
// 	(1)先打印一个矩形
// 	(2)再打印半个金字塔
//  (3)打印整个金字塔
		/*
		    *			//第1层有 1个*	2 * 1 - 1	有4=(总层数-1)个空格
		   ***			//第2层有 3个*	2 * 2 - 1	有3=(总层数-2)个空格
		  *****			//第3层有 5个*	2 * 3 - 1	有2=(总层数-3)个空格
		 *******		//第4层有 7个*	2 * 4 - 1	有1=(总层数-4)个空格
		*********		//第5层有 9个*	2 * 5 - 1	有0=(总层数-5)个空格		总层数=5
		*/
//  (4)再输出*之前输出加上空格
//  (5)打印镂空金字塔

public class Stars {
	public static void main(String[] args) {
		int total = 20;
		for ( int i = 1 ; i <= total ; i++ ) {

			for ( int k = 1 ; k <= total - i ; k++ ) {
				System.out.print(" ");
			}
			for ( int j = 1 ; j <= i * 2 - 1 ; j++ ) {

				// 一行的第一个位置为*，最后一个位置也是*，最后一行都是*
				if (j == 1 || j == i * 2 -1 || i == total) {
					System.out.print("*");
				}else {
					System.out.print(" ");
				}
			}
			System.out.println();  //每打印完一行后要换行
		}
	}
}

4. break
4.1 跳转控制语句

随机生成0——100的一个数，直到生成了97这个数
Math.random() 	方法生成一个0——1之间的一个double类型数据1

public class Test {
	public static void main(String[] args) {
		for ( int i = 1 ; i <= 10 ; i++ ) {
			System.out.println((int)(Math.random()*100) + 1);
		}
	}
}

break 用于终止某个语句块的循环，一般使用在switch或者循环for，while，do...while中，跳出当前循环，不是终止程序
4.2 BreakDetail


break 语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是那一层语句块


尽量不使用标签来退出某一层循环，会让可读性变差
如果没有指定break退出的层级，默认退出最近的循环体


题 1 ：
// 1–100以内数求和，求出当和第一次大于20的当前数
public class BreakExersice {
	public static void main(String[] args) {
		int i = 1;
		int sum = 0;
		for (; i <= 100 ; i++ ) {
			sum += i;
			if (sum > 20) {
				break;
			}
		}
		System.out.println(i);
	}
}

题 2 ：
// 实现登录验证，有三次机会，如果用户名为爆辣鸭脖，密码为002提示登录成功，否则提示还有几次机会 （ 用for break实现 )

// 循环三次，满足条件就退出
本题注意：最好将要使用的变量先定义在循环外面

用方法equal比较字符串内容是否相等（判断用户名和密码是否相等）
可以写作： name.equals(“爆辣鸭脖”) && password.equals(“002”)，但推荐下面写法
为了避免空指针

import java.util.Scanner;

public class BreakExersice2 {
	public static void main(String[] args) {

		Scanner myScanner = new Scanner(System.in);
		String name = " ";
		String password = " ";
		int chance = 3;
		for (int i = 1;i <=3 ;i++ ) {
			System.out.println("请输入用户名:");
			name = myScanner.next();
			System.out.println("请输入密码:");
			password = myScanner.next();

			// 比较输入的用户名和密码是否相同
			// 用 equals 方法比较字符串的内容是否相等
			// 可以写作： name.equals("爆辣鸭脖") && password.equals("002")，但推荐下面写法
			// 但是为了避免空指针

			if ("爆辣鸭脖".equals(name) && "002".equals(password)) {
				System.out.println("登录成功");
				break;
			}

			// 登录的机会减少一次
			chance --;
			System.out.println("你还有" + chance + "次登录机会");
		}
	}
}

5. continue
用于结束本次循环，以下语句不执行，继续执行下次循环
public class Continue01 {
	public static void main(String[] args) {
		int i = 1;
		while(i <= 4){
			i++;
			if (i == 2) {
				continue;
			}
			System.out.println("i=" + i);
		}
	}
}

6. return
return用在方法时，表示跳出方法，如果用在main，表示退出程序
将以下return换成break 和 continue：运行结果
public class Return01 {
	public static void main(String[] args) {
		for (int i = 1;i <= 5 ;i++ ) {
			if (i == 3) {
				System.out.println("爆辣鸭脖");
				return;
			}
			System.out.println("溜了溜了");
		}
		System.out.println("go on...");
	}
}

7. Homework
题 1 ( 路口 )
/* 某人有100 000元，每经过一次路口需要交费，规则如下

(1)当现金大于50000时，每次交5%

(2)当现金小于50000时，每次交1000

问：该人可以通过多少个路口（要求：用 while和break）

*/
public class Homework01 {
	public static void main(String[] args) {
		
		int money = 100000;
		int count = 0;
		while(true){
			if (money > 50000) {
				money *= 0.95;
				count++;
			}else if (money > 1000) {
				money -= 1000;
				count++;
			}else{  //小于1000元就退出
				break;
			}
		}
		System.out.println("可以通过" + count + "个路口");
	}
}

我写的：( 就离谱 )
public class Exercise01 {
	public static void main(String[] args) {

		int money = 100000;
		int count = 0;
		while(money > 50000){
			int lastMoney = money - money / 20;
			System.out.println("剩下" + lastMoney + "元");
			money = lastMoney;
			count++;
		}
		while(money > 0){
			int lastMoney2 = money -= 1000;
			money = lastMoney2;
			System.out.println("剩下" + lastMoney2);
			count++;
		}
		System.out.println(count-1);
	}
}

题 2 ( 水仙花数 )
// 水仙花数：153 = 1* 1* 1 + 3 3 * 3 + 5 5* 5

一个数怎么得到其百位，十位，个位数

public class Homework03 {
	public static void main(String[] args) {
		int n = 153;
		int n3 = n / 100;
		int n2 = n % 100 / 10;
		int n1 = n % 10;
		if (n3*n3*n3 + n2*n2*n2 + n1*n1*n1 == n) {
			System.out.println(n + "是水仙花数");
		}else{
			System.out.println("不是水仙花数");
		}
	}
}

题 3 ( 5整除 )
// 输出1——100之间的不能被5整除的数，每5个一行

关键在于：定义一个count接收输出的个数，count % 5 == 0时换行

public class Homework04 {
	public static void main(String[] args) {
		int count = 0;
		for (int i = 1;i <= 100 ;i++ ) {
			if (i % 5 != 0) {
				count++;
				System.out.print(i + " ");
				if (count % 5 == 0) {
					System.out.println();
				}
			}
		}
		System.out.println("count=" + count);
	}
}

题 4 ( A—Z )
// 输出小写的 a–z 和 Z–A

ASCII码表
//  字符是可以比较大小的，char字符的本质就是整数，输出时，输出时会按照对应的Unicode字符输出，而ASCII码包含于Unicode码

public class Homework05 {
	public static void main(String[] args) {
		
		// 由ASCII码表：'b' = 'a' + 1      'c' = 'a' + 2
		for (char c1 = 'a';c1 <= 'z' ;c1++ ) {
		//字符是可以比较大小的,char字符的本质就是整数，输出时，输出时会按照对应的Unicode字符输出，而ASCII码包含于Unicode码
			System.out.print(c1 + " ");
		}

		System.out.println();
		
		for (char c2 = 'Z';c2 >= 'A' ; c2-- ) {
			System.out.print(c2 + " ");
		}
	}
}

题 5 ( 分数连加 )
//  求出 1-1/2+1/3-1/4+1/5…1/100 的和

这里有一个陷阱：要将分子的1，写成1.0才能保留精度

// 这里有一个陷阱：要将分子的1，写成1.0才能保留精度

public class Homework06 {
	public static void main(String[] args) {

		double sum = 0;
		for (int i = 1;i <= 100 ;i++ ) {
			if (i % 2 != 0) {  //分母奇数
				sum += (1.0/i);
			}else{  //分母偶数
				sum -= (1.0/i);
			}
		}
		System.out.println("sum=" + sum);
	}
}

题 6（1+2+…+100）
//  1 + (1+2) + (1+2+3) + (1+2+3+4) + (…) + (1+2+…+100)
public class Homework07 {
	public static void main(String[] args) {

		int sum = 0;
		for (int i = 1;i <= 100 ;i++ ) {
			for (int j = 1;j <= i ;j++ ) {
				sum += j;
			}
		}
		System.out.println(sum);
	}
}

out.print(c2 + " ");

}

}

}

### 题 5 ( 分数连加 )

//  求出 1-1/2+1/3-1/4+1/5...1/100 的和

> 这里有一个陷阱：要将分子的`1`，写成`1.0`才能保留精度

```java
// 这里有一个陷阱：要将分子的1，写成1.0才能保留精度

public class Homework06 {
	public static void main(String[] args) {

		double sum = 0;
		for (int i = 1;i <= 100 ;i++ ) {
			if (i % 2 != 0) {  //分母奇数
				sum += (1.0/i);
			}else{  //分母偶数
				sum -= (1.0/i);
			}
		}
		System.out.println("sum=" + sum);
	}
}

题 6（1+2+…+100）
//  1 + (1+2) + (1+2+3) + (1+2+3+4) + (…) + (1+2+…+100)
public class Homework07 {
	public static void main(String[] args) {

		int sum = 0;
		for (int i = 1;i <= 100 ;i++ ) {
			for (int j = 1;j <= i ;j++ ) {
				sum += j;
			}
		}
		System.out.println(sum);
	}
}