【韩顺平Java笔记】第5章：程序控制结构

文章目录

102. 回顾上一章节
103. 顺序控制
- 103.1 顺序控制
104. 单分支使用
- 104.1 分支控制 if-else 介绍
- 104.2 单分支
105. 单分支流程图
106. 双分支使用
107. 双分支流程图
108. 双分支练习题
109. 多分支使用
- 109.1 多分支的流程图
110. 多分支练习1
111. 多分支练习2
112. 嵌套分支
- 112.1 基本介绍
- 112.2 基本语法
- 112.3 应用案例
113. 嵌套分支课后练习
114. switch基本语法
- 114.1 基本语法
115. switch流程图
116. switch快速入门
117. switch细节
118. 119. switch课堂练习1
120. switch和if选择
121. for基本语法
- 121.1 基本语法
122. for执行流程
123. for细节
124. for编程思想1
125. for编程思想2
126. while基本语法
- 126.1 基本语法
127. while执行流程
128. while课堂练习
运行结果： i=3 i=6 i=9 i=12 i=15 i=18 i=21 i=24 i=27 i=30 i=33 i=36 i=39 i=42 i=45 i=48 i=51 i=54 i=57 i=60 i=63 i=66 i=69 i=72 i=75 i=78 i=81 i=84 i=87 i=90 i=93 i=96 i=99
129. dowhile语法
130. dowhile执行流程
131. dowhile练习1
132. dowhile练习2
133. 多重循环执行流程
- 133.1 介绍
133.2 多重循环执行步骤分析
134. 多重循环练习1
135. 多重循环练习2
136. 空心金字塔
137. break需求
138. break执行流程
139. break快速入门
140. break细节
141. 142. break课堂练习1,2
143. continue执行流程
- 143.1 基本介绍
- - 143.2 基本语法
  - 143.3 流程图
144. continue快速入门
145. continue细节
146. return使用说明
147. 本章作业1
148. 本章作业2
149. 150. 151. 152. 本章作业3,4,5,6

102. 回顾上一章节

103. 顺序控制

在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。

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

103.1 顺序控制

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

104. 单分支使用

104.1 分支控制 if-else 介绍

让程序有选择的的执行,分支控制有三种

单分支 if
双分支 if-else
多分支 if-else if -…-else

104.2 单分支

import java.util.Scanner;
public class If01
{
    public static void main(String[] args)
    {
        //编写一个程序,可以输入人的年龄,如果该同志的年龄大于 18 岁, //则输出 "你年龄大于 18,要对自己的行为负责,送入监狱"
        //
        //思路分析
        //1. 接收输入的年龄, 应该定义一个 Scanner 对象
        //2. 把年龄保存到一个变量 int age
        //3. 使用 if 判断，输出对应信息
        //应该定义一个 Scanner 对象
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入年龄");
        //把年龄保存到一个变量 int age
        int age = myScanner.nextInt();
        //使用 if 判断，输出对应信息
        if(age > 18)
        {
            System.out.println("你年龄大于 18,要对自己的行为负责,送入监狱");
        }
        System.out.println("程序继续...");
    }
}

运行结果：
114514
你年龄大于 18,要对自己的行为负责,送入监狱
程序继续…

105. 单分支流程图

106. 双分支使用

import java.util.Scanner;
public class If02
{
    public static void main(String[] args)
    {
        //编写一个程序,可以输入人的年龄,如果该同志的年龄大于 18 岁, //则输出 "你年龄大于 18,要对
        //自己的行为负责, 送入监狱"。否则 ,输出"你的年龄不大这次放过你了."
        //
        //思路分析
        //1. 接收输入的年龄, 应该定义一个 Scanner 对象
        //2. 把年龄保存到一个变量 int age
        //3. 使用 if-else 判断，输出对应信息
        //应该定义一个 Scanner 对象
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入年龄");
        //把年龄保存到一个变量 int age
        int age = myScanner.nextInt();
        //使用 if 判断，输出对应信息
        if(age > 18)
        {
            System.out.println("你年龄大于 18,要对自己的行为负责,送入监狱");
        }
        else
        {
            System.out.println("你的年龄不大这次放过你了");
        }
        System.out.println("程序继续...");
    }
}

