Java选择结构、循环结构

二. Java语言基础

6. 控制语句

• 所有控制语句都能嵌套使用，只要合理嵌套就行

6.1 选择结构

if语句

• if语句，又被称为分支语句/条件控制语句：

if(布尔表达式){                //第一种方式
	java语句;
	java语句;
	...
}

if(布尔表达式){                //第二种方式
	java语句;
	...
}else{
	java语句;
	...
}

if(布尔表达式){                //第三种方式
	java语句;
	...
}else if(布尔表达式){
	java语句;
	...
}else if(布尔表达式){
	java语句;
	...
}...

if(布尔表达式){                //第四种方式
	java语句;
	...
}else if(布尔表达式){
	java语句;
	...
}else{
	java语句;
	...
}

• 对于java中的if语句来说，只要有一个分支执行，整个if语句全部结束

  带有else分支的编写方式可以保证一定会有分支执行

• if语句的分支中只有一条java语句的话，大括号可以省略（不推荐使用）

if (true/false){
	一条java语句;
}

if (true/false) 一条java语句;           //不推荐使用

boolean sex = false;
if (sex) System.out.println("男"); else System.out.println("女");		//编译通过

if (true)
	System.out.println("男");		 //编译通过
	System.out.println("蛤");		 //不属于if语句内容
else				//编译出错，else没有对应的if
	System.out.println("女");

• 题目：系统给定一个考生的成绩（可能带小数点），根据该学生的成绩判断成绩等级

  [90 - 100]：A [80 - 90)：B [70 - 80)：C [60 - 70)：D [0 - 60)：E

public class ScoreGrade{
	public static void main(String[] args){
		double score = 59.5;
		if(score < 0 || score > 100){
			System.out.println("成绩不合法");
		}else if(score >= 90){
			System.out.println("等级为A")
		}else if(score >= 80){
			System.out.println("等级为B")
		}else if(score >= 70){
			System.out.println("等级为C")
		}else if(score >= 60){
			System.out.println("等级为D")
		}else {
			System.out.println("等级为E")
		}
	}
}
//方法二：
String grade = "等级为E"；
if(score < 0 || score > 100){
	grade = "成绩不合法";
}else if(score >= 90){
	grade = "等级为A";
}else if(score >= 80){
	grade = "等级为B";
}else if(score >= 70){
	grade = "等级为C";
}else if(score >= 60){
	grade = "等级为D";
}
System.out.println(grade);

• 接收用户键盘输入命令：从键盘到内存
  1. 以字符串的形式接收
  2. 以数字形式（int）接收

System.out.println();				//负责向控制台输出（从内存到控制台）

//第一步：创建键盘扫描器对象
java.util.Scanner s = new java.util.Scanner(System.in);
//第二步：调用Scanner对象的next()方法开始接收用户键盘输入
String str = s.next();		//程序执行到这里会停下来，等待用户输入
//输入完成按下回车键后，输入信息自动赋值给变量str

int num = s.nextInt();				//接收数字
System.out.println("您输入的数字是：" + num);

• 题目：输入年龄，判断所在年龄阶段

public class abc
{
	public static void main(String[] args){
		java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.println("请输入您的年龄：");
		int age = s.nextInt();
		System.out.println("age = " + age);
		String str = "您处于老年";
		if (age < 0 || age >150){
			str = "年龄不合法";
		}else if (age <=5){
			str = "您处于幼年";
		}else if(age <= 18){
			str = "您处于青少年";
		}else if (age <= 35){
			str = "您处于青年";
		}else if (age <= 55){
			str = "您处于中年";
		}
		System.out.println(str);
	}
}

• 嵌套if语句练习题

