JAVA——选择，循环，顺序控制结构

目录

• 一、顺序控制
• 二、选择控制
  • 2.1分支控制
    • 2.1.1单分支
    • 2.1.2双分支
    • 2.1.3分支控制if-else
    • 2.1.4嵌套分支
  • 2.2switch分支结构
    • 细节讨论
    • 练习
      • 题目1
      • 题目2
      • 题目3
  • 2.3 switch和if的比较
• 三、循环控制
  • 3.1for循环
    • 3.1.1基本语法
    • 3.1.2注意事项和细节
      • 练习
  • 3.2while循环
    • 3.2.1注意事项和细节
      • 练习
  • 3.3do while循环
    • • 练习
  • 3.4多重循环
    • • 练习
  • 3.5跳转控制语句break
    • 3.5.1break语句标签
    • 练习
  • 3.6continue跳转控制语句
    • 3.6.1跳转控制语句-return

一、顺序控制

介绍：程序从上到下逐行地执行，中间没有任何判断和跳转

注意事项:

• Java中定义变量时采用合法的前向引用。

二、选择控制

2.1分支控制

2.1.1单分支

2.1.2双分支

2.1.3分支控制if-else

注意：

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

2.1.4嵌套分支

在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外 层分支。老师建议: 不要超过 3 层

---

2.2switch分支结构

1. switch关键字，表示switch分支
2. 表达式对应一个值
3. case 常量1：当表达式的值等于 常量1，就执行 语句块1
4. break：退出switch
5. 如果一个都没有匹配，就执行default

细节讨论

1.表达式数据类型，应和case 后的常量类型一致

• 或者是可以 自动转换成可以相互比较的类型，比如输入的是字符，而常量是int

2.switch(表达式) 中表达式的返回值必须是：(byte,short,int,char,enum[枚举],Sting)

3.case子句中的值必须是常量 或者常量表达式,不能是变量

4.default子句 是可选的，当没有匹配case时，默认执行default

5.如果没有写break，程序会顺序执行到switch结尾，除非遇到一个break；

• break语句用来执行一个case分支后使程序跳出switch语句块

练习

1. 使用 switch 把小写类型的 char 型转为大写(键盘输入)。只转换 a, b, c, d, e. 其它的输出 "other"。

2. 对学生成绩大于 60 分的，输出"合格"。低于 60 分的，输出"不合格"。(注：输入的成绩不能大于 100), 提示 成绩/60

3. 根据用于指定月份，打印该月份所属的季节。3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季

4. 课堂练习, 提示 使 用穿透

题目1

使用 switch 把小写类型的 char 型转为大写(键盘输入)。只转换 a, b, c, d, e. 其它的输出 "other

import java.util.Scanner;

public class SwitchExercise{

	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		char ch = myScanner.next().charAt(0);
		switch(ch){
			case 'a':
				ch = 'A';
				System.out.println(ch);
				break;
			case 'b':
				ch = 'B';
				System.out.println(ch);
				break;
			case 'c':
				ch = 'C';
				System.out.println(ch);
				break;
			case 'd':
				ch = 'D';
				System.out.println(ch);
				break;
			case 'e':
				ch = 'E';
				System.out.println(ch);
				break;
			default:
				System.out.println("你的输入有误");
		}
	}
}

题目2

对学生成绩大于 60 分的，输出"合格"。低于 60 分的，输出"不合格"。(注：输入的成绩不能大于 100), 提示 成绩/60

import java.util.Scanner;

public class SwitchExercise01{

	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		System.out.print("请输入学生的成绩:");
		double score = myScanner.nextDouble();

		//把用score/60并转换成int类型如果等于1，就是60以上及格
		//如果不等于1，就是不及格
		if(score>=0 &&score<=100){
			switch((int)score/60){
				case 1:
					System.out.print("成绩合格");
				case 0:
					System.out.print("成绩不合格");
			}
		}else{
			System.out.print("输入的成绩有误");
		}
	}
}

题目3

根据用于指定月份，打印该月份所属的季节。3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季

import java.util.Scanner;

public class SwitchExercise02{

	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		System.out.print("请输入月份:");
		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("请输入正确的月份");
				break;
		}
	}
}

2.3 switch和if的比较

