第4章程序控制结构

介绍

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

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

顺序控制结构

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

举例和注意事项

Java中定义成员变量时采用合法的前向引用。如：

public class Test{
int num1 = 12;
int num2 = num1 + 2;
}
//错误形式如下:
public class Test{
int num2 = num1 + 2; 
int num1 = 12;
}

图示：中间没有判断，直接顺序走即可

分支控制结构

介绍：让程序有选择的进行执行，分支控制有三种
分类：1.单分支 2.双分支 3.多分支

单分支

基本语法

if(条件表达式) {
    执行代码块;(可以有多条语句.)
}

说明：当条件表达式为ture时，就会执行{}中的代码。如果为false就不执行。

特别说明：如果{}中只有一条语句，则可以不用{}，但是建议写上{}

案例说明If01.java

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

        scanner.close();//记住关闭接收终端
    }
}

单分支流程图

、

双分支

基本语法

if(条件表达式) {
    执行代码块1;
}else {
    执行代码块2;
}

说明：当条件表达式成立，即执行代码块1，否则执行代码块2。如果执行代码块只有一条语句，则{}可以省略，否则，不能省略。

案例演示lf02.java

//编写一个程序，可以输入人的年龄如果该同志的年龄大于18岁则输出"你年龄大于18，要对自己的行为负责，送入监狱。"否则,输出"你的年龄不大这次放过你了。"
package chapter05;
import java.util.Scanner;
public class If02 {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入年龄：");//新建键盘接收

        int age = scanner.nextInt();//保存年龄int变量

        if (age > 18) {//进行if判断
            System.out.println("你年龄大于18，要对自己的行为负责，送入监狱。");
        }else {//双分支
            System.out.println("你的年龄不大这次放过你了。");
        }
    
        System.out.println("程序继续……");
        scanner.close();
        
    }
}

双分支流程图

练习题1-单双

嵌套

答案：韩顺平教育~

练习

//lfExercise01.java
//2.编写程序，声明2个double型变量并赋值。判断第1个数大于10.0，且第2个数小于20.0，打印两数之和
//3.[课后自己练]定义两个变量int，判断两者的和，是否能被3又能被5整除，打印提示信息
//4.判断一个年份是否是闰年，闰年的条件是符合下面二者之一:(1)年份能被4整除，但不能被100整除;(2)能被400整除
int a = 12;
int b = 34;
if ((a+b) % 3 == 0 && (a + b) % 5 == 0) {
 System.out.println("和能被3和5整除");
}

int years = 1;
if((years % 4 ==0 && years % 100 != 0) 
   || years % 400 == 0) {
    System.out.println("闰年");
}

多分支

基本语法

if(条件表达式1) {
    执行代码块1;
}else if(条件表达式2) {
    执行代码块2;
}
......
else{
    执行代码块n;
}
//特别说明:(1)多分支 可以没有else,如果所以的条件表达式都不成立，则一个执行入口都没有 (2)如果有else,如果所有的条件表达式都不成立，则默认执行else代码块

说明

1.当条件表达式1成立时，即执行代码块1；
2.如果表达式1不成立，才去判断表达式2是否成立；
3.如果表达式2成立，就执行代码块2；
4.以此类推，如果所有的表达式都不成立；
5.则执行else的代码块，注意，只能有一个执行入口。
图示

练习题2-多

案例1

//案例lf03.java
/*
输入保国同志的芝麻信用分:
如果:
1.信用分为100分时，输出信用极好;
2.信用分为(30, 99]时，输出信用优秀;
3.信用分为[60,80]时，输出信用一般;
4.其它情况，输出信用不及格
5.请从键盘输入保国的芝麻信用分，并加以判断
*/
package chapter05;
import java.util.Scanner;
public class If03 {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);//接收数据

        System.out.println("请输入保国同志的芝麻信用分：");
        int grade = scanner.nextInt();//保存变量

        if (grade >=1 && grade <= 100){
        //限定范围-->此处还可以进行使用异常处理机制对输入的数据不是整数，而是hello进行处理！！！

            if (grade == 100) {//多分支判断
                System.out.println("信用极好");
            } else if (grade > 80 && grade <= 99) {
                System.out.println("信用优秀");
            } else if (grade >= 60 && grade <= 80) {
                System.out.println("信用一般");
            } else {
                System.out.println("信用不及格");
            }

        } else {
            System.out.println("输入数据不合法，请重新输入！");
        }

        scanner.close();//接收关闭
        
    }
}

案例2

