• Java控制结构总结[顺序控制 分支控制 循环控制]

    文章目录

    在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。
    1)顺序控制
    2)分支控制
    3)循环控制

    顺序控制

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

    image-20221027171252294

    分支控制(if , else, switch)

    单分支

    基本语法

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

    • 1
    • 2
    • 3

    说明: 当条件表达式为ture时，就会执行{ }的代码。如果为false就不执行.
    特别说明，如果{}中只有一条语句，则可以不用{}, 但是建议写上{}

    import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年龄: ");
        int age = sc.nextInt();
        if (age >= 18) {
            System.out.println("成年人!");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    双分支

    基本语法

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

    • 1
    • 2
    • 3
    • 4
    • 5
    import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年龄: ");
        int age = sc.nextInt();
        if (age >= 18) {
            System.out.println("成年人!");
        } else {
            System.out.println("未成年~");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    多分支

    基本语法

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    image-20221027172257041

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

    输入保国同志的芝麻信用分 ------------------ 如果:
    1.信用分为100分时，输出信用极好;
    2.信用分为(80, 99]时，输出信用优秀;
    3.信用分为[60,80]时，输出信用一般;
    4.其它情况，输出信用不及格;
    5.请从键盘输入保国的芝麻信用分，并加以判断

    import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入芝麻信用分: ");
        int score = sc.nextInt();
        if (score >= 100) {
            System.out.println("信用极好");
        } else if (score > 80) {
            System.out.println("信用优秀");
        } else if (score >= 60) {
            System.out.println("信用一般");
        } else {
            System.out.println("信用不及格");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    嵌套分支

    在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。

    老师建议:不要超过3层(可读性不好)

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    案例演示

    参加歌手比赛，如果初赛成绩大于8.0进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。[可以让学员先练习下] ,输入成绩和性别，进行判断和输出信息。

    import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入歌手成绩: ");
        double score = sc.nextDouble();
        if (score > 8.0) {
            System.out.println("请输入性别:");
            char gender = sc.next().charAt(0);
            if (gender == '男') {
                System.out.println("♂");
            } else if (gender == '女') {
                System.out.println("♀");
            }
        } else {
            System.out.println("被淘汰了😅");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    switch分支结构

    基本语法

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    1. switch关键字，表示swtich分支
    2. 表达式对应一个值
    3. case常量1 :当表达式的值等于常量1,就执行语句块1
    4. break :表示退出swtich
    5. 如果和case常量1匹配，就执行语句块1,如果没有匹配，就继续匹配case常量2
    6. 如果一个都没有匹配上，执行default

    image-20221027174008057

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

    import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入: ");
        char c = sc.next().charAt(0);
        switch (c) {
            case 'a':
                System.out.println("Monday");
                break;
            case 'b':
                System.out.println("Tuesday");
                break;
            case 'c':
                System.out.println("Wednesday");
                break;
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    switch注意事项和细节讨论

    1. 表达式数据类型，应和case后的常量类型一致， 或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int
    2. switch(表达式)中表达式的返回值必须是: (byte, short, int, char, enum[枚举], String)
    3. case子句中的值必须是常量,而不能是变量
    4. default子句是可选的，当没有匹配的case时，执行default
    5. break语用来在执行完一 个case分支后使程序跳出switch语句块: 如果没有写break,程序会顺序执行到switch结尾

    例题

    根据用于指定月份，打印该月份所属的季节。3,4,5 春季 6,7,8夏季 9,10,11秋季 12,1,2冬季[课堂练习，提示使用穿透]

    import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入月份: ");
        int month = sc.nextInt();
        switch (month) {
            case 3:
            case 4:
            case 5:
                System.out.println("Spring");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("Summer");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("Autumn");
                break;
            case 12:
            case 1:
            case 2:
                System.out.println("Winter");
                break;
            default:
                System.out.println("Wrong Month [1-12]");
        }
    }
}

    • 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
    switch和if的比较
    • 如果判断的具体数值不多，而且符合byte, short, int, char, enum, String这6种类型。虽然两个语句都可以使用，建议使用swtich语句。
    • 其他情况:对区间判断，对结果为boolean类型判断，使用if, if的使用范围更广

    循环控制(for，while , do while ,多重循环)

    for循环控制

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

    基本语法

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

    • 1
    • 2
    • 3

    ➢老韩说明

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

    image-20221027214201440

    public class Test {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.println("你好, 红烧肉");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    注意事项和细节说明

    • 循环条件是返回一个布尔值的表达式

    • for(;循环判断条件;)中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。

            int i = 1;
        for (; i <= 10; ) {
            System.out.println("你好, 红烧肉" + i);
            i++;
        }
        for (; ; ) {
            System.out.println("死循环,可以结合break用");
        }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    • 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，
      循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。

    • 使用内存分析法，分析输出下面代码输出什么?

            int count = 3;
        for (int i = 0, j = 0; i < count; i++, j += 2) {
            System.out.println("i=" + i + "\t j=" + j);
        }

    • 1
    • 2
    • 3
    • 4

    i=0 j=0
    i=1 j=2
    i=2 j=4

    while循环控制

    基本语法

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

    • 1
    • 2
    • 3
    • 4
    • 5

    while循环也有四要素, 只是四要素放的位置，不一样.

    image-20221027221301668

            int i = 1;
        while (i < 11) {
            System.out.println("丘丘人\t" + i);
            i++;
        }

    • 1
    • 2
    • 3
    • 4
    • 5

    注意事项和细节说明

    循环条件是返回一个布尔值的表达式

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

    do while循环

    基本语法

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

    • 1
    • 2
    • 3
    • 4
    • 5

    说明:

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

    image-20221028102218841

            int i = 1;
        do {
            System.out.println("丘丘人\t" + i);
            i++;
        } while (i < 11);

    • 1
    • 2
    • 3
    • 4
    • 5
    多重循环控制

    1 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环和内层循环。[建议一 般使用两层，最多不要超过3层，否则，代码的可读性很差]

    2 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环[听不懂，走案例]。

    3 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

    打印出九九乘法表

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    打印出空心金字塔

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

    image-20221028111155441

    public class Test {
    public static void main(String[] args) {
        int totalLevel = 5;
        for (int t = 1; t < totalLevel; t++) {
            //1 先输出边上的空格
            for (int temp1 = 0; temp1 < totalLevel - t; temp1++) System.out.print(" ");
            //2 输出一个*
            System.out.print("*");
            //3 判断条件, 输出空格
            if (2 * t - 3 < 0) {
                System.out.println();
                continue;
            } else {
                for (int temp2 = 0; temp2 < 2 * t - 3; temp2++) System.out.print(" ");
            }
            //4 再输出一个*
            System.out.print("*");
            //5 输出空格,输不输出都一样
            //6 换行
            System.out.println();
        }
        for (int temp = 0; temp < totalLevel * 2 - 1; temp++) System.out.print("*");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    跳转控制语句-break

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

    public class Test {
    public static void main(String[] args) {
        while (true) {
            double r = Math.random();
            int r_int = (int) (r * 100);
            System.out.println(r_int);
            if (r_int == 77) break;
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    注意事项和细节说明:

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

    2 标签的基本使用

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

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

    public class Test {
    public static void main(String[] args) {
        lable1:
        for (int i = 0; i < 4; i++) {
            lable2:
            for (int j = 0; j < 10; j++) {
                if (j == 2) {
                    break lable1;
                }
                System.out.println("i= " + i + "\tj=" + j);
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    1-100以内的数求和，求出当和第一次大于20的当前数

    public class Test {
    public static void main(String[] args) {
        int sum = 0;
        int i = 1;
        for (; i < 101; i++) {
            sum += i;
            if (sum > 20) {
                System.out.println("和大于20时, i=" + i);
                break;
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    跳转控制语句-continue

    基本介绍:

    • continue语句用于结束本次循环，继续执行下一次循环。
    public class Test {
    public static void main(String[] args) {
        int i = 0;
        while (i <= 4) {
            i++;
            if (i == 2) {
                continue;
            }
            System.out.println("i=" + i);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环,这个和前面的标签的使用的规则一样.
    public class Test {
    public static void main(String[] args) {
        lable1:
        for (int i = 0; i < 4; i++) {
            lable2:
            for (int j = 0; j < 10; j++) {
                if (j == 2) {
                    continue lable1;
                }
                System.out.println("i= " + i + "\tj=" + j);
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    跳转控制语句-return

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

    public class Test {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                System.out.println("纳西妲\t" + i);
                return;//continue; break;
            }
            System.out.println("Hel1o World!");
        }
        System.out.println("go on. .");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    作 业

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

    public class Test {
    public static void main(String[] args) {
        int times = 0;
        double rmb = 100000;
        while (rmb >= 1000) {
            if (rmb > 50000) {
                rmb = 0.95 * rmb;
            } else {
                rmb -= 1000;
            }
            times++;
        }
        System.out.println("经过了 " + times + "次路口");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    2 实现判断一个整数，属于哪个范围: 大于0;小于0;等于0

    3 判断一个年份是否为闰年

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

    import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        // 判断一个整数是否是水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数字: ");
        int num = sc.nextInt();
        // 获得 个十百 分位数字
        int high = num / 100;
        int middle = (num / 10) % 10;
        int low = num % 10;
        if (num == (Math.pow(low, 3) + Math.pow(middle, 3) + Math.pow(high, 3))) {
            System.out.println("是水仙花数!");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    6 输出1-100之间的不能被5整除的数，每5个一行

    public class Test {
    public static void main(String[] args) {
        // 输出1-100之间的不能被5整除的数，每5个一行
        int newLineTag = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 5 != 0) {
                newLineTag++;
                System.out.print(i + "\t");
                if (newLineTag % 5 == 0) System.out.println();
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

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

    8 求出 1 − 1 / 2 + 1 / 3 − 1 / 4 + . . . − 1 / 100 1-1/2+ 1/3-1/4+...-1/100 1−1/2+1/3−1/4+...−1/100的和

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

    public class Test {
    public static void main(String[] args) {
        // 求1+ (1+2) + (1+2+3) + (1+2+3+4) +...+(1 +2+3+...+100)的结果
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            for (int j = 1; j <= i; j++) {
                sum += j;
            }
        }
        System.out.println("sum= " + sum);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
  • 相关阅读:
    rocketmq-exporter配置为系统服务-自启动
    10.VScode下载---Windows64x
    从入门到进阶 之 ElasticSearch SpringData 继承篇
    如何使用Docker部署开源Leanote蚂蚁笔记并发布个人博客至公网
    可用于智能客服的完全开源免费商用的知识库项目
    mobx基础及在react中的使用
    硅基罗丹明-四嗪SiR-tetrazine SiR-TZ SIR荧光染料
    《微机原理》-绪论
    一文讲明白K8S各核心架构组件
    豆包MarsCode Agent 登顶 SWE-bench Lite 评测集
  • 原文地址：https://blog.csdn.net/Drifter_Galaxy/article/details/127574988