public class weather{
	public static void main(String[] args){
		java.util.Scanner s = new java.util.Scanner(System.in);		//只写一遍就行
		System.out.println("请输入天气状况，1代表下雨，0代表晴天");
		int wea = s.nextInt();


		if (wea != 1 && wea != 0){
			System.out.println("您的天气太复杂");
		}else if (wea == 1){
			System.out.println("请输入性别，1代表男，0代表女");
			int sex = s.nextInt();
			if (sex == 1){
				System.out.println("带一把大黑伞");
			}else if (sex == 0){
				System.out.println("带一把小花伞");
			}else {
				System.out.println("您的性别不对劲");
			}
		}else{
			System.out.println("请输入气温");
			int tem = s.nextInt();
			if (tem > 30 && tem <= 50){
				System.out.println("请输入性别，1代表男，0代表女");
				int sex = s.nextInt();
				if (sex == 1){
					System.out.println("戴墨镜");
				}else if (sex == 0){
					System.out.println("擦防晒霜");
				}else {
				System.out.println("您的性别不对劲");
				}
			}else if (tem < -50 || tem > 50){
				System.out.println("您输入的气温不对劲");
			}
		}
	}
}

switch语句

• switch语句，属于选择结构，也是分支语句

  语法结构：

switch(int或String类型的字面值或变量){
	case int或String类型的字面值或变量：
		java语句;
		...
		break;
	case int或String类型的字面值或变量 :
		java语句;
		...
		break;
	...
	default :
		java语句;
		...
}

long x = 10L;
switch(x){}			//编译报错
switch((int) x){}		//编译通过

String User = "abc";
switch(User){}			//编译通过
bytr a = 10;
switch(a){}			//编译通过
short b = 10;
switch(b){}			//编译通过
char c = 'A';
switch(c){}			//编译通过
char c1 = '97';
switch(c1){}			//编译通过

switch(true){}			//编译报错

• switch语句执行原理：

  1. switch后面的小括号中的“数据”和case后面的“数据”进行一一匹配，匹配成功的分支执行，按照自上而下的顺序依次匹配
  2. 匹配成功的分支执行，若分支中有“break;”语句，整个switch语句终止
  3. 若匹配成功的分支没有“break;”语句，则继续执行后面分支，直到遇到“break;”语句或执行到switch语句结束。这种现象被称为case穿透现象【“break;”语句可以避免穿透】
  4. 所有分支都未匹配成功时，若有“default”分支则执行该分支程序
  5. switch 和 case 后面只能是 int 或 String 类型的数据（byte、short、char也可以，因为它们可以进行自动类型转换）（从jdk7开始可以写String）

• case可以合并

int i = 10;
switch(i){
	case 1: case 2: case 3: case 10:			//只要i是1、2、3、10其中一个
		System.out.println("Test Code!");		//此分支的语句就执行
}

• 题目：用户输入数字，显示星期几

java.util.Scanner s = new java.util.Scanner(System.in);
System.out.print("请输入1-7中任意数字")；
int num = s.nextInt();
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("您输入的数字非法")
}

• 题目：实现简单计算器的+、-、*、/、%功能

public class computer {
	public static void main(String[] args){
		java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.print("请输入第一个整数：");
			int num1 = s.nextInt();
		System.out.print("请输入运算符：");
			String operator = s.next();
		System.out.print("请输入第二个整数：");
			int num2 = s.nextInt();
			int result = 0;
		switch (operator){
		case "+":
			result = num1 + num2;
			break;
		case "-":
			result = num1 - num2;
			break;
		case "*":
			result = num1 * num2;
			break;
		case "/":
			result = num1 / num2;
			break;
		case "%":
			result = num1 % num2;
			break;
		}
		System.out.println(num1 + operator + num2 + "=" + result);
	}
}

• 用switch语句判断考生成绩等级，要求同上题

  窍门：(int)(成绩 / 10)

public class grade{
	public static void main(String[] args){
		java.util.Scanner s = new java.util.Scanner (System.in);
		System.out.print("请输入考生成绩：");
		double score = s.nextDouble();			//nextDouble将输入内容视为double型
		int a = (int)(score / 10);
		String grade = "A";
		switch (a){
			case 6:
				grade = "D";
			break;
			case 7:
				grade = "C";
			break;
			case 8:
				grade = "B";
			break;
			case 9: case 10:
				grade = "A";
			break;
			default :
				grade = "E";
		}
		System.out.println("该考生成绩等级为：" + grade);
	}
}