//代码，看看输出什么?
boolean b = true;
if(b = false) {// 如果写成if(b= false)能编译通过吗?如果能，结果是?-->因为if判断的括号里是false，判断结果就是错，括号里是true，结果就是对(此处为赋值)
System.out.println("a");
} else if(b) {
System.out.println("b");
} else if(!b) {
System.out.println("c");
} else {
System.out.println("d");
}

嵌套分支

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

基本语法

if() {
    if() {
        //if-else...
    }else{
        //if-else...
    }
}

案例1

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

package chapter05;

import java.util.Scanner;

public class NestedIf {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        double score = scanner.nextDouble();
        if (score > 8.0) {

            System.out.println("请输入性别：");
            char gender = scanner.next().charAt(0);//该处是如何将字符串转成一个字符！
            if (gender == '男') {
                System.out.println("恭喜您进入男子组决赛！");
            } else if (gender == '女'){
                System.out.println("恭喜您进入女子组决赛！");
            } else {
                System.out.println("输入类型有误，请重新输入！");
            }

        } else {
            System.out.println("很遗憾您被淘汰！");
        }

        scanner.close();

    }
}

switch分支

基本语法

switch(表达式) {
    case 常量1: //-->翻译就是当...
        语句块1;
        break;
    case 常量2:
        语句块2:
        break;
    ...
    case 常量n:
        语句块n; 
        break;
    default:
    default语句块;
        break;
}

switch说明

switch关键字，表示swtich分支
有一个表达式就对应一个具体的返回值
case 常量1：当表达式的值等于常量1，就执行语句块1
break：表示退出swtich
如果和 case 常量1匹配，就执行语句块1，如果没有匹配，就继续匹配 case 常量2
如果一个都没有匹配上，执行default

示意图

如果没有break会存在case穿透，执行完所有语句块！

快速入门

案例Switch01.java

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

import java.util.Scanner;