运行结果：
请输入年龄
1
你的年龄不大这次放过你了
程序继续…

107. 双分支流程图

108. 双分支练习题

单分支和双分支练习题

编写程序，声明 2 个 double 型变量并赋值。判断第一个数大于 10.0，且第 2 个数小于 20.0，打印两数之和。
【课后自己练】定义两个变量 int，判断二者的和，是否能被 3 又能被 5 整除，打印提示信息
判断一个年份是否是闰年，闰年的条件是符合下面二者之一：(1)年份能被 4 整除，但不能被 100 整除；(2)能被 400整除

public class IfExercise01 {
    public static void main(String[] args) {
        //第一个题
        double a = 11.0;
        double b = 19.1;
        if (a > 10 && b < 20) 
        {
            System.out.println("两个数和=" + (a + b));
        }
        //第二个题
        int x1 = 5;
        int x2 = 10;
        int sum1 = x1 + x2;
        if(sum1 % 3 == 0 && sum1 % 5 == 0)
        {
            System.out.println(x1 + "+" + x2 + "=" + sum1 + "既能被3又能被5整除");
        }
        else
        {
            System.out.println(x1 + "+" + x2 + "=" + sum1 + "不能被3又能被5整除");
        }
        //断一个年份是否是闰年，闰年的条件是符合下面二者之一
        int year = 2028;
        if((year % 4 == 0 && year % 100 !=0) || year % 400 == 0)
        {
            System.out.println(year + "年是闰年");
        }
        else
        {
            System.out.println(year + "年不是闰年");
        }
    }
}

运行结果：
两个数和=30.1
5+10=15既能被3又能被5整除
2028年是闰年

109. 多分支使用

109.1 多分支的流程图

110. 多分支练习1

输入保国同志的芝麻信用分：
如果：

信用分为 100 分时，输出信用极好；
信用分为(80，99]时，输出信用优秀；
信用分为[60,80]时，输出信用一般；
其它情况，输出信用不及格
请从键盘输入保国的芝麻信用分，并加以判断

import java.util.Scanner;
public class If03
{
    public static void main(String[] args) 
    {
        /*
        输入保国同志的芝麻信用分：
        如果：
        信用分为 100 分时，输出 信用极好；
        信用分为(80，99]时，输出 信用优秀；
        信用分为[60,80]时，输出 信用一般；
        其它情况 ，输出 信用 不及格
        请从键盘输入保国的芝麻信用分，并加以判断
        假定信用分数为 int
        */
        int score = 0;//信用分数
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入信用分(1-100):");
        score = scanner.nextInt();
        if(score >=1 && score <= 100)
        {
            if(score == 100)
            {
                System.out.println("信用极好");
            }
            else if(score > 80 && score <= 99)
            {
                System.out.println("信用优秀");
            }
            else if(score >= 60 && score <= 80)
            {
                System.out.println("信用一般");
            }
            else
            {
                System.out.println("信用不及格");
            }
        }
        else
        {
            System.out.println("信用分需要在 1-100,请重新输入:)");
        }
    }
}

运行结果：
请输入信用分(1-100):
99
信用优秀

111. 多分支练习2

先执行b = false，b为false
然后if条件是false不执行，else if条件也是false不执行，最后输出的是c，因为!b是true

112. 嵌套分支

112.1 基本介绍

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

112.2 基本语法

112.3 应用案例

参加歌手比赛，如果初赛成绩大于 8.0 进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。【可以让学员先练习下】, 输入成绩和性别，进行判断和输出信息。
提示: double score; char gender;
接收字符: char gender = scanner.next().charAt(0)