6.2 循环结构

• 基本上所有语言支持的循环包括三种：for循环、while循环、do…while循环

//for循环语法结构
for(初始化表达式;布尔表达式;更新表达式){
	//需要重复执行的代码片段（循环体）
}

for循环

• for循环执行原理

  1. 初始化表达式、布尔表达式、更新表达式都不是必须的，但两个分号是必须的
  2. 初始化表达式最先执行，且在整个for循环中只执行一次
  3. 布尔表达式必须是true/false，不能是其他值
  4. 执行过程：先执行初始化表达式，判断布尔表达式，为true则执行循环体，再执行更新表达式，再判断布尔表达式true还是false；为false则循环结束

for(int i = 1; i <= 10; i += 1){
	System.out.println(i);			  //输出1-10
}
for(;;){
	System.out.println("死循环");		//死循环
}

int i;
	for (i = 0; i <=10 ; ){
		System.out.println(i);		  //输出0 2 4 6 8 10
		i +=2;					//等同于for(i = 0; i <=10 ;i += 2){}
		System.out.println(i);		  //输出2 4 6 8 10 12
	}

• 循环体变量作用域：

for (int i = 0; i < 10; i ++){}			//此for循环的i变量作用域只在循环内使用
System.out.println("i = " + i);			//编译错误，无法在main方法作用域内访问

int i = 0;						//作用域为main方法
for (; i < 10; i ++){}
System.out.println("i = " + i);			//输出10

• 循环语句和条件判断语句嵌套使用（for和if的嵌套）

  题目：找出1 ~ 100的奇数（从1开始，以1递增，除以2取余数判断）

for(int i=1;i <= 100;i ++){
	if(i % 2 != 0){				//奇数对2取余数为1，偶数为0
		System.out.println(i);
	}
}

​ 计算1 ~ 100所有奇数的和

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

• 循环体中可以编写其他的控制语句，控制语句可以嵌套使用

  内层循环中的变量名和外层循环中的变量名不能重名

for(int i = 0;i <= 10;i ++){
	for(int i = 1; ;){}			//内循环，编译错误
}

​ 内层循环代码执行次数 = 外层循环数 * 内层循环数

for (int i = 0; i <10 ;i ++ ){				//外循环循环10次
	for (int j = 0;j < 3 ;j ++ ){			//内循环循环三次
		System.out.println("j = " + j);		//共输出30次0 1 2
	}
}

for(int i = 1; i <= 5; i++){
	for(int j = 1; j <= 5; j ++){
		System.out.println(i * j);		//i=1时与j=1、2、3、4、5相乘
	}							//i=2时与j=1、2、3、4、5相乘……
}								//输出1 2 3 4 5 2 4 6 8 10……

• 使用for循环实现九九乘法表：

for (int i = 1;i < 10 ;i ++ ){
	for (int j = 1;j <= i ;j ++ ){
		System.out.print(i +" * "+ j +" = "+ i*j);	//保证金字塔形不能换行
	}System.out.print('\n');		//换行，或者用println
}

• 用for循环找出1 ~ 100中所有的素数（只能被1和自身整除，不能被其他数整除，1不是素数）

  包含知识点：for循环使用、for循环嵌套、标记、break语句使用、统计

for(int i = 2; i <= 100; i++){
	boolean isSuShu = true;			//true表示是素数
	for(int j = 2; j <= i; j++){		//判断是否为素数
		if(i % j == 0){
			isSuShu = false;
			break;				//只要有一个被除尽就结束循环
		}
	}if(isSuShu){				//为true则输出
	System.out.println(i);
	}				//或者用System.out.println(isSuShu ? i + "是": i + "不是");
}