1. 如果判断的具体数值不多，而且符合 byte、 short 、int、 char, enum[枚举], String 这 6 种类型。虽然两个语句都可 以使用，建议使用 swtich 语句
2. 其他情况：对区间判断，对结果为 boolean 类型判断，使用 if，if 的使用范围

---

三、循环控制

3.1for循环

3.1.1基本语法

1. for 关键字，表示循环控制

2. for 有四要素:

1)循环变量初始化

2)循环条件

3)循环操作

4)循环变量迭代

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

2. 如果 循环操作(语句) 只有一条语句，可以省略 {}, 建议不要省

3.1.2注意事项和细节

1. 循环条件是返回一个布尔值的表达式
2. for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
3. 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代 语句，中间用逗号隔开。

public class ForDetail{

	public static void main(String[] args){

			int i = 1;//循环变量初始化，for循环结束之后，还想使用这个i，就写在外面
			for( ; i <= 10;){
				System.out.println("Hello World!" + i);
				i++;
			}

			System.out.println(i);//11
			for(;;){//表示一个无限循环
				System.out.println("ok~");
			}
		}
	}
}

练习

题目1：打印1~100之间所有是9的倍数的整数，并统计个数及和

//打印1~100之间所有是9的倍数的整数，并统计个数及和
public class ForExercise{

	public static void main(String[] args){
		//1.利用for循环进行搜索 for(int i=1;i<100;i++)
		//2.进行判断，如果i满足 i%9==0 则输出i的值，并利用cnt变量记录个数
		//cnt变量默认为1
		//3.求和：满足条件后，把i加到sum里面去。
		int cnt = 0;
		int sum = 0;
		for(int i =1; i <= 100; i++){
			if( i % 9 == 0 ){
				System.out.println(i);
				sum+=i;
				++cnt;
			}
		}
		System.out.println("1~100中9的倍数的个数为： " + cnt);
		System.out.println("1~100中9的倍数和为： " + sum);
	}
}

方法2：

//打印1~100之间所有是9的倍数的整数，并统计个数及和
public class ForExercise{

	public static void main(String[] args){
		//1.利用for循环进行搜索 for(int i=1;i<100;i++)
		//2.进行判断，如果i满足 i%9==0 则输出i的值，并利用cnt变量记录个数
		//cnt变量默认为1
		//3.求和：满足条件后，把i加到sum里面去。
		int cnt = 0;
		int sum = 0;
		int i = 9;
		int end =100;
		for(int j =1; i*j <= end; j++){
			System.out.println(i*j);
			sum+=i*j;
			++cnt;
		}
		System.out.println("1~100中9的倍数的个数为： " + cnt);
		System.out.println("1~100中9的倍数和为： " + sum);
	}
}

---

3.2while循环

基本形式：

3.2.1注意事项和细节

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

练习

题目一：打印 1—100 之间所有能被 3 整除的数 [使用 while, 老师评讲 ]

public class WhileExercise{

	public static void main(String[] args){
		//打印 1—100 之间所有能被 3 整除的数

		int i = 1;
		int end = 100;
		while(i<=end){
			if(i%3==0){
				System.out.println(i);
			}
			i++
		}
	}
}

题目二：打印 40—200 之间所有的偶数 使用 while

public class WhileExercise01{

	public static void main(String[] args){
		//打印 40—200 之间所有的偶数
		int i = 40;
		int end = 200;
		while(i<=end){
			if(i%2==0){
				System.out.println(i);
			}
			i++;
		}
	}
}

3.3do while循环

循环变量初始化;

do{ 

	循环体(语句); 

	循环变量迭代; 

}while(循环条件);

1. do while 是关键字
2. 也有循环四要素, 只是位置不一样
3. 先执行，再判断，也就是说，一定会至少执行一次
4. 最后 有一个 分号 ;
5. while 和 do..while 区别举例

练习

题目：打印 1—100 并计算 1—100的和

public class DoWhileExercise{

	public static void main(String[] args){
		//打印 1—100之并计算和

		int sum = 0;
		int i = 1;
		int end = 100;
		do{
			sum+=i;
			System.out.println("i=" + i);
			i++
		}while(i<=end);

	}
}

题目： 统计 1---200 之间能被 5 整除但不能被 3 整除的个数

public class DoWhileExercise01{