public class Switch01 {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符(a,b,c,d,e,f,g)");
        char input = scanner.next().charAt(0);
        //在Java中只要有值返回，就是一个表达式
        switch (input) {
            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后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int

char C = 'a';
switch(c) {
    case 'a'://正确
        System.out.println("ok1");
    break;
    case "hello"://错误
        System.out.println("ok2");
    break;
    case 20://正确，可以进行转换
        System.out.println("ok2");
    break;
    default:
        System.out.println("ok3");
}

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

double d = 1.1;
switch(d){//错误，不能使用浮点数，会造成精度下降
    case 1.1://错误
        System.out.println("ok2");
    break;
}

case子句中的值必须是常量或者常量表达式（1，‘a’），而不能是变量

char d = 'a';
switch(d){
    case 'a'://正确，只能是常量或者常量表达式
        System.out.println("ok2");
    break;
    case d://错误，不能是变量
        System.out.println("ok3");
    break;
}

default子句是可选的，当没有匹配的case时，默认执行default
break语用来在执行完一个case分支后使程序跳出switch语句块，如果没有写break，程序会顺序执行到switch结尾，除非遇到break

练习题3-s

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冬季（提示使用穿透）

package chapter05;

import java.util.Scanner;

public class SwitchExercise {
    public static void main(String[] args) {
        //1. 使用switch把小写类型的char型转为大写（键盘输入）。只转换a,b, c, d, e。其它的输出"other"。
        /*
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个小写字母：");
        char c = scanner.next().charAt(0);
        switch (c) {
            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");
        }
        System.out.println("完成操作！");*/

        /*2.学生成绩大于60分的，输出"合格"。低于60分的，输出"不合格"。（注：输入的成绩不能大于100），提示 成绩/60
        思路分析：
        0.这道题，可以使用分支来完成，但是要求使用switch这里我们需要进行一个转换，编程思路
        1.如果成绩在[60,100] ，(int)(成绩/60) = 1
        2.如果成绩在[0,60) , (int)(成绩/60) = 0
         */
        /*
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学生成绩：");
        double score = scanner.nextDouble();
        if (score>=0 && score<= 100) {

            switch ((int)(score / 60)) {
                case 0:
                    System.out.println("不合格");
                    break;
                case 1:
                    System.out.println("合格");
                    break;
            }
        } else {
            System.out.println("输入成绩有误，请重新输入");
        }
         */

        //3. 根据用户指定月份，打印该月份所属的季节。3,4,5 春季；6,7,8夏季；9,10,11秋季；12,1,2冬季（提示使用穿透）
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入月份(1-12)：");
        int month = scanner.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("输入有误，请重新输入");
        }
        scanner.close();
    }
}

switch和if的比较

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

循环控制结构

for循环

基本介绍：听其名而知其意，就是让你的代码可以循环的执行。

实际需求For01.java

编写个程序可以打印10句”你好，世界！”。请大家想想怎么做？

package chapter05;
public class For01 {
    public static void main(String[] args) {
        //使用for循环控制
        for(int i = 1; i <= 10; i++) {
        System.out.println("你好，世界！" + i);
        }
    }
}

基本语法

for(循环变量初始化;循环条件;循环变量迭代){
    循环操作(可以多条语句);
}

语法说明

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

2.for有四要素：(1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
3.循环操作，这里可以有多条语句，也就是我们要循环执行的代码
4.如果循环操作（语句）只有一条语句，可以省略{}，但建议不要省略
图示

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

//2.(;判断条件;)
int i = 1;//循环变量初始化
for(; i <= 10 ;) {
    System.out.println("hello,world!");
    i++ ;
}   
System.out.println("i=" + i);//11
//补充
int j = 1;
for(;;) { //表示一个无限循环,死循环
    System.out.println("ok~" + (j++));
}

//3-4.内存分析法
int count = 3;
for (int i = 0,j = 0; i < count; i++,j += 2) {
    System.out.println("i=" + i + "j=" + j);
}

练习题1-f

ForExercise.java

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

package chapter05;

public class ForExercise {
    public static void main(String[] args) {
        //打印1~100之间所有是9的倍数的整数，统计个数及总和。
        //1.化繁为简：即将复杂的需求，拆解为简单的需求，逐步完成
        //2.先死后活：先考虑固定的值，然后在转成灵活变化的值
        //思路分析：
        /*
        
        (1)完成 输出1-100的值
        (2)在输出的过程中，进行过滤，只输出9的倍数
        (3)统计个数 定义一个变量 int count = 0;当 条件满足时 count++;
        (4)进行求和 ，定义一个变量int sum = 0;当条件满足时 sum += i;
         */
        /*
        先死后活：
        (1)为了适应更好的需求，把范围开始的值和结束的值，进行变量
        (2)定义的开始的值 int start = 1;
        (3)定义的结束的值 int end =100;
        (4)还可以更进一步 将倍数进行切换 int t = 9;
         */
        int count = 0;//统计9的个数 变量进行统计
        int sum = 0;
        //int start = 1;
        //int end = 100;
        //int t = 9;
        for (int i = 1; i <=100; i++ ){//-->for (int i = start; i <= end; i++)
            if (i % 9 == 0){//if (i % t == 0)
                System.out.println("i=" + i);
                count++;//此处只能放在if内才能终止循环！
                sum += i;
            }
        }
        System.out.println("count=" + count);
        System.out.println("sum=" + sum);
    }
}

完成下面的表达式输出ForExercise02.java
0 + 5 = 5
1 + 4 = 5
2 + 3 = 5
3 + 2 = 5
5 + 0 = 5

package chapter05;

public class ForExercise02 {
    public static void main(String[] args) {
      /*
        0 + 5 = 5
        1 + 4 = 5
        2 + 3 = 5
        3 + 2 = 5
        5 + 0 = 5
       */
        //思路分析
        /*
        化繁为简
        (1)先输出 0-5
        (2)观察最后结果都是等于5 所哟一在前面我们就可以用结果的5去减去前面的i
         先死后活
        (1)可以将5替换成变量 n, int n = 5
        (2)直接替换-->变成
        int n = 5
        for (int i = 0; i <= n; i++) {
        System.out.println(i + "+" + (n - i) + "=n");
        }

         */
        for (int sum1 = 0; sum1 <= 5; sum1++){
            System.out.println(sum1 + "+" + (5 - sum1) + "=5");
        }
    }
}

while循环

基本语法

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

说明

1.while循环也有四要素。
2.只是四要素放的位置和for循环结构的位置不一样。
流程图：只是退出while循环，不是退出程序，如果while下面还有代码，程序会继续执行
注意事项和细节说明
1.循环条件是返回一个布尔值的表达式（true可以用IDEA的debug进行步骤查看）

2.while循环是先判断再执行语句

练习题2-w

WhileExercise.java
1.打印1-100之间所有能被3整除的数（使用while）
2.打印40 200之间所有的偶数（使用while）

package chapter05;

public class WhileExercise {
    public static void main(String[] args) {

        //化繁为简，先死后活！
        //1.打印1-100之间所有能被3整除的数（使用while）
        int i = 1;
        while (i <= 100) {
            if (i % 3 == 0) {
                System.out.println("i=" + i);
            }
            i++;//变量自增应该放在外面
        }

        //2.打印40-200之间所有的偶数（使用while）
        int d = 40;
        while (d <= 200){
            if (d % 2 == 0) {//进行筛选
                System.out.println("d=" + d);
            }
            d++;//循环变量迭代-->网友提示：可以改成j += 2;但是感觉不是太好，一则没有遍历完该范围内所有的数，二则不便于后续变活操作，如若出现需要除以3的倍数时， +=2会导致遍历不玩所有的值
        }
    }
}

do…while循环

基本语法

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

说明

1.do while是关键字

2.也有循环四要素，只是位置不一样

3.先执行，再判断，也就是说，一定会执行一次(至少会执行一次)

4.最后有一个分号;

5.while和do.while区别举例：要账~哈哈哈哈哈哈笑死
流程图：退出do…while循环，再进行后续操作

package chapter05;

public class DoWhile01 {
    public static void main(String[] args) {
        //输出十句你好世界
        int i = 1;//循环变量初始化
        do {
            System.out.println("你好，世界！");
            i++;//一定要循环变量迭代，不然就是一个死循环
        }while (i <= 10);//循环条件判断
        System.out.println("退出do..while,继续执行程序");
    }
}

注意事项和细节说明
1.循环条件是返回一个布尔值的表达式
2.do…while循环是先执行，再判断，因此它至少执行一次

练习题3-dw

打印1-100 [学生做]
计算1-100的和[学生做]

统计1-200之间能被5整除但不能被3整除的个数DoWhileExercise01.java

package chapter05;

public class DoWhileExercise_Stu {
    public static void main(String[] args) {
        //1.打印1-100
        int i = 1;
        do {
            System.out.println("i=" + i);
            i++;
        }while (i <= 100);

        //2.计算1-100的和
        int i2 = 1;
        int sum =0;
        do {
            sum += i2;
            i2++;
        }while (i2 <= 100);
        System.out.println("sum=" + sum);

        //3.能被3但不能被5整除的数的个数
        int a = 1;
        int time = 0;
        do {
            if(a % 5 == 0 && a % 3 != 0){
                time++;
            }
            a++;
        }while (a <= 200);
        System.out.println("count=" + time);

    }
}//自己做的

//统计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++;
    }
    i++ ;
}while (i <= 200);
System.out.println("count=" + count);

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

