概述
1.顺序控制
-
程序流程控制介绍
在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。- 顺序控制
- 分支控制
- 循环控制
-
顺序控制
2.分支控制if-else–“单分支”
- 分支控制if-else 介绍
让程序有选择的的执行,分支控制有三种- 单分支if
- 双分支if-else
- 多分支if-else if -…-else
- 单分支
import java.util.Scanner;//导入
public class If01 {
//编写一个main方法
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("程序继续...");
}
}
- 单分支流程图
3.分支控制if-else–“双分支”
- 基本语法
- 代码演示
import java.util.Scanner;//导入
public class If02 {
//编写一个main方法
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-else 判断，输出对应信息
if(age > 18) {
System.out.println("你年龄大于18,要对自己的行为负责,送入监狱");
} else {//双分支
System.out.println("你的年龄不大这次放过你了");
}
System.out.println("程序继续...");
}
}
- 双分支流程图
4.单分支、双分支练习题
public class IfExercise01 {
//编写一个main方法
public static void main(String[] args) {
//第1题，编写程序，声明2个double型变量并赋值。
//判断第一个数大于10.0，且第2个数小于20.0，打印两数之和
double d1 = 33.5;
double d2 = 2.6;
if(d1 > 10.0 && d2 < 20.0) {
System.out.println("两个数和=" + (d1 + d2));
}
//第2题，定义两个变量int，判断二者的和，
//是否能被3又能被5整除，打印提示信息
//思路分析
//1. 定义两个变量int num1, num2
//2. 定义一个变量 int sum = num1 + num2;
//3. sum % 3 , 5 后 等于0 说明可以整除
//4. 使用 if - else 来提示对应信息
//走代码
int num1 = 10;
int num2 = 1;
int sum = num1 + num2;
if(sum % 3 == 0 && sum % 5 == 0) { //等号千万是两个==，不能是=
System.out.println("和可以被3又能被5整除");
} else {
System.out.println("和不能·被3和5整除..");
}
//第3题，判断一个年份是否是闰年，闰年的条件是符合下面二者之一：
//(1)年份能被4整除，但不能被100整除；(2)能被400整除
//思路分析
//1. 定义 int year 保存年
//2. 年份能被4整除，但不能被100整除,
// => year % 4 == 0 && year % 100 != 0
//3. 能被400整除 => year % 400 == 0
//4. 上面的 2 和 3 是 或的关系
//代码实现
int year = 2028;
if( (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 ) {
System.out.println(year + " 是 闰年");
} else {
System.out.println(year + " 不是 闰年");
}
}
}
5.分支控制if-else–“多分支”
-
基本语法
-
流程图
-
课堂练习
注意：grade > 80 && grade <= 99，千万不能写成 80 < grade <=99
import java.util.Scanner;
public class If03 {
//编写一个main方法
public static void main(String[] args) {
/* 习题1
输入保国同志的芝麻信用分：
如果：
信用分为100分时，输出 信用极好；
信用分为(80，99]时，输出 信用优秀；
信用分为[60,80]时，输出 信用一般；
其它情况 ，输出 信用 不及格
请从键盘输入保国的芝麻信用分，并加以判断
假定信用分数为int
*/
Scanner myScanner = new Scanner(System.in);
//接收用户输入
System.out.println("请输入信用分(1-100):");
//请思考：如果小伙伴输入的不是整数，而是hello..
//==>这里我们后面可以使用异常处理机制搞定-》老师点一下
int grade = myScanner.nextInt();
//先对输入的信用分，进行一个范围的有效判断 1-100, 否则提示输入错误
if(grade >=1 && grade <= 100) {
//因为有4种情况，所以使用多分支
if(grade == 100) {
System.out.println("信用极好");
} else if (grade > 80 && grade <= 99) { //信用分为(80，99]时，输出 信用优秀；
System.out.println("信用优秀");
} else if (grade >= 60 && grade <= 80) {//信用分为[60,80]时，输出 信用一般
System.out.println("信用一般");
} else {//其它情况 ，输出 信用 不及格
System.out.println("信用不及格");
}
} else {
System.out.println("信用分需要在1-100,请重新输入:)");
}
}
}
习题2 ：
6.嵌套分支
- 基本介绍
在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。建议: 不要超过3 层（可读性不好）
- 基本语法
if (){
if(){
//if-else...
}else{
//if-else...
}
}
- 案例演示
import java.util.Scanner;
public class NestedIf {
//编写一个main方法
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代码
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入该歌手的成绩");
double 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 ,你被淘汰了~");
}
}
}
7.switch分支结构
-
基本语法
-
流程图
-
案例
案例：Switch01.java
请编写一个程序，该程序可以接收一个字符，比如:a,b,c,d,e,f,g
a 表示星期一，b 表示星期二…
根据用户的输入显示相应的信息.要求使用switch 语句完成。
import java.util.Scanner;
public class Switch01 {
//编写一个main方法
public static void main(String[] args) {
/*思路分析
1. 接收一个字符 , 创建Scanner对象
2. 使用switch 来完成匹配,并输出对应信息
*/
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入一个字符(a-g)");
char c1 = myScanner.next().charAt(0);//
//在java中，只要是有值返回，就是一个表达式
switch(c1) {
case 'a' :
System.out.println("今天星期一,猴子穿新衣");
break;
case 'b' :
System.out.println("今天星期二,猴子当小二");
break;
case 'c' :
System.out.println("今天星期三,猴子爬雪山..");
break;
//.....
default:
System.out.println("你输入的字符不正确，没有匹配的");
}
System.out.println("退出了switch ,继续执行程序");
}
}
- 注意事项和细节
case子句中的值必须是常量(1,‘a’)或者是常量表达式,而不能是变量 - 课堂练习
- 使用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 {
//编写一个main方法
public static void main(String[] args) {
//使用 switch 把小写类型的
//char型转为大写(键盘输入)。只转换 a->A, b->B, c, d, e.
//其它的输出 "other"。
//创建Scanner对象
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入a-e");
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("你的输入有误~");
}
//第二题
import java.util.Scanner;
public class zuoye{
public static void main(String[] args){
// 这道题，可以使用 分支来完成， 但是要求使用switch
// 这里我们需要进行一个转换, 编程思路 :
// 如果成绩在 [60,100] , (int)(成绩/60) = 1
// 如果成绩在 [0,60) , (int)(成绩/60) = 0
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入学生成绩，0-100分");
int score = myScanner.nextInt();
if (score >= 0 && score <= 100) {
switch((int)(score/60)){ //运用了强转
case 0: //注意不要写成case '0'
System.out.println("不合格");
break;
case 1 : //注意不要写成case '1'
System.out.println("合格");
break;
}
}else{
System.out.println("输入有误");
}
}
}
//第三题
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 1:
case 2:
case 12:
System.out.println("这是冬季");
break;
default :
System.out.println("你输入的月份不对(1-12)");
}
}
}
8. switch 和if 的比较
- 如果判断的具体数值不多，而且符合byte、short 、int、char, enum[枚举], String 这6 种类型。虽然两个语句都可以使用，建议使用swtich 语句。
- 其他情况：对区间判断，对结果为boolean 类型判断，使用if，if 的使用范围更广
9.for 循环控制(!!!)
基本介绍:听其名而知其意,就是让你的代码可以循环的执行.
看一个实际需求，请大家看个案例[For01.java]:
编写一个程序, 可以打印10 句"你好，韩顺平教育!"。请大家想想怎么做?
-
基本语法
说明： -
for 关键字，表示循环控制
-
for 有四要素: (1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
-
循环操作, 这里可以有多条语句，也就是我们要循环执行的代码
-
如果循环操作(语句) 只有一条语句，可以省略{}, 建议不要省略
-
for 循环执行流程分析
流程图
代码执行内存分析
-
注意事项和细节说明
- 循环条件是返回一个布尔值的表达式
- for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
- 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。
- 使用内存分析法，老师分析输出下面代码输出什么?
//演示for的使用细节
public class ForDetail {
//编写一个main方法
public static void main(String[] args) {
/* for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
。。。这样的好处是for循环完之后还可以用变量i ***/
// 使用for循环控制
// int i = 1;//循环变量初始化
// for( ; i <= 10 ; ) {
// System.out.println("hello，韩顺平教育" + i);
// i++;
// }
// System.out.println("i=" + i);//11 ok
// int j = 1;
// //补充
// for(;;) { //表示一个无限循环,死循环
// System.out.println("ok~" + (j++));
// }
//循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，
//循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开
//老师使用内存分析法，看看下面代码输出什么?
int count = 3;
for (int i = 0,j = 0; i < count; i++, j += 2) {
System.out.println("i=" + i + " j=" + j);
}
}
}
- 练习题
- 打印1~100 之间所有是9 的倍数的整数，统计个数及总和.[化繁为简,先死后活]
public class zuoye {
//编写一个main方法
public static void main(String[] args) {
//打印1~100之间所有是9的倍数的整数，统计个数 及 总和.[化繁为简,先死后活]
//老韩的两个编程思想(技巧)
//1. 化繁为简 : 即将复杂的需求，拆解成简单的需求，逐步完成
//2. 先死后活 : 先考虑固定的值，然后转成可以灵活变化的值
//
//思路分析
//打印1~100之间所有是9的倍数的整数，统计个数 及 总和
//化繁为简
//(1) 完成 输出 1-100的值
//(2) 在输出的过程中，进行过滤，只输出9的倍数 i % 9 ==0
//(3) 统计个数 定义一个变量 int count = 0; 当 条件满足时 count++;
//(4) 总和 , 定义一个变量 int sum = 0; 当条件满足时累积 sum += i;
//先死后活
//(1) 为了适应更好的需求，把范围的开始的值和结束的值，做成变量
//(2) 还可以更进一步 9 倍数也做成变量 int t = 9;
int count = 0; //统计9的倍数个数 变量
int sum = 0; //总和
int start = 1;
int end = 100;
int t = 9; // 倍数
for(int i = start; i <= end; i++) {
if( i % t == 0) {
System.out.println("i=" + i);
count++;
sum += i;//累积
}
}
System.out.println("count=" + count);
System.out.println("sum=" + sum);
}
}
2.完成下面的表达式输出[老师评讲ForExercise02.java] 化繁为简 先死后活
//先简单来一下
public class zuoye {
public static void main(String[] args) {
for(int i = 0, b = 5; i <= 5 && b >= 0; i++,b--) {
System.out.println(i + "+" + b + "=5" );
}
}
}
//换成变量，先死后活
public class zuoye {
public static void main(String[] args) {
int a1 = 2;
int a2 = 10;
for(int i = a1, b = a2; i <= a2 && b >= a1; i++,b--) {
System.out.println(i + "+" + b + "=" + a2 );
}
}
}
10.while循环
- 基本语法
- 流程分析
内存分析
- 注意事项和细节说明
- 循环条件是返回一个布尔值的表达式
- while 循环是先判断再执行语句
- 课堂练习题 WhileExercise.java
- 打印1—100 之间所有能被3 整除的数[使用while, 老师评讲]
- 打印40—200 之间所有的偶数[使用while, 课后练习]
public class WhileExercise {
public static void main(String[] args) {
// 第1题：打印1―100之间所有能被3整除的数 [使用while, 老师评讲 ]
// 化繁为简, 先死后活
int i = 1;
int endNum = 100;
while( i <= endNum) {
if( i % 3 == 0) {
System.out.println("i=" + i);
}
i++;//变量自增
}
// 第2题：打印40―200之间所有的偶数 [使用while, 课后练习]
// 化繁为简, 先死后活(利于思考)
//
System.out.println("========");
int j = 40; //变量初始化
while ( j <= 200) {
//判断
if( j % 2 == 0) {
System.out.println("j=" + j);
}
j++;//循环变量的迭代
}
}
}
11.do while循环
- 基本语法
循环变量初始化;
do{
循环体(语句);
循环变量迭代;
}while(循环条件);
- 说明:
- do while 是关键字
- 也有循环四要素, 只是位置不一样
- 先执行，再判断，也就是说，一定会至少执行一次
- 最后有一个分号;
- while 和do…while 区别举例: 要账
- 流程图
- 内存分析
- 注意事项和细节说明
(1)循环条件是返回一个布尔值的表达式
(2) do…while 循环是先执行，再判断， 因此它至少执行一次 - 课堂练习题】
(1) 打印1—100 [学生做]
(2) 计算1—100 的和[学生做]
(3) 统计1—200 之间能被5 整除但不能被3 整除的个数(DoWhileExercise01.java)
(4)如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为止[System.out.println(“老韩问：还钱吗？y/n”)] do…while … DoWhileExercise02.java
//第1,2题
public static void main(String[] args) {
int i = 1;
int sum =0;
do{
System.out.println(i );
sum += i;
i ++;
}
while(i <= 100);
System.out.println(sum);
}
}
//第3题
public class DoWhileExercise01 {
//编写一个main方法
public static void main(String[] args) {
//统计1---200之间能被5整除但不能被3整除的个数
//化繁为简
//(1) 使用do-while输出 1-200
//(2) 过滤 能被5整除但不能被3整除的数 %
//(3) 统计满足条件的个数 int count = 0;
//先死后活
//(1) 范围的值 1-200 你可以做出变量
//(2) 能被5整除但不能被3整除的 , 5 和 3 可以改成变量
int i = 1;
int count = 0; //统计满足条件的个数
do {
if( i % 5 == 0 && i % 3 != 0 ) {
System.out.println("i=" + i);
count++; //计数的count要放在这
}
i++;
}while(i <= 200);
System.out.println("count=" + count);
}
}
//第4题
import java.util.Scanner;
public class DoWhileExercise02 {
public static void main(String[] args) {
//如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为
//[System.out.println("老韩问：还钱吗？y/n")] do...while ..
//
//化繁为简
//(1) 不停的问还钱吗?
//(2) 使用char answer 接收回答, 定义一个Scanner对象
//(3) 在do-while 的while 判断如果是 y 就不在循环
Scanner myScanner = new Scanner(System.in);
char answer = ' ';
do {
System.out.println("老韩使出五连鞭~");
System.out.println("老韩问：还钱吗？y/n");
answer = myScanner.next().charAt(0);
System.out.println("他的回答是" + answer);
}while(answer != 'y');//判断条件很关键
System.out.println("李三还钱了");
}
}
12.多重循环控制
- 介绍
- 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while 均可以作为外层循环和内层循环。
【建议一般使用两层，最多不要超过3 层, 否则，代码的可读性很差】 - 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环[听不懂，走案例]。
- 设外层循环次数为m 次，内层为n 次，则内层循环体实际上需要执行m*n 次。
-
多重循环执行步骤分析
-
应用实例
（1） 统计3 个班成绩情况，每个班有5 名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
（2） 统计三个班及格人数，每个班有5 名同学。
import java.util.Scanner;
public class MulForExercise01 {
//编写一个main方法
public static void main(String[] args) {
//统计3个班成绩情况，每个班有5名同学，
//求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
//统计三个班及格人数，每个班有5名同学。
//
//思路分析:
//化繁为简
//(1) 先计算一个班 , 5个学生的成绩和平均分 , 使用for
//1.1 创建 Scanner 对象然后，接收用户输入
//1.2 得到该班级的平均分 , 定义一个 doubel sum 把该班级5个学生的成绩累积
//(2) 统计3个班(每个班5个学生) 平均分
//(3) 所有班级的平均分
//3.1 定义一个变量，double totalScore 累积所有学生的成绩
//3.2 当多重循环结束后，totalScore / (3 * 5)
//(4) 统计三个班及格人数
//4.1 定义变量 int passNum = 0; 当有一个学生成绩>=60, passNum++
//4.2 如果 >= 60 passNum++
//(5) 可以优化[效率，可读性, 结构]
//创建 Scanner 对象
Scanner myScanner = new Scanner(System.in);
double totalScore = 0; //累积所有学生的成绩
int passNum = 0;//累积 及格人数
int classNum = 3; //班级个数
int stuNum = 5;//学生个数
for( int i = 1; i <= classNum; i++) {//i 表示班级
double sum = 0; //一个班级的总分
for( int j = 1; j <= stuNum; j++) {//j 表示学生
System.out.println("请数第"+i+"个班的第"+j+"个学生的成绩");
double score = myScanner.nextDouble();
//当有一个学生成绩>=60, passNum++
if(score >= 60) {
passNum++;
}
sum += score; //累积
System.out.println("成绩为" + score);
}
//因为sum 是 5个学生的总成绩
System.out.println("sum=" + sum + " 平均分=" + (sum / stuNum));
//把 sum 累积到 totalScore
totalScore += sum;
}
System.out.println("三个班总分="+ totalScore
+ " 平均分=" + totalScore / (classNum*stuNum));
System.out.println("及格人数=" + passNum);
}
}
- 经典的打印金字塔
使用for 循环完成下面的案例
请编写一个程序，可以接收一个整数,表示层数（totalLevel），打印出金字塔。(Stars.java) [化繁为简, 先死后活]
public class Stars {
//编写一个main方法
public static void main(String[] args) {
/*
*
* *
* *
********
思路分析
化繁为简
1. 先打印一个矩形
*****
*****
*****
*****
***** */
for(int i = 1; i <= 5 ;i++){
System.out.println("*****");
}
/* 2. 打印半个金字塔
* //第1层 有 1个*
** //第2层 有 2个*
*** //第3层 有 3个*
**** //第4层 有 4个*
***** //第5层 有 5个* */
for(int i = 1; i <= 5 ;i++){ //i表示层数
//控制打印每层*的个数
for(int j = 1;j <= i; j++){ //i=1 进入循环体,j=1,输出一个*后j++,j=2,退出循环体.
//i++,i=2,进入循环体,j=1,输出一个*后j++,j=2,再输出一个*后j++,j=3,退出循环体.
System.out.print("*");
}
//每打印完一层的*后就换行，pirntln本身就会换行
System.out.println(" ");
}
/* 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)个空格 */
for(int i = 1; i <= 5; i++) { //i 表示层数
//在输出*之前，还有输出 对应空格 = 总层数-当前层
for(int k = 1; k <= 5 - i; k++ ) {
System.out.print(" ");
}
//控制打印每层的*个数
for(int j = 1;j <= 2 * i - 1;j++) {
System.out.print("*");
}
//每打印完一层的*后，就换行 println本身会换行
System.out.println("");
}
/* 4. 打印空心的金字塔 [最难的]
* //第1层 有 1个* 当前行的第一个位置是*,最后一个位置也是*
* * //第2层 有 2个* 当前行的第一个位置是*,最后一个位置也是*
* * //第3层 有 2个* 当前行的第一个位置是*,最后一个位置也是*
* * //第4层 有 2个* 当前行的第一个位置是*,最后一个位置也是*
********* //第5层 有 9个* 全部输出* */
for(int i = 1; i <= 5; i++) { //i 表示层数
//在输出*之前，还有输出 对应空格 = 总层数-当前层
for(int k = 1; k <= 5 - i; k++ ) {
System.out.print(" ");
}
//控制打印每层的*个数
for(int j = 1;j <= 2 * i - 1;j++) {
//当前行的第一个位置是*,最后一个位置也是*, 最后一层全部 *
if(j == 1 || j == 2 * i - 1 || i == 5) {
System.out.print("*");
} else { //其他情况输出空格
System.out.print(" ");
}
}
//每打印完一层的*后，就换行 println本身会换行
System.out.println("");
}
/* 先死后活
5 层数做成变量 int totalLevel = 5;
//小伙伴 技术到位，就可以很快的把代码写出
*/
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 <= 2 * i - 1;j++) {
//当前行的第一个位置是*,最后一个位置也是*, 最后一层全部 *
if(j == 1 || j == 2 * i - 1 || i == totalLevel) {
System.out.print("*");
} else { //其他情况输出空格
System.out.print(" ");
}
}
//每打印完一层的*后，就换行 println本身会换行
System.out.println("");
}
}
}
13.跳转控制语句-break
- 看下面一个需求
随机生成1-100 的一个数，直到生成了97 这个数，看看你一共用了几次?
提示使用(int)(Math.random() * 100) + 1
思路分析：
循环，但是循环的次数不知道. -> break ,当某个条件满足时，终止循环
通过该需求可以说明其它流程控制的必要性，比如break
- 基本介绍：
break 语句用于终止某个语句块的执行，一般使用在switch 或者循环[for , while , do-while]中
- 基本语法：
{ ……
break;
……
} - 以while 使用break 为例,画出示意图
- 快速入门
- 注意事项和细节说明
上图代码输出 i=0;i=1。
- 课堂练习
- 1-100 以内的数求和，求出当和第一次大于20 的当前数【for + break】
法1：
public class BreakExercise {
//编写一个main方法
public static void main(String[] args) {
//1-100以内的数求和，求出 当和 第一次大于20的当前数 【for + break】
//思路分析
//1. 循环 1-100, 求和 sum
//2. 当 sum > 20 时，记录下当前数，然后break
//3. 在for循环外部，定义变量 n , 把当前i 赋给 n
int sum = 0; //累积和
//注意i 的作用范围在 for{}
int n = 0;
for(int i = 1; i <= 100; i++) {
sum += i;//累积
if(sum > 20) {
System.out.println("和>20时候 当前数i=" + i);
n = i;
break;
}
}
System.out.println("和>20时候 当前数=" + n);
}
}
法2 ：把 i 定义在for循环外边 ，后边还可以继续使用i
public class zuoye{
public static void main(String[] args){
int sum = 0;
int i = 0;
for( ; i <= 100; i++){
sum += i;
if (sum >=20){
System.out.println(i);
break;
}
}
System.out.println(i);
}
}
- 实现登录验证，有3 次机会，如果用户名为"丁真" ,密码"666"提示登录成功，否则提示还有几次机会，请使用for+break完成BreakExercise02.java
import java.util.Scanner;
public class BreakExercise02 {
//编写一个main方法
public static void main(String[] args) {
//实现登录验证，有3次机会，如果用户名为"丁真" ,密码"666"提示登录成功，
//否则提示还有几次机会，请使用for+break完成
//
// 思路分析
// 1. 创建Scanner对象接收用户输入
// 2. 定义 String name ; String passwd; 保存用户名和密码
// 3. 最多循环3次[登录3次]，如果 满足条件就提前退出
// 4. 定义一般变量 int chance 记录还有几次登录机会
//
// 代码实现
Scanner myScanner = new Scanner(System.in);
String name = "";
String passwd = "";
int chance = 3; //登录一次 ，就减少一次
for( int i = 1; i <= 3; i++) {//3次登录机会
System.out.println("请输入名字");
name = myScanner.next();
System.out.println("请输入密码");
passwd = myScanner.next();
//比较输入的名字和密码是否正确
//补充说明字符串 的内容 比较 使用的 方法 equals
if("丁真".equals(name) && "666".equals(passwd)) {
System.out.println("恭喜你，登录成功~");
break;
}
//登录的机会就减少一次
chance--;
System.out.println("你还有" + chance + "次登录机会");
}
}
}
14.跳转控制语句-continue
- 基本介绍：
- continue 语句用于结束本次循环，继续执行下一次循环。
- continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环, 这个和前面的标签的
使用的规则一样.
- 基本语法：
{ ……
continue;
……
} - 以while 使用continue 为例,画出示意图
- 快速入门案例
- 细节案例分析和说明
public class ContinueDetail {
//编写一个main方法
public static void main(String[] args) {
label1:
for(int j = 0; j < 2; j++){
label2:
for(int i = 0; i < 10; i++){
if(i == 2){
//看看分别输出什么值，并分析
//continue ; //等价于 continue label2 输出2遍i=0 1 3 4 5 6 7 8 9
//continue label2;//等价 continue;
continue label1; //输出 2次[0,1]
}
System.out.println("i = " + i);
}
}
}
}
15.跳转控制语句-return
return 使用在方法，表示跳出所在的方法，在讲解方法的时候，会详细的介绍，这里我们简单的提一下。注意：如果return 写在main 方法，退出程序…Return01.java
public class Return01 {
//编写一个main方法
public static void main(String[] args) {
for(int i=1;i<=5;i++){
if(i==3) {
System.out.println("韩顺平教育 "+i);
return; //当return用在方法时，表示跳出方法，如果使用在main,表示退出程序。
//所以这里只输出hello hello 韩顺平3就结束程序
//如果return换成break，输出的是hello hello 韩顺平3 go
//如果return换成continue，输出的是hello hello 韩顺平3 hello hello go
}
System.out.println("Hello World!");
}
System.out.println("go on..");
}
}
16.本章作业（1-9题）
public class Homework01 {
//编写一个main方法
public static void main(String[] args) {
/*
某人有100,000元,每经过一次路口，需要交费,规则如下:
1) 当现金>50000时,每次交5%
2) 当现金<=50000时,每次交1000
编程计算该人可以经过多少次路口, 要求: 使用 while + break方式完成
思路分析
1. 定义 double money 保存 100000
2. 根据题的要求，我们分析出来有三种情况
money > 50000
money >=1000 && money <= 50000
money < 1000
3. 使用多分支 if-elseif-else
4. while+break[money < 1000], 同时使用一个变量count来保存通过路口
代码实现
*/
double money = 100000;//还有多少钱
int count = 0; //累积过的路口
while(true) { //无限循环
if(money > 50000) { //过路口
//money = money - money * 0.05;可以，太啰嗦
money *= 0.95; //过了这个路口后，还有这么多钱
count++;
} else if(money >=1000) {
money -= 1000;
count++;
} else { //钱不够1000
break;
}
}
System.out.println("100000 可以过 " + count + " 路口..");
}
}
法2
public class zuoye{
public static void main(String[] args){
double money = 100000;
int y = 0; //y表示>50000时可以过多少路口
int x = 0;//x表示<=50000时可以过多少路口
while(money > 50000){
money = money * 0.95 ;
y++;
System.out.println(y);
}
while(money <= 50000 && money > 1000){
money = money - 1000 ;
x ++;
System.out.println(x);
}
}
}
方法3：
public class zuoye {
//编写一个main方法
public static void main(String[] args) {
double money = 100000;//还有多少钱
int count = 0; //累积过的路口
for( ; money > 50000;money *= 0.95 ) { //无限循环
count++;
}
for( ;money >=1000 && money <= 50000;money -= 1000 ) { //无限循环
count++;
}
System.out.println("100000 可以过 " + count + " 路口..");
}
}
题目2-4
//第2题
import java.util.Scanner;
public class zuoye{
public static void main(String[] args){
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入一个整数");
int num = myScanner.nextInt();
if(num > 0){
System.out.println("您输入数字的范围为>0");
}else if(num < 0){
System.out.println("您输入数字的范围为<0");
}else{
System.out.println("您输入数字的范围为=0");
}
}
}
第4题
import java.util.Scanner;
public class zuoye{
public static void main(String[] args){
/*
4. 判断一个整数是否是水仙花数，所谓水仙花数是指一个3位数，
其各个位上数字立方和等于其本身。
例如： 153 = 1*1*1 + 3*3*3 + 5*5*5
思路分析 => 多听. 见多识广..
1. 比如 int n = 153;
2. 先得到 n的百位，十位 ，各位的数字, 使用 if 判断他们的立方和是否相等
3. n的百位 = n / 100
4. n的十位 = n % 100 / 10
5. n的各位 = n % 10
6. 判断即可
*/
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入一个三位数");
int n = myScanner.nextInt();
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 + "是水仙花数");
} else {
System.out.println(n + "不是水仙花数");
}
}
}
第6题
public class Homework06 {
//编写一个main方法
public static void main(String[] args) {
/*
输出1-100之间的不能被5整除的数，每5个一行
思路分析
1. 先输出1-100的所有数
2. 然后过滤输出 不能被5整除的数 i % 5 !=0
3. 每5个一行, 我们使用 int count 统计输出的个数 当 count%5=0就说明
输出了5个，这时，我们输出 一个换行即可控制
代码实现
*/
int count = 0; //统计输出的个数
for(int i = 1; i <= 100; i++) {
if(i % 5 != 0) {
count++;
System.out.print(i + "t");//这样就不换行了
//判断, 每满5个，就输出一个换行..
if(count % 5 == 0) {
System.out.println();
}
}
}
}
}
第7题 法1
public class Homework07 {
//编写一个main方法
public static void main(String[] args) {
//输出小写的a-z以及大写的Z-A
//考察我们对 a-z编码和 for的综合使用
//思路分析
//1. 'b' = 'a' + 1 c = 'a' + 2
//2. 使用for搞定
for(char c1 = 'a'; c1 <= 'z'; c1++) {
System.out.print(c1 +" ");
}
System.out.println("============");
//灵活的使用，编程..
for(char c1 = 'Z'; c1 >= 'A'; c1--) {
System.out.print(c1 +" ");
}
}
}
第7题 法2
public class zuoye{
public static void main(String[] args){
for(int i = 97; i <= 122; i++){
System.out.print((char)i + " ");//强转
}
System.out.print("n");//
for(int j = 90; j >= 65; j--){
System.out.print((char)j+ " ");//强转
}
}
}
第8题
public class Homework08 {
//编写一个main方法
public static void main(String[] args) {
/*
求出1-1/2+1/3-1/4…..1/100的和
思路分析
1. 1-1/2+1/3-1/4…..1/100 = (1/1)-(1/2)+(1/3)-(1/4)...1/100
2. 从上面的分析我们可以看到
(1) 一共有100数 ， 分子为1 , 分母从1-100
(2) 还发现 当分母为奇数时，前面是 +, 当分母是偶数时，前面是-
3. 我们可以使用 for + 判断即可完成
4. 把结果存放到 double sum
5. 这里有一个隐藏的陷阱，要把 公式分子 1 写出1.0 才能得到精确的小数
*/
double sum = 0;
for(int i = 1; i <= 100; i++) {
//判断是奇数还是偶数，然后做不同的处理
if( i % 2 != 0) {//分母为奇数
sum = sum + (1.0/i);
} else { //分母我偶数
sum = sum - (1.0/i);
}
}
System.out.println("sum=" + sum);
}
}
第9题
public class Homework09 {
//编写一个main方法
public static void main(String[] args) {
//求(1)+（1+2）+（1+2+3）+（1+2+3+4）+...+(1+2+3+..+100)的结果
//
//思路分析
//1. 一共有100项相加
//2. 每一项的数字在逐渐增加
//3. 很像一个双层循环
//i 可以表示是第几项,同时也是当前项的最后一个数
//4. 使用 sum 进行累计即可
int sum = 0;
for(int i = 1; i <= 100; i++) {
for(int j = 1;j <= i; j++) {//内层对1-i进行循环
sum += j;
}
}
System.out.println("sum=" + sum);
}
}
最后
以上就是开放毛衣为你收集整理的java学习笔记-(4) 第五章-程序控制结构（完结）的全部内容，希望文章能够帮你解决java学习笔记-(4) 第五章-程序控制结构（完结）所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复