	public static void main(String[] args){
		//统计 1---200 之间能被 5 整除但不能被 3 整除的个数

		int cnt = 0;
		int i = 1;
		int end = 200;
		do{
			if(i % 5 ==0 && i % 3 != 0){
					System.out.println("i=" + i);
					cnt++;
			}
			i++;
		}while(i<=end);
		System.out.println("cnt=" + cnt);
	}
}

题目：如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为止

import java.util.Scanner;

public class DoWhileExercise02{

	public static void main(String[] args){
		//如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为止
		Scanner myScanner = new Scanner(System.in);
		char anwser = ' ';
		//方法1
		/*do{
			System.out.println("还钱吗？y/n");
			anwser = myScanner.next().charAt(0);
			if (anwser!='y') {
				System.out.println("五连鞭");
			}else{
				System.out.println("张三还钱了");
			}
		}while(anwser!='y');*/

		do{
			System.out.println("老韩使出五连鞭");
			System.out.println("老韩问：还钱吗？y/n");
			anwser = myScanner.next().charAt(0);
			System.out.println("张三的回答：" + anwser);
		}while(anwser!='y');

		System.out.println("张三还钱了");

	}
}

3.4多重循环

1. 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while 均可以作为外层循环和内层循环。
   • 建议一般使用两层，最多不要超过 3 层, 否则，代码的可读性很差
2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内 层循环，才可结束外层的当次循环，开始下一次的循环。
3. 设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。

练习

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

import java.util.Scanner;

public class MulForExercise01{

	public static void main(String[] args){
		//统计统计 3 个班成绩情况，每个班有 5 名同学，
		//求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。

		Scanner myScanner = new Scanner(System.in);
		double score = 0;
		double average = 0;
		double sum = 0;
		int cnt = 0;//统计的及格人数
		double classSum;
		double classAve;

		for(int i = 1 ; i<=3; i++){
			 classSum = 0;//统计各班的总分
			 classAve =0;//统计各班的平均分
			for(int j = 1 ; j<=5;j++){
				System.out.println("请输如第 "+ i +"班"+ "第" +j +"个同学的成绩:");
				score = myScanner.nextDouble();
				classSum+=score;
				if(score>=60){
					cnt++;//分数大于60的cnt+1，cnt，代表及格个数
				}
			}
			sum+=classSum;//把各班级加到sum里面去，sum位总成绩之和
			classAve= classSum/5.0;
			System.out.println("第 "+ i +"班的平均成绩是："+ classAve );
			System.out.println("============================");
			System.out.println("============================");
		}
		average = sum/15.0;
		System.out.println("三个班的平均成绩是："+ average);
		System.out.println("及格人数："+ cnt);
	}
}

题目：九九乘法表

public class MulForExercise03{

	public static void main(String[] args){
		int i;
		int j;
		for( i = 1; i < 10 ;i++){
			for( j = 1 ; j <=i ; j++){
				System.out.print(j + "*" + i + "=" + i*j + "\t");
			}
			System.out.print("\n");
		}
	}
}

题目：经典的打印金字塔

public class Stars{

	public static void main(String[] args){
	/*打印空心金字塔
		totaLeave 层数
		1.打印完整的金字塔
		 1.1打印的空格
		 	1.1.1 每层的空格数=总层数-1
		 1.2打赢*
	*/	

		for (int i = 1;i <= 5 ; i++ ) {//i 表示层数

			//在输出*之前，还要输出对应空格
			for (int k = 1; k <= 5-i; k++) {
				System.out.print(" ");
			}

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

			System.out.print("\n");
		}
	}
}

public class Stars{

	public static void main(String[] args){
	/*打印空心金字塔
		1.打印完整的金字塔
		*  			//第1层 有1个*	4个空格
	   ***			//第2层 有3个*	3个空格
	  *****			//第3层 有5个*	2个空格
	 *******		//第4层 有7个*	1个空格
	*********		//第5层 有9个*	0个空格
		2.打印空心金字塔

		* 			//第1层 有1个*	当前行的第一个位置是*，最后一个位置也是*
	   * *			//第2层 有2个*	当前行的第一个位置是*，最后一个位置也是*
	  *   *			//第3层 有2个*	当前行的第一个位置是*，最后一个位置也是*
	 *     *		//第4层 有2个* 	当前行的第一个位置是*，最后一个位置也是*
	*********     	//第5层 有9个*	全部输出*
		3.先死后活
		层数变成变量

	*/
		int totalLevel = 20;
		for (int i = 1;i <= totalLevel ; i++ ) {//i 表示层数

			//在输出*之前，还要输出对应空格
			for (int k = 1; k <= totalLevel - i ; k++) {
				System.out.print(" ");
			}
			//输出*
			for (int j = 1; j <= i * 2 - 1 ; j++ ) {
				if ( i==totalLevel||j==1||j==i*2-1) {
					System.out.print("*");
				}else{
					System.out.print(" ");
				}

			}
			//没打印完一行就换行
			System.out.print("\n");
		}
	}
}