package chapter05;
import java.util.Scanner;

   public class DoWhileExercise02 {
       public static void main(String[] args) {
           //如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为止 [System.out.println("老韩问：还钱吗？y/n")]
           //分析：化繁为简
           //1.不停的问还钱？
           //2.使用一个char answer接收，定义一个scanner对象
           //3.在do-while 的while判断如果是y就不在循环
           Scanner scanner = new Scanner(System.in);
           char answer = ' ';
           do {
               System.out.println("老韩使出五连鞭！");
               System.out.println("老韩问：还钱吗？y/n");
               answer = scanner.next().charAt(0);
               System.out.println("他的回答是" + answer);
           }while (answer != 'y');//判断条件很关键
           System.out.println("李三还钱了！");
       }
   }

多重循环控制(重难点)

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

for(int i = 1; i <= 7; i++) {//第一层循环 7次
    for(int j= 1;j <= 2; j++) {//第二层循环 2次
        System.out.println(" ok~~");//7 * 2 = 14
    }
}
//多重循环执行步骤分析:
//请分析下面的多重循环的执行步骤，写出输出，采用内存分析法
//双层for循环

for(int i = 0; i < 2; i++) {
    for(int j = 0; j < 3; j++) {
        System.out.println("i=" + i + " j=" + j);
    }
}
/*
  i=0j=0
  i=0j=1
  i=0j=2
  i=1j=0
  i=1j=1
  i=1j=2
  */

练习题4-多

MulForExercise01.java

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

统计三个班及格人数，每个班有5名同学

package chapter05;

import java.util.Scanner;