import java.util.Scanner;
public class NestedIf
{
    public static void main(String[] args) 
    {
        /*
        参加歌手比赛，如果初赛成绩大于 8.0 进入决赛，
        否则提示淘汰。并且根据性别提示进入男子组或女子组。
        【可以让学员先练习下】, 输入成绩和性别，进行判断和输出信息。
        [NestedIf.java]
        提示: double score; char gender;
        接收字符: char gender = scanner.next().charAt(0)
        */
        //思路分析
        //1. 创建 Scanner 对象，接收用户输入
        //2. 接收 成绩保存到 double score
        //3. 使用 if-else 判断 如果初赛成绩大于 8.0 进入决赛，否则提示淘汰
        //4. 如果进入到 决赛，再接收 char gender, 使用 if-else 输出信息
        //代码实现 => 思路 --> java 代码
        double score = 0.0;//成绩
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入该歌手的成绩");
        score = myScanner.nextDouble();
        if(score > 8.0)
        {
            System.out.println("请输入性别");
            char gender = myScanner.next().charAt(0);
            if(gender == '男')
            {
                System.out.println("进入男子组");
            }
            else if(gender == '女')
            {
                System.out.println("进入女子组");
            }
            else
            {
                System.out.println("你的性别有误，不能参加决赛~");
            }
        }
        else
        {
            System.out.println("sorry ,你被淘汰了~");
        }
    }
}

运行结果：
请输入该歌手的成绩
114514
请输入性别
男
进入男子组

113. 嵌套分支课后练习

4月-10月是旺季

import java.util.Scanner;
public class Price
{
	public static void main(String[] args)
	{
		//月份
		int month = 0;
		//输入月份
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入当前月份：");
		month = myScanner.nextInt();
		//年龄
		int age = 0;
		//输入年龄
		System.out.println("请输入年龄：");
		age = myScanner.nextInt();
		//票价
		double price = 60.0;
		if(month >= 4 && month <= 10)
		{
			//旺季票价60.0
			price = 60.0;
			if(age >= 18 && age <= 60)
			{
				System.out.println("票价为" + price);
			}
			else if(age < 18 && age >= 0)
			{
				System.out.println("票价为" + (price / 2.0));
			}
			else if(age > 60)
			{
				System.out.println("票价为" + (price / 3.0));
			}
			else
			{
				System.out.println("输入的年龄不合法！");
			}
		}
		else
		{
			//淡季票价40.0
			price = 40.0;
			if(age >= 18)
			{
				System.out.println("票价为" + price);
			}
			else if(age >= 0 && age < 18)
			{
				price = 20.0;
				System.out.println("票价为" + price);
			}
			else
			{
				System.out.println("输入的年龄不合法！");
			}
		}
	}
}

运行结果：
请输入当前月份：
4
请输入年龄：
61
票价为20.0

114. switch基本语法

114.1 基本语法

115. switch流程图

116. switch快速入门

请编写一个程序，该程序可以接收一个字符，比如:a,b,c,d,e,f,g
a 表示星期一，b 表示星期二 …
根据用户的输入显示相应的信息.要求使用 switch 语句完成

import java.util.Scanner;
public class Switch01
{
    public static void main(String[] args) 
    {
        /*
        案例：Switch01.java
        请编写一个程序，该程序可以接收一个字符，比如:a,b,c,d,e,f,g
        a 表示星期一，b 表示星期二 …
        根据用户的输入显示相应的信息.要求使用 switch 语句完成
        思路分析
        1. 接收一个字符 , 创建 Scanner 对象
        2. 使用 switch 来完成匹配,并输出对应信息
        代码
        */
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入字符(a-g)：");
        char c1 = myScanner.next().charAt(0);
        switch(c1)
        {
            case 'a':
                System.out.println("星期一");
                break;
            case 'b':
                System.out.println("星期二");
                break;
            case 'c':
                System.out.println("星期三");
                break;
            case 'd':
                System.out.println("星期四");
                break;
            case 'e':
                System.out.println("星期五");
                break;
            case 'f':
                System.out.println("星期六");
                break;
            case 'g':
                System.out.println("星期日");
                break;
            default:
                System.out.println("你输入的字符不对");
        }
        System.out.println("退出了 switch ,继续执行程序");
    }
}

执行两次运行结果：
请输入字符(a-g)：
f
星期六
退出了 switch ,继续执行程序

请输入字符(a-g)：
z
你输入的字符不对
退出了 switch ,继续执行程序

117. switch细节

自动转换成可以转换的类型例子：

常量表达式也能编译通过：

118. 119. switch课堂练习1

SwitchExercise.java

使用 switch 把小写类型的 char 型转为大写(键盘输入)。只转换 a, b, c, d, e. 其它的输出 “other”。
对学生成绩大于 60 分的，输出"合格"。低于 60 分的，输出"不合格"。(注：输入的成绩不能大于 100), 提示成绩/60
根据用于指定月份，打印该月份所属的季节。3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季 [课堂练习, 提示使
用穿透 ]