---

3.5跳转控制语句break

随机生成 1-100 的一个数，直到生成了 97 这个数，看看你一共用了几次?

思路分析：

• 循环，但是循环的次数不知道. -> break ,当某个条件满足时，终止循环
• 通过该需求可以说明其它流程控制的必要性，比如 break

random()
返回值为 double值为正号，大于等于 0.0 ，小于 1.0

介绍：break 语句用于终止某个语句块的执行，一般使用在 switch 或者循环[for , while , do-while]中

基本语法：
{
 break;
}

3.5.1break语句标签

1. break语句出现在多重嵌套的语句块中，可以通过标签指明要终止的是哪一层语句块BreakDetial.java

2. 标签的基本使用

lable1:{
lable2:
    {

	}
}

• break语句可以指定退出哪一层
• lable1是标签，名字由程序员决定
• break 后指定到那个lable就突出到哪里
• 在实际的开发中，老韩建议尽量不使用标签
• 如果没有指定break，默认退出最近的循环体

练习

题目：1-100 以内的数求和，求出 当和 第一次大于 20 的当前数 【for + break】

public class BreakDetail{

	public static void main(String[] args){
		int i;
		int sum = 0;
		for (i = 1;i <= 100 ;i++ ) {
			sum+=i;
			if(sum > 20){
				System.out.println("第一次大于20的数="+ i);
				break;
			}
		}

	}
}

题目：实现登录验证，有 3 次机会，如果用户名为"丁真" ,密码"666"提示登录成功，否则提示还有几次机会，请使用 for+break 完成

import java.util.Scanner;

public class BreakExercise{

	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		String name = "";
		String password = "";
		int chance = 3;
		int i;
		for (i = 1; i<=3 ; i++ ) {
			System.out.print("请输入用户名:");
			name = myScanner.next();
			System.out.print("请输入密码:");
			password = myScanner.next();

			if ( "丁真".equals(name)  &&  "666".equals(password)) {
				//这样写可以避免空指针
				System.out.println("登陆成功~");
				break;
			}
			chance--;
			System.out.println("你还有" + chance + "次登陆机会");
		}
		System.out.println("程序运行结束");
	}
}

注意：

• 字符串不能直接进行比较，要用equal进行比较
  • 格式："字符串".equals(字符串变量名)

---

3.6continue跳转控制语句

1. continue 语句用于结束本次循环，继续执行下一次循环
2. continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环 , 这个和前面的标签的 使用的规则一样.

import java.util.Scanner;

public class Java_Continue{

	public static void main(String[] args){
		label1:
		for(int j = 0; j < 4; j++){
		label2:
			for(int i = 0; i < 10; i++){
				if(i == 2){
				//看看分别输出什么值，并分析
				//continue ;
				//continue label2;
				continue label1;
				}
				System.out.println("i = " + i);//4组 i=0,i=1
			}
		}
	}
}

3.6.1跳转控制语句-return

return 使用在方法，表示跳出所在的方法

本章作业

public class Homework01{

	public static void main(String[] args){
		/*
		我的思路
		int cnt = 0;
		double money = 100000;
		while(money>=1000){
			if (money>50000) {
				money-=money*0.05;

			}else{
				money-=1000;
			}
			cnt++;
		}
		System.out.println("该人可以经过" + cnt + "次路口");//62次
		*/

		double money = 100000;
		int cnt = 0;
		while(true){
			if(money>50000){
				money -= money*0.05;
				cnt++;
			}else if(money>=1000&&money<=50000){
				money -= 1000;
				cnt++;
			}else{
				break;
			}
		}
		System.out.println("可以经过" + cnt + "次路口");
	}
}