public class MulForExercise01 {
    public static void main(String[] args) {
        //1.统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分（学生的成绩从键盘输入）
        //2.统计三个班及格人数，每个班有5名同学
        /*
        思路分析：
        化繁为简
        (1)先计算一个班，5个同学的成绩，使用for循环
        1.1 创建 Scanner对象 然后，接收用户的键入
        1.2得到该班级平均分，定义一个 double 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 = new Scanner(System.in);
        double totalScore = 0;//累计所有学生的成绩
        int passNum = 0;//累计及格人数
        for (int i = 1; i <= 3; i++) {//i 表示班级
            double sum = 0;
            for (int j = 1; j <= 5; j++) {//j 表示学生
                System.out.println("请输入第" + i +"个班的第" + j + "个学生的成绩：");
                double score = scanner.nextDouble();
                //当有一个学生成绩 >= 60，passNum++
                if (score >= 60) {
                    passNum++;
                }
                sum += score;//累计总分
                System.out.println("成绩为" + score);
            }
            //sum 是 5 个学生的总成绩
            System.out.println("sum=" + sum + "平均分=" + (sum / 5));
            // 把sum 积累到totalScore
            totalScore += sum;

        }
        System.out.println("三个班总分=" + totalScore + "平均分=" + (totalScore / 15));
        System.out.println("及格人数=" + passNum);
    }
}

package chapter05;//自己梳理了一遍

import java.util.Scanner;

public class MulForExercise01 {
    public static void main(String[] args) {
        //1.统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分（学生的成绩从键盘输入）
        //2.统计三个班及格人数，每个班有5名同学
        /*
        1.先输出一个班学生五个成绩数量 此处需要for循环
        1.1进行总分统计和平均分计算 int sum =
        2.统计三个班的成绩 此处需要进行多重循环 把一个班的循环放在内循环体，然后外循环也进行三次
        2.1for 循环次数小于3次 修改输出内容
        3.统计所有班的成绩进行平均分计算 int totalScore = 接收
        4.统计三个班及格人数 ，每个班五个人
        4.1要进行条件进行判断 if(score >= 60){
        passNum++
        }
         */
        double sum = 0;//班级总成绩初始化
        double totalScore = 0;//年级总成绩初始化
        int passNum = 0;//及格人数初始化
        for(int t = 1; t <= 3; t++) {
            for (int i = 1; i <= 5; i++) {
                Scanner scanner = new Scanner(System.in);//键入班级同学成绩
                System.out.println("请输入" + t + "班第" + i + "个学生的成绩：");//提示信息
                double score = scanner.nextDouble();//接收学生成绩
                sum += score;//班级总成绩累计
                if(score >= 60){//及格人数进行筛选
                    passNum++;
                }
            }
            System.out.println("第" + t + "班总成绩是=" + sum + 
                               "平均分是=" + (sum / 5));//总成绩输出和平均分输出
            totalScore += sum++;//年级总成绩积累
        }
        System.out.println("所有班总成绩=" + totalScore + 
                           "平均分是=" + (totalScore / 15));//年纪总成绩输出和平均分输出
        System.out.println("所有班及格人数=" + passNum);//及格人数进行筛选
    }
}

打印出九九乘法表（自己做）
```
//待定
```

打印经典的金字塔Stars.java

要求：1.使用for循环完成，可以接收一个整数，表示层数（totalLevel），打印出金字塔
提示：1.完成思路，可以先从矩形开始打；2.代码实现；3.同学使用while来实现

升级：空心金字塔–>空心菱形在这里插入图片描述

package chapter05;