//升级版：每输出8个数字换一行
int count = 0;
for(int i = 2; i <= 100; i++){
	boolean isSuShu = true;
	for(int j = 2; j <= i; j++){
		if(i % j == 0){
			isSuShu = false;
			break;
		}
	}if(isSuShu){
		System.out.println(i + "  ");
		count++;
		if(count % 8 == 0){			//能被8整除则换行
			System.out.println();
		}
	}
}

//换行的代码还可以写成：
if(count == 8){
	System.out.println();
	count = 0;				//归零
}

while循环

• while循环语法结构：

while(布尔表达式){			//布尔表达式为true则执行循环体
	//循环体				 //执行完再判断布尔表达式，为false时退出循环
}

• while循环的循环次数：0 ~ n次（while循环体可能执行0次）

while (true){
	System.out.println("死循环");		//死循环
}
System.out.println("Hello World!");		  //编译报错，编译器检测到该程序永远都无法执行

int i = 10;
int j = 3;
while(i > j){
	System.out.println("呵呵");
}
System.out.println("Hello World!")		  //编译通过，编译阶段不检查变量的布尔表达式

• 使用while循环输出1 ~ 10

int i = 1;
while(i <= 10){
	System.out.println(i);			//输出1 2 3 4 5 6 7 8 9 10
	i ++;
}
System.out.println(i);				//输出11

int j = 10;
while(j > 0){
	System.out.println(j --);		//输出10 9 8 7 6 5 4 3 2 1 
	System.out.println(j);			//输出9 8 7 6 5 4 3 2 1 0
}
System.out.println(j);				//输出0

int k = 10;
while(k >= 0){
	System.out.println(--k);		//输出9 8 7 6 5 4 3 2 1 0 -1
}
System.out.println(k);				//输出-1

do…while循环

• do…while循环语法结构：

do{
	循环体;
}while(布尔表达式);

• do…while循环的循环体代码执行次数为1 ~ n次【至少执行一次】

  do…while循环最后有一个“分号”

int i = 10;
do{
	System.out.println(i);			//输出10
}while(i > 100);				//退出循环

int j = 1;
do{
	System.out.println(j);			//输出1 2 3 4 5 6 7 8 9 10
	j ++;
}while(j <= 10);

• break语句：

  1. break和分号“;”可以成为一个单独的完整的java语句： break;

  2. break语句可以用在switch语句中，避免穿透现象

  3. break语句可以使用在循环语句（for、while、do…while）中，用来终止循环的执行

  4. 默认情况下，break语句终止离它最近的循环语句。也可以指定终止某个循环，需要给循环起名

     语法： break 循环名称 ;

for(int i = 0; i < 10; i ++){
	if(i == 5){
		break;
	}System.out.println(i);			//输出0 1 2 3 4
}

for(int j = 0; j < 3; j++){
	for(int i = 0; i < 10; i++){
		if(i == 5){
			break;				//这里的break语句终止的是内层for循环
		}					//这里的break语句不会影响外层循环
	}System.out.println(i);			//输出三个“0 1 2 3 4”
}

for1 :for(int j = 0; j < 3; j++){			//外层for循环起名for1
	for2 :for(int i = 0; i < 10; i++){		//内层for循环起名for2
		if(i == 5){
			break for1;				//终止for1循环
		}
	}System.out.println(i);				//输出三个“0 1 2 3 4”
}

• continue语句：

  1. 一个continue关键字和分号“;”构成一个完整的语句： continue;

  2. break和continue的区别：

     break表示循环体结束，终止循环

     continue表示终止“本次”循环，直接进入下一次循环继续执行

  3. continue也有这样的用法： continue 循环名称; （作为了解内容）

for(int i = 0; i < 10; i++){
	if(i == 5){
		continue;			//i == 5时本次循环结束，直接进入下一次循环
	}
}System.out.println(i);			 //输出0 1 2 3 4 6 7 8 9

myFor :for(int i = 0; i < 10; i++){
	if(i == 5){
		continue myFor;		//continue作用于myFor循环
	}
}System.out.println(i);			 //输出0 1 2 3 4 6 7 8 9