程序流程控制
在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句
1）顺序控制
2）分支控制
3）循环控制
顺序控制
程序从上到下逐行地执行，中间没有任何判断和跳转。
分支控制
if else
让程序有选择地执行：
- 单分支 if
- 双分支 if-else
- 多分支 if-else if -…-else
单分支
//if的快速入门
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("程序继续...");
}
}
双分支
//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("程序继续...");
}
}
多分支
嵌套分支
在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。
建议: 不要超过 3 层 （可读性不好）
switch
switch注意事项和细节讨论
public class SwitchDetail {
//编写一个main方法
public static void main(String[] args) {
//细节1
//表达式数据类型，应和case 后的常量类型一致，
//或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是 int
//细节2
//switch(表达式)中表达式的返回值必须是：
//(byte,short,int,char,enum[枚举],String)
//细节3
//case子句中的值必须是常量(1,'a')或者是常量表达式,而不能是变量
//
//细节4
//default子句是可选的，当没有匹配的case时，执行default
//如果没有default 子句，有没有匹配任何常量，则没有输出
//
//细节5
//break语句用来在执行完一个case分支后使程序跳出switch语句块；
//如果没有写break，程序会顺序执行到switch结尾,除非执行到break
char c = 'b';
char c2 = 'c';
switch(c) {
case 'a' :
System.out.println("ok1");
break;
case 'b' :
System.out.println("ok2");
break;
default :
System.out.println("ok3");
}
System.out.println("退出了switch,继续执行..");
}
}
switch和if的比较
循环控制
代码可以循环的执行.
for循环
基本语法：
相关说明：
- for 关键字，表示循环控制
- for 有四要素: (1)循环变量初始化 (2)循环条件 (3)循环操作 (4)循环变量迭代
- .循环操作 , 这里可以有多条语句，也就是我们要循环执行的代码
- 如果 循环操作(语句) 只有一条语句，可以省略 {}, 建议不要省略
for循环执行流程分析：
for循环注意事项及细节分析：
- 循环条件是返回一个布尔值的表达式
- for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
- 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代 语句，中间用逗号隔开。
for循环练习题：
- 打印 1~100 之间所有是 9 的倍数的整数，统计个数 及总和.[化繁为简,先死后活]
public class ForExercise {
//编写一个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 = 10;
int end = 200;
int t = 5; // 倍数
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);
}
}
- 完成下面的表达式输出
public class ForExercise02 {
//编写一个main方法
public static void main(String[] args) {
//化繁为简
//先死后活
int n = 9;
for( int i = 0; i <= n; i++) {
System.out.println(i + "+" + (n-i) + "=" + n);
}
}
}
while
基本语法：
while 循环执行流程分析：
do while
基本语法：
do…while 循环执行流程分析：
多重循环
介绍:
- 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while,do…while 均可以作为外层循环和内层循环,(建议一般使用两层，最多不要超过 3 层, 否则，代码的可读性很差)
- 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内 层循环，才可结束外层的当次循环，开始下一次的循环[听不懂，走案例]
- 设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。
练习题：
import java.util.Scanner;
public class class1 {
//编写一个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);
}
}
练习题2：打印金字塔
请编写一个程序，可以接收一个整数,表示层数（totalLevel），打印出金字塔。(Stars.java) [化繁为简, 先死后活]
public class Stars {
//编写一个main方法
public static void main(String[] args) {
/*
*
* *
* *
********
思路分析
化繁为简
1. 先打印一个矩形
*****
*****
*****
*****
*****
2. 打印半个金字塔
* //第1层 有 1个*
** //第2层 有 2个*
*** //第3层 有 3个*
**** //第4层 有 4个*
***** //第5层 有 5个*
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)个空格
4. 打印空心的金字塔 [最难的]
* //第1层 有 1个* 当前行的第一个位置是*,最后一个位置也是*
* * //第2层 有 2个* 当前行的第一个位置是*,最后一个位置也是*
* * //第3层 有 2个* 当前行的第一个位置是*,最后一个位置也是*
* * //第4层 有 2个* 当前行的第一个位置是*,最后一个位置也是*
********* //第5层 有 9个* 全部输出*
先死后活
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("");
}
}
}
break
基本介绍：
break 语句用于终止某个语句块的执行，一般使用在 switch 或者循环[for , while , do-while]中
基本语法：
{ ……
break;
……
}
跳转控制语句-break
label
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
//continue label2;//等价 continue;
continue label1; //输出 2次[0,1]
}
System.out.println("i = " + i);//输出2次[0,1,3,4,5,6,7,8,9]
}
}
}
}
跳转控制语句-return
return使用在方法，表示跳出所在的方法，在讲解方法的时候，会详细的介绍。
如果return写在main方法，会退出程序。
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,表示退出程序
}
System.out.println("Hello World!");
}
System.out.println("go on..");
}
}
924
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