public class Stars {
    public static void main(String[] args) {
        //化繁为简
        /*
        1.先打印一个矩形
        *****
        *****
        *****
        *****
        *****
        2.打印半个金字塔
        *     //第1层 1个*
        **    //第2层 2个*
        ***   //第3层 3个*
        ****  //第4层 4个*
        ***** //第5层 5个*
        3.打印整个金字塔
        *     //第1层 1个*  2*层数 - 1   4个空格(总层数 - 当前层)
       ***    //第2层 3个*  2 * 2 - 1    3个空格
      *****   //第3层 5个*  2 * 3 - 1    2个层数
     *******  //第4层 7个*  2 * 4 - 1    1个层数
    ********* //第5层 9个*  2 * 5 - 1    0个层数
        4.打印空心金字塔
        *     //第1层 1个*  2*层数 - 1   当前行的第一个位置是*，最后一个位置也是*
       * *    //第2层 2个*  2 * 2 - 1    当前行的第一个位置是*，最后一个位置也是*
      *   *   //第3层 2个*  2 * 3 - 1    当前行的第一个位置是*，最后一个位置也是*
     *     *  //第4层 2个*  2 * 4 - 1    当前行的第一个位置是*，最后一个位置也是*
    ********* //第5层 9个*  2 * 5 - 1    全部输出*
        5.先死后活
        5.1改变层数 定义一个层数变量
        
         */
        int totalLine = 5;
        for (int i = 1; i <= totalLine; i++) {// i 表示层数

            //在输出*之间还要打印空格,对应空格 = 总层数 - 当前层
            for (int k = 1; k <= totalLine - i; k++) {
                System.out.print(" ");
            }

            //进行控制每层*的个数
            for (int j = 1; j <= 2 * i - 1; j++) {
                //当前行的第一个位置是*，最后一个位置也是*
                if (j == 1 || j == 2 * i - 1 || i == totalLine) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            
            //每打完一层的*后，换行  println会自动换行
            System.out.println("");
        }

    }
}

跳转控制语句

break

需求：随机生成1-100的一个数，直到生成了97这个数，看看你一共用了几次?
提示使用：(int)(Math.random() *100) +1
思路分析：循环，但是循环的次数不知道–> break，当某个条件满足时，终止循环–>通过该需求可以说明其它流程控制数据的必要性，比如break
基本介绍：
break语句用于终止某个语句块的执行，一般使用在switch或者循环中

基本语法:

{
    ......
        break;
    ......
}

示意图//break可作为提前终止循环的作用

快速入门Break01.java

for(int i = 0; i < 10; i++) {
    if(i == 3) {
        break; 
    }
    System.out.println("ok" + i);
}
//内存分析法 值输出0、1、2

注意事项和细节

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

2.标签的基本使用

label1: {......
label2:    {......
label3:      {......
              break label2;
              ......
              }
            }
         }

(1)break语句可以指定退出哪层
(2)label1是标签，由程序员指定
(3)break后指定到哪个label就退出到哪里
(4)在实际的开发中，尽量不要使用标签
(5)如果没有指定break，默认退出最近的循环体

3.判断输出什么？并分析原因

package chapter05;

public class BreakDetail {
    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) {
                    break label1;//如果此处改成break-->结果就是4组i = 0; i = 1
                }
                System.out.println("i=" + i);
            }
        }

    }
}//一组i = 0; i = 1

练习题1-b

BreakExercise.java

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

package chapter05;
import java.util.Enumeration;
public class BreakExercise {
//自己写的
    public static void main(String[] args) {
        
        int sum = 0;
        int num = 1;
        for (; num <= 100; num++){//将变量i提出来了！
            sum += num;
            if (sum > 20){
                break;
            }
        }
        System.out.println("num=" + num);
    }
}

package chapter05;
//写在里面（老韩写的）
import java.util.Enumeration;

public class BreakExercise {
    public static void main(String[] args) {

        int sum = 0;
        for (int num = 1; num <= 100; num++){
            sum += num;
            if (sum > 20){
                System.out.println("此时和大于20时 当前数i=" + num);
                break;
            }
        }
    }
}

package chapter05;

import java.util.Enumeration;
//老韩推荐写的
public class BreakExercise {
    public static void main(String[] args) {
        
        int sum = 0;//1.积累和，用for循环把1-100打印出来
        int n = 0;//3.在for循环外面定义一个变量 n,再把 i 赋给 n
        //注意i的作用域在for()循环里面
        for (int num = 1; num <= 100; num++){
            sum += num;
            if (sum > 20){
                System.out.println("此时和大于20时");
                n = num;
                break;//2.当sum >20时，记录下当前数，然后break
            }
        }
        System.out.println("i=" + n);
    }
}

实现登录验证，有3次机会，如果用户名为”丁真”，密码”666″提示登录成功，否则提示还有几次机会（for+ break）

补充：字符串的n内容比较是否相等方法使用equals类

String name ="林黛玉” ;
System.out.println(name.equals("林黛玉" ));
System.out.println("林黛玉".equals(name));//更推荐使用第二种方法，避免空指针

package chapter05;

import java.util.Scanner;

public class BreakExercise02 {
    public static void main(String[] args) {
        ///实现登录验证，有3次机会，如果用户名为"丁真"，密码"666"提示登录成功，
        //否则提示还有几次机会（for+ break）
        /*
        1.创建Scanner对象接收用户输入
        2.定义String name; string password; 保存用尸名和密码
        3.最多循环3次（登陆三次），如果满足条件提前退出
        4.定义变量 int chance 记录还有几次登录机会
         */
        Scanner scanner = new Scanner(System.in);
        String name = "";
        String password = "";
        int chance = 3;//登录一次就减少一次
        for (int i = 1; i <= 3; i++) {
            System.out.println("用户名：");
            name = scanner.next();
            System.out.println("密码：");
            password = scanner.next();
            //进行条件判断
            //补充：字符串的n内容比较是否相等 方法使用equals类
            if ("丁真".equals(name) && "666".equals(password)) {
                System.out.println("登陆成功");
                break;
            }
            //登录机会就减少一次
            chance--;
            System.out.println("你还有" + chance + "次登录机会");
        }
    }
}