import java.util.Scanner;
public class SwitchExercise
{
    public static void main(String[] args) 
    {
        //第一题转换大小写
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入字母：");
        char c1 = myScanner.next().charAt(0);
        switch(c1)
        {
            case 'a':
                System.out.println("A");
                break;
            case 'b':
                System.out.println("B");
                break;    
            case 'c':
                System.out.println("C");
                break;
            case 'd':
                System.out.println("D");
                break;
            case 'e':
                System.out.println("E");
                break;
            default:
                System.out.println("other");
        }
        //第二题成绩问题
        double score = 0.0;
        System.out.println("请输入成绩：");
        score = myScanner.nextDouble();
        //成绩除60取整数，如果是大于60的成绩比如90，90/60必然是大于1的小数，则取整是1
        if(score >= 0 && score <= 100)
        {
            switch((int)score/60)
            {
                case 1:
                    System.out.println("合格");
                    break;
                case 0:
                    System.out.println("不合格");
                    break;
                default:
                    System.out.println("输入有误");
            }
        }
        else
        {
             System.out.println("输入的成绩不合法！");
        }
        //第三个问题季节问题
        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("你输入的月份不对(1-12)");
        }
    }
}

运行结果：
请输入字母：
e
E
请输入成绩：
61
合格
请输入月份：
3
春季

120. switch和if选择

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

121. for基本语法

基本介绍:听其名而知其意,就是让你的代码可以循环的执行.

121.1 基本语法

老韩说明

for 关键字，表示循环控制
for 有四要素: (1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
循环操作 , 这里可以有多条语句，也就是我们要循环执行的代码
如果循环操作(语句) 只有一条语句，可以省略 {}, 建议不要省略

122. for执行流程

123. for细节

循环条件是返回一个布尔值的表达式
for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。
使用内存分析法，老师分析输出下面代码输出什么?

124. for编程思想1

1)打印 1~100 之间所有是 9 的倍数的整数，统计个数及总和.[化繁为简,先死后活]

public class ForExercise
{
    public static void main(String[] args) 
    {
        int count = 0;//个数
        int sum = 0;//总和
        for(int i = 1; i <= 100; i++)
        {
            if(i % 9 == 0)
            {
                System.out.println("i=" + i);
                sum += i;
                count++;
            }
        }
        System.out.println("个数:" + count);
        System.out.println("总和" + sum);
    }
}

运行结果：
i=9
i=18
i=27
i=36
i=45
i=54
i=63
i=72
i=81
i=90
i=99
个数:11
总和594

125. for编程思想2

完成下面的表达式输出

public class ForExercise02
{
    public static void main(String[] args) 
    {
        for(int i = 0; i <= 5; i++)
        {
            System.out.println(i + "+" + (5 - i) + "=" + 5);
        }
    }
}

126. while基本语法

126.1 基本语法

127. while执行流程

128. while课堂练习

循环条件是返回一个布尔值的表达式
while 循环是先判断再执行语句
WhileExercise.java
打印 1—100 之间所有能被 3 整除的数 [使用 while, 老师评讲 ]
打印 40—200 之间所有的偶数 [使用 while, 课后练习]
代码

public class WhileExercise
{
    public static void main(String[] args) 
    {
        //while循环打印能被3整除的数
        int i = 1;
        while(i <= 100)
        {
            if(i % 3 == 0)
            {
                System.out.println("i=" + i);
            }
            i++;
        }
        //打印40-200之间的所有偶数
        System.out.println("========");
        int j = 40;
        while(j <= 200)
        {
            //按位与，二进制中最后一位是0表示偶数，是1表示奇数
            //利用位与运算（&）可以判断一个二进制数的最后一位是0还是1，如果结果为0，则表示该数为偶数，否则为奇数。
            if((j & 1) == 0)
            {
                System.out.println("j=" + j);
            }
            j++;
        }
    }
}

运行结果：
i=3
i=6
i=9
i=12
i=15
i=18
i=21
i=24
i=27
i=30
i=33
i=36
i=39
i=42
i=45
i=48
i=51
i=54
i=57
i=60
i=63
i=66
i=69
i=72
i=75
i=78
i=81
i=84
i=87
i=90
i=93
i=96
i=99