continue

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

快速入门Continue01.java

int i = 1;
while(i <= 4) {
    i++;
    if(i == 2) {
        continue;
    }
    System.out.println("i=" + i);
}
//i=3\4\5结束

练习题2-c

细节案例分析和说明//结合内存分析法

package chapter05;

public class ContinueDetail {
    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;//4组 0、1、3-9（跳过了2）
                    continue label1;//4组 0、1
                }
                System.out.println("i=" + i);
            }
        }

    }
}

return

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

package chapter05.test;

public class Return01 {
    public static void main(String[] args) {

        for(int i = 1; i <= 5; i++) {
            if (i == 3) {
                System.out.println("你好" + i);
                return;//当return用在方法时，表示跳出方法，如果使用在main，表示直接结束程序
                //continue; //跳过本次循环
                //break;//跳出循环
            }
            System.out.println("Hello World!");
        }
        System.out.println("go on.." );

    }
}

家庭作业

练习题1

编程实现如下功能
某人有100,000元，每经过一次路口，需要交费，规则如下：
1)当现金>50000时，每次交5%
2)当现金<=50000时，每次交1000
编程计算该人可以经过多少次路口，要求：使用while break方式完成。

package chapter05.homework;

public class HomeWork01 {
    public static void main(String[] args) {
        /*
        1.定义变量 double money 保存钱
        2.根据题要求，分析出三种情况
          money > 50000
          money >= 1000 && money <=50000
          money <1000 退出循环的条件！break！
        3.使用多分支if-else-else进行
        4.while+break [money<1000],同时使用一个变量count来保存通过路口
         */
        double money = 100000;//剩余多少钱
        int time = 0;//累计过的路口
        while (true) {//无限循环
            if (money > 50000) {
                money *= 0.95;//money = money - (money * 0.05);
                time++;
            }else if (money >= 1000) {
                money -= 1000;//money = money - 1000;
                time++;
            }else {
                break;//钱不够1000
            }
            //time++;//放在此处也可以
        }
        System.out.println("该人可以经过" + time +"次路口");
    }
}

练习题2

实现判断个整数，属于哪个范围：大于0；小于0；等于0

package chapter05.homework;

import java.util.Scanner;

public class HomeWork02 {
    //实现判断个整数，属于哪个范围：大于0；小于0；等于0
    public static void main(String[] args) {
        /*
        1.创建Scanner对象 接收整数键入,定义一个变量int num
        2.使用什么循环进行判断？
        3.自己写的

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入判断的整数：");
        int num = scanner.nextInt();
        for (;true;) {
            if (num > 0) {
                System.out.println("该数大于0");
                break;
            }else if (num == 0) {
                System.out.println("该数等于0");
                break;
            }else {
                System.out.println("该数小于0");
                break;
            }
        }
        scanner.close();
         */
        
        //思路:定义int n=22;使用if--elseif--else即可
        //先死后活 再建立一个Scanner对象 键入
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入判断的整数：");
        int n = scanner.nextInt();
        if (n > 0) {
            System.out.println("该数>0");
        }else if (n < 0) {
            System.out.println("该数<0");
        }else {
            System.out.println("该数=0");
        }
        scanner.close();
    }
}

练习题3

判断一个年份是否为闰年

思路：课堂上讲过

练习题4

判断一个整数是否是水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。例如：153 = 1 * 1 * 1 + 3 * 3 * 3 + 5 * 5 * 5

package chapter05.homework;

public class HomeWork04 {
    //判断一个整数是否是水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
    //例如：153 = 1 * 1 * 1 + 3 * 3 * 3 + 5 * 5 * 5
    public static void main(String[] args) {
        /*自己写的
        1.创建一个Scanner对象，定义一个变量int num保存
        2.分别求出这个三位数的个十百位的数字 234 = 100 * 2 + 10 * 3 + 1 * 4
        3.int hun = num / 100;
          int ten = (num - hun * 100) / 10
          int unit = (num - hun* 100 - ten *10 ) / 1
          int cal = hum^3 + ten^3 + unit^3
        4.判断是否相等
        if(hum == cal){
            System.out.println("该数是水仙花数");
        }else{

        }
        */
        /*
        int num = 135;
        int hun = num / 100;
        int ten = (num - hun * 100) / 10;
        int unit = (num - hun* 100 - ten *10 ) / 1;
        int cal = (hun*hun*hun + ten*ten*ten + unit*unit*unit
        );
        if(num == cal){
            System.out.println("该数是水仙花数");
        }else{
            System.out.println("该数不是水仙花数");
        }
        */
        /*
        思路分析：老师写的
        1.比如int n = 153;
        2.先得到n的百位，十位，各位的数字，使用if判断他们的立方和是否相等
        3.n的百位 = n / 100
        4.n的十位 = n % 100 / 10
        5.n的各位=n % 10
        6.判断即可
        */
        int n = 153;
        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 + "不是水仙花数");
        }

    }
}

看看下面代码输出什么？//什么都不输出

class Demo {
    public static void main(String[] args) {
        int m = 0, n = 3;
        if(m > 0) {
            if(n > 2)
                System.out.println("OK1"); 
            else
                System.out.println("OK2"); 
        }
        
    }
}

输出1-100之间的不能被5整除的数，每5个一行//注意换行符的放置位置

package chapter05.homework;

public class HomeWork06 {
    public static void main(String[] args) {
        //1.输出1-100
        //2.筛选数据
        //3.5个一行 int count 统计个数 count % 5 ==0
        //说明输出五个
        int time = 0;//统计累计的个数
        for (int n = 1; n <= 100; n++) {
            if (n % 5 != 0) {
                time++;
                System.out.print(n + " ");
                //每满五个就输出一个换行
                if (time % 5 == 0) {
                    System.out.print("\n");//System.out.println();这种写法也可以！
                }
            }
        }

    }
}

输出小写的a-z以及大写的Z-A

package chapter05.homework;
public class HomeWork07 {
    public static void main(String[] args) {
        //输出小写的a-z以及大写的Z-A-->循环
        //考察我们对a-z编码和For的综合使用
        /*
        1.a = 97
        2.b = 'a' + 1 c = 'a' + 2
        3.使用for循环
         */
        for (char c = 'a'; c <= 'z'; c++) {
            System.out.print(c + "\t");
        }
        System.out.println();
        for (char c = 'Z'; c >= 'A'; c--) {
            System.out.print(c + "\t");
        }
        
    }
}

求出1-1/2+1/3-14…+1/97-1/98+1/99-1/100的和//注意隐藏条件

package chapter05.homework;

public class HomeWork08 {
    //求出1-1/2+1/3-1/4....+1/97-1/98+1/99-1/100的和
    public static void main(String[] args) {
        /*
        思路分析
        1. 1-1/2+1/3-14....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 += 1.0/i;//sum = sum + 1/i;
            }else {
                sum -= 1.0/i;
            }
        }
        System.out.println("sum=" + sum);
    }
}

求1+ (1+2) + (1+2+3) + (1+2+3+4) + … + (1+2+3+…+100)的结果

package chapter05.homework;

public class HomrWork09 {
    //求1+ (1+2) + (1+2+3) + (1+2+3+4) + ... + (1+2+3+...+100)的结果
    /*
    1.一共100项增加
    2.每一项的数字再逐渐增加
    3.很像一个双重循环
     */
    public static void main(String[] args) {
        //i 表示第几项，同时也是当前项的最后一个数
        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);
    }
}

原文链接：https://blog.csdn.net/weixin_54709885/article/details/123998456

day 04-控制结构学习

第4章程序控制结构

目录

介绍

顺序控制结构

分支控制结构

单分支

双分支

练习题1-单双

多分支

练习题2-多

嵌套分支

switch分支

练习题3-s

switch和if的比较

循环控制结构

for循环

练习题1-f

while循环

练习题2-w

do…while循环

练习题3-dw

多重循环控制(重难点)

练习题4-多

跳转控制语句

break

练习题1-b

continue

练习题2-c

return

家庭作业

练习题1

练习题2

练习题4

标签云

近期文章

分类

day 04-控制结构学习

第4章 程序控制结构

目录

介绍

顺序控制结构

分支控制结构

单分支

双分支

练习题1-单双

多分支

练习题2-多

嵌套分支

switch分支

练习题3-s

switch和if的比较

循环控制结构

for循环

练习题1-f

while循环

练习题2-w

do…while循环

练习题3-dw

多重循环控制(重难点)

练习题4-多

跳转控制语句

break

练习题1-b

continue

练习题2-c

return

家庭作业

练习题1

练习题2

练习题4

相关文章

第4章程序控制结构