j=40
j=42
j=44
j=46
j=48
j=50
j=52
j=54
j=56
j=58
j=60
j=62
j=64
j=66
j=68
j=70
j=72
j=74
j=76
j=78
j=80
j=82
j=84
j=86
j=88
j=90
j=92
j=94
j=96
j=98
j=100
j=102
j=104
j=106
j=108
j=110
j=112
j=114
j=116
j=118
j=120
j=122
j=124
j=126
j=128
j=130
j=132
j=134
j=136
j=138
j=140
j=142
j=144
j=146
j=148
j=150
j=152
j=154
j=156
j=158
j=160
j=162
j=164
j=166
j=168
j=170
j=172
j=174
j=176
j=178
j=180
j=182
j=184
j=186
j=188
j=190
j=192
j=194
j=196
j=198
j=200

129. dowhile语法

循环变量初始化;
do{
循环体(语句);
循环变量迭代;
}while(循环条件);
【注】

do while 是关键字
也有循环四要素, 只是位置不一样
先执行，再判断，也就是说，一定会至少执行一次
最后有一个分号 ;
while 和 do…while 区别举例: 要账（即do…while先执行一次，while不会）

130. dowhile执行流程

循环条件是返回一个布尔值的表达式
do…while 循环是先执行，再判断，因此它至少执行一次

131. dowhile练习1

打印 1—100 [学生做]
计算 1—100 的和 [学生做]
统计 1—200 之间能被 5 整除但不能被 3 整除的个数 (DoWhileExercise01.java)

public class DoWhileExercise01
{
    public static void main(String[] args) 
    {
        //打印1-100
        int i = 1;
        int sum = 0;//求1-100的和
        do{
            System.out.println(i);
            sum += i;
            i++;
        }while(i<=100);
        System.out.println("sum=" + sum);
        //统计1-200之间能被5整除但不能被3整除的个数
        int count = 0;//个数
        i = 1;
        do{
            if(i % 5 == 0 && i % 3 != 0)
            {
                count += 1;
            }
            i++;
        }while(i <= 200);
        System.out.println("count=" + count);
    }
}

运行结果：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
sum=5050
count=27

132. dowhile练习2

如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为止
[System.out.println(“老韩问：还钱吗？y/n”)] do…while … DoWhileExercise02.java

import java.util.Scanner;
public class DoWhileExercise02
{
    public static void main(String[] args) 
    {
        Scanner myScanner = new Scanner(System.in);
        char ch = 'n';//还钱与否
        do { 
            System.out.println("老韩使出五连鞭~");
            System.out.println("老韩问：还钱吗？y/n");
            ch = myScanner.next().charAt(0);
            System.out.println("他的回答是" + ch);
        } while (ch == 'n'); //不还钱就接着拷打
        System.out.println("李三还钱了");
    }
}

运行结果：
老韩使出五连鞭~
老韩问：还钱吗？y/n
n
他的回答是n
老韩使出五连鞭~
老韩问：还钱吗？y/n
n
他的回答是n
老韩使出五连鞭~
老韩问：还钱吗？y/n
n
他的回答是n
老韩使出五连鞭~
老韩问：还钱吗？y/n
y
他的回答是y
李三还钱了

133. 多重循环执行流程

133.1 介绍

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

133.2 多重循环执行步骤分析

6次
i=0j=0
i=0j=1
i=0j=2
i=1j=0
i=1j=1
i=1j=2

134. 多重循环练习1

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


import java.util.Scanner;

public class MulForExercise01
{
    public static void main(String[] args) 
    {
        int classNum = 3;//3个班级
        int stuNum = 5;//5名学生
        double totalGrade = 0.0;//总成绩
        double classTotalGrade = 0.0;//每个班级的总成绩
        int passNum = 0;//统计每个班及格的人数
        double nowGrade = 0.0;//当前遍历到某个学生时候的成绩
        //创建Scanner对象
        Scanner myScanner = new Scanner(System.in);
        for(int i = 0; i < classNum ; i++)
        {
            //清空classTotalGrade为0，方便求下一个班级的平均成绩
            classTotalGrade = 0;
            for(int j = 0; j < stuNum; j++)
            {
                System.out.println("请输入" + (i+1) + "班第" + (j+1) + "个学生的成绩");
                nowGrade = myScanner.nextDouble();
                System.out.println("该生成绩为" + nowGrade);
                totalGrade += nowGrade;classTotalGrade += nowGrade;
                if(nowGrade >= 60.0)
                {
                    passNum++;
                }
            }
            System.out.println((i+1) + "班的平均成绩为" + classTotalGrade / stuNum);
        }
        System.out.println(classNum + "个班级的平均成绩为" + totalGrade / (classNum * stuNum));
        System.out.println("及格人数=" + passNum);
    }
}

运行结果：
请输入1班第1个学生的成绩
10
该生成绩为10.0
请输入1班第2个学生的成绩
10
该生成绩为10.0
请输入1班第3个学生的成绩
10
该生成绩为10.0
请输入1班第4个学生的成绩
10
该生成绩为10.0
请输入1班第5个学生的成绩
10
该生成绩为10.0
1班的平均成绩为10.0
请输入2班第1个学生的成绩
20
该生成绩为20.0
请输入2班第2个学生的成绩
20
该生成绩为20.0
请输入2班第3个学生的成绩
20
该生成绩为20.0
请输入2班第4个学生的成绩
20
该生成绩为20.0
请输入2班第5个学生的成绩
20
该生成绩为20.0
2班的平均成绩为20.0
请输入3班第1个学生的成绩
70
该生成绩为70.0
请输入3班第2个学生的成绩
70
该生成绩为70.0
请输入3班第3个学生的成绩
70
该生成绩为70.0
请输入3班第4个学生的成绩
70
该生成绩为70.0
请输入3班第5个学生的成绩
70
该生成绩为70.0
3班的平均成绩为70.0
3个班级的平均成绩为33.333333333333336
及格人数=5

135. 多重循环练习2

打印出九九乘法表



public class MulForExercise02
{
    public static void main(String[] args) 
    {
        for(int i = 1; i<=9; i++)
        {
            for(int j = 1; j <= i; j++)
            {
                System.out.print(j + "*" + i + "=" + (i * j) +'\t');
            }
            System.out.println();//换行格式要注意
        }
    }
}

运行结果：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

136. 空心金字塔

使用 for 循环完成下面的案例
请编写一个程序，可以接收一个整数,表示层数（totalLevel），打印出金字塔。(Stars.java)

import java.util.Scanner;
public class Stars
{
    public static void main(String[] args) 
    {
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入层数：");
        int totalLevel = myScanner.nextInt();
        //打印左侧第一种
        for(int i = 1; i <= totalLevel; i++)
        {
            for(int j = 1; j <= i; j++)
            {
                System.out.print("*");
            }
            System.out.println();
        }
        //打印从左到右第二种
        for(int i = 1; i <= totalLevel; i++)
        {
            //||||*
            //|||***
            //||*****
            //|*******
            //*********
            //打印空格|，总层数-i
            for(int k = 1; k <= totalLevel - i; k++)
            {
                System.out.print(" ");
            }  
            //打印
            //2i-1个（奇数个*）
            for(int j = 1; j <= 2*i - 1; j++)
            {
                System.out.print("*");
            }
            System.out.println();
        }
        //打印空心金字塔
        for(int i = 1; i <= totalLevel; i++)
        {
            //||||*
            //|||***
            //||*****
            //|*******
            //*********
            //打印空格|，总层数-i
            for(int k = 1; k <= totalLevel - i; k++)
            {
                System.out.print(" ");
            }  
            //打印
            //2i-1个（奇数个*）
            for(int j = 1; j <= 2*i - 1; j++)
            {
                //第一个位置是*，最后一个位置是*，最后一层全是*
                //其他情况打印空格
                if(j == 1 || j == 2*i - 1 || i == totalLevel)
                {
                    System.out.print("*");
                }
                else
                {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
        //打印空心菱形
        //打印上半部分
        for(int i = 1; i <= totalLevel; i++)
        {
            //||||*
            //|||***
            //||*****
            //|*******
            //*********
            //打印空格|，总层数-i
            for(int k = 1; k <= totalLevel - i; k++)
            {
                System.out.print(" ");
            }  
            //打印
            //2i-1个（奇数个*）
            for(int j = 1; j <= 2*i - 1; j++)
            {
                //第一个位置是*，最后一个位置是*
                //其他情况打印空格
                if(j == 1 || j == 2*i - 1)
                {
                    System.out.print("*");
                }
                else
                {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
        //打印下半部分，不包括中间的对角线
        for(int i = totalLevel - 1; i >= 1; i--)
        {
            //||||*
            //|||***
            //||*****
            //|*******
            //*********
            //打印空格|，总层数-i
            for(int k = 1; k <= totalLevel - i; k++)
            {
                System.out.print(" ");
            }  
            //打印
            //2i-1个（奇数个*）
            for(int j = 1; j <= 2*i - 1; j++)
            {
                //第一个位置是*，最后一个位置是*
                //其他情况打印空格
                if(j == 1 || j == 2*i - 1)
                {
                    System.out.print("*");
                }
                else
                {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
}

运行结果：

137. break需求

随机生成 1-100 的一个数，直到生成了 97 这个数，看看你一共用了几次?
提示使用 (int)(Math.random() * 100) + 1
思路分析：
循环，但是循环的次数不知道. -> break ,当某个条件满足时，终止循环
通过该需求可以说明其它流程控制的必要性，比如 break
【注】

138. break执行流程

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

基本语法
{ ……
break; ……
}

139. break快速入门

i为3时候跳出循环，此时没有执行打印输出语句，所以没输出i=3

140. break细节

【答】j为0时候，进入内层循环
i为0，i!=2，继续，输出i=0
i为1，i!=2，继续，输出i=1
i为2，跳出到label1，整个外层循环都终止，所以直接输出
i=0
i=1
【注】标签是标识符，可以按标识符规则命名
如果将break label1;改成break;
j为0时候，进入内层循环
i为0，i!=2，继续，输出i=0
i为1，i!=2，继续，输出i=1
i为2，跳出到外层循环
j为1：
i为0，i!=2，继续，输出i=0
i为1，i!=2，继续，输出i=1
i为2，跳出到外层循环
…
j一共从0到3，是打印了4次，即输出了4次重复的i=0 i=1，即
i=0
i=1
i=0
i=1
i=0
i=1
i=0
i=1

141. 142. break课堂练习1,2

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

public class BreakExercise {
    public static void main(String[] args) 
    {
        int sum = 0;// 求和0
        for (int i = 1; i <= 100; i++) 
        {
            sum += i;//累积
            if(sum > 20)
            {
                System.out.println("和>20 时候 当前数 i=" + i);
                break;
            }
        }
    }
}

运行结果：
和>20 时候当前数 i=6
2) 实现登录验证，有 3 次机会，如果用户名为"丁真" ,密码"666"提示登录成功，否则提示还有几次机会，请使用 for+break

import java.util.Scanner;
public class BreakExercise02 {
    public static void main(String[] args) 
    {
        Scanner myScanner = new Scanner(System.in);
        String name = "";
        String password = "";
        int chance = 3;//登陆次数
        for(int i = 0; i < chance; i++)
        {
            System.out.println("请输入名字：");
            name = myScanner.next();
            System.out.println("请输入密码：");
            password = myScanner.next();
            //比较输入的名字和密码是否正确
            //补充说明字符串 的内容 比较 使用的 方法 equals
            if("Dingzhen".equals(name) && "666".equals(password))
            {
                System.out.println("知识学爆，登录成功~");
                break;
            }
            System.out.println("你还有" + (chance - i - 1) + "次登录机会");
        }
    }
}

运行结果：
请输入名字：
1
请输入密码：
1
你还有2次登录机会
请输入名字：
2
请输入密码：
2
你还有1次登录机会
请输入名字：
Dingzhen
请输入密码：
666
知识学爆，登录成功~

143. continue执行流程

143.1 基本介绍

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

143.2 基本语法

{ ……
continue; ……
}

143.3 流程图

144. continue快速入门

145. continue细节

【答】
（1）continue的情况：
i=0
i=1
i=3
…
i=10
这样重复4遍
（2）continue label2的情况：
和continue的情况一致，因为继续执行的循环还是内层的，略过的还是i=2
（3）continue label1的情况：
继续执行的是最外层循环（相当于break;），所以答案为：
i=0
i=1
i=0
i=1
i=0
i=1
i=0
i=1

146. return使用说明

return 使用在方法，表示跳出所在的方法，在讲解方法的时候，会详细的介绍，这里我们简单的提一下。注意：如果 return 写在 main 方法，退出程序

输出结果是：
Hello World
Hello World
韩顺平教育

然后程序就退出了

147. 本章作业1



public class Homework01 {
    public static void main(String[] args) 
    {
        double money = 100000.0;//某人所带的钱
        int num = 0;//该人可以经过多少次路口
        //非要用break就只能这么抽象了
        while(true)
        {
            if(money > 50000)
            {
                money = money - money * 0.05;
                num++;//通过一次
            }
            else if (money > 1000 && money <= 50000)
            {
                money -= 1000;
                num++;//通过一次
            }
            else
            {
                break;//此处钱不够了，未通过
            }
        }
        System.out.println("该人可以经过" + num +"次路口");
    }
}

运行结果：
该人可以经过62次路口

148. 本章作业2

（2）

public class Homework02 {
    public static void main(String[] args) 
    {
        int n = 22;
        if(n > 0)
        {
            System.out.println(n + ">0");
        }
        else if(n == 0)
        {
            System.out.println(n + "=0");
        }
        else
        {
            System.out.println(n + "<0");
        }
    }
}

运行结果：
22>0
（3）

public class Homework03 {
    public static void main(String[] args) 
    {
        int year = 2020;
        if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
        {
            System.out.println(year + "年是闰年");
        }
    }
}

运行结果：
2020年是闰年
（4）

public class Homework04 {
    public static void main(String[] args) 
    {
        int n = 153;
        //先得到num的百位，十位，个位
        //n的百位 = n / 100
        //n的十位 = n % 100 / 10
        //n的个位 = n % 10
        int n1 = n / 100;
        int n2 = n % 100 / 10;
        int n3 = n % 10;
        if(n1 * n1 * n1 + n2 * n2 * n2 + n3 * n3 * n3 == n)
        {
            System.out.println(n + "是水仙花数");
        }
    }
}

运行结果：
153是水仙花数

149. 150. 151. 152. 本章作业3,4,5,6

【答】（5）什么都不输出

（6）

public class Homework06 {
    public static void main(String[] args) 
    {
        int count = 0;//统计输出的个数
        //count % 5 == 0就说明满5，需要换行
        for(int i = 1; i <= 100; i++)
        {
            if(i % 5 != 0)
            {
                System.out.print(i + "\t");
                count++;
                if(count % 5 == 0)
                {
                    System.out.println();
                }
            }
        }
    }
}

运行结果
1 2 3 4 6
7 8 9 11 12
13 14 16 17 18
19 21 22 23 24
26 27 28 29 31
32 33 34 36 37
38 39 41 42 43
44 46 47 48 49
51 52 53 54 56
57 58 59 61 62
63 64 66 67 68
69 71 72 73 74
76 77 78 79 81
82 83 84 86 87
88 89 91 92 93
94 96 97 98 99
（7）

public class Homework07 {
    public static void main(String[] args) 
    {
        //小写字母a-z
        for(char c1 = 'a'; c1 <= 'z'; c1++)
        {
            System.out.print(c1 + " ");
        }
        System.out.println("\n===========");
        //大写字母a-z
        for(char c1 = 'A'; c1 <= 'Z'; c1++)
        {
            System.out.print(c1 + " ");
        }
    }
}

运行结果：
a b c d e f g h i j k l m n o p q r s t u v w x y z
===========
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
（8）

public class Homework08 {
    public static void main(String[] args) 
    {
        double sum = 0.0;//求和用
        //奇数项正，偶数项负
        for(int i = 1; i <= 100; i++)
        {
            //i是偶数，sum减去
            if( (i & 1) == 0)
            {
                sum -= (1.0 / i);
            }
            else
            {
                sum += (1.0 / i);
            }
        }
        System.out.println("sum=" + sum);
    }
}

运行结果：
sum=0.688172179310195
（9）

public class Homework09 {
    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=" + sum);
    }
}