Javaswitch和循环结构

超高校级の程序员

已于 2024-08-13 11:30:26 修改

阅读量979

点赞数 31

分类专栏： Java 文章标签：开发语言 java

于 2024-07-17 21:46:10 首次发布

本文链接：https://blog.csdn.net/weixin_64426680/article/details/140504360

版权

Java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

分支结构-switch语句

switch..case语句

switch..case分支语句，也被称为多路分支语句。

switch本身的含义是开关。在Java中switch..case语句很像生活中的开关，按不同的开关按钮，有不同的效果。

switch..case的语法格式

switch(表达式){
    case 值1:
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
    case 值3:
        语句体3;
        break;
    ...
    default:
        语句体n+1;
        break;
}

switch..case的执行流程

1. 计算switch表达式的值。注意：与if语句不同，不在是true和false，而是数值、字符、字符串等。

2. 表达式的值与某case的值一样时，执行对应case中的语句体。

3. break用于结束switch语句，继续执行switch语句后面的代码。

4. 如果没有任何一个case的值和表达式的值一致，执行default对应的语句体。default表示其他情况，即除了罗列的case之外的所有情况。

switch..case示例

switch..case示例：

1. 需求：输入一个1~7之间的整数（含1和7），如果输入的是1，就输出"今天是星期一"，如果输入的是2，就输出"今天是星期二"，...，如果输入的是7，就输出"今天是星期天"。如果输入的是其他数字，就输出"输入的数字非法"。

2. 代码：

public static void main(String[] args) {
/*需求：输入一个1~7之间的整数（含1和7），如果输入的是1，就输出"今天是星期一"，
如果输入的是2，就输出"今天是星期二"，...，如果输入的是7，就输出"今天是星期
    天"。
如果输入的是其他数字，就输出"输入的数字非法"。（使用switch..case来实现。）*/
    int day = 0;
    Scanner scanner = new Scanner(System.in);
    System.out.print("请输入1~7之间的数字（含1和7）：");
    day = scanner.nextInt();
    switch(day) {
        case 1:
            System.out.println("今天是星期一。");
            break;
        case 2:
            System.out.println("今天是星期二。");
            break;
        case 3:
            System.out.println("今天是星期三。");
            break;
        case 4:
            System.out.println("今天是星期四。");
            break;
        case 5:
            System.out.println("今天是星期五。");
            break;
        case 6:
            System.out.println("今天是星期六。");
            break;
        case 7:
            System.out.println("今天是星期天。");
            break;
        default:
            System.out.println("输入的数字非法。");
            break;
    }
}

switch..case语句中，switch后面的表达式的值是一个数值或者字符或者字符串。

表达式的值对应哪个case，就跳转到对应的case去执行。

如果没有任何一个case和表达式的值对应，就执行default对应的语句体。default一般写在所有case的后面。

default可以省略不写，相当于不处理其他情况。

break关键字

break关键字有2个用途：

1. 用于switch..case语句中的case语句块里，作用是结束switch的执行。

2. 用于循环结构，结束循环。

case中也可以不写break，不写break的话，switch不会结束执行，而是顺序往下执行代码，直到遇到break结束switch语句（或者顺序执行完整个switch..case语句）。

除非特殊需求需要省去break，否则每个case都要写上break。

break示例：

1. 需求：从键盘输入一个代表月份的数字，根据输入的结果，输出这个月有多少天（假定是平年）？例如：1月31天，2月28天，3月31天..

2. 代码1：

public static void main(String[] args) {
/*需求：从键盘输入一个代表月份的数字，根据输入的结果，输出这个月有多少天（假定是平年）？
例如：1月31天，2月28天，3月31天..*/
    int month = 0;
    Scanner scanner = new Scanner(System.in);
    System.out.print("请输入一个月份：");
    month = scanner.nextInt();
    switch (month) {
        case 1:
            System.out.println(month + "月有31天。");
            break;
        case 2:
            System.out.println(month + "月有28天。");
            break;
        case 3:
            System.out.println(month + "月有31天。");
            break;
        case 4:
            System.out.println(month + "月有30天。");
            break;
        case 5:
            System.out.println(month + "月有31天。");
            break;
        case 6:
            System.out.println(month + "月有30天。");
            break;
        case 7:
            System.out.println(month + "月有31天。");
            break;
        case 8:
            System.out.println(month + "月有31天。");
            break;
        case 9:
            System.out.println(month + "月有30天。");
            break;
        case 10:
            System.out.println(month + "月有31天。");
            break;
        case 11:
            System.out.println(month + "月有30天。");
            break;
        case 12:
            System.out.println(month + "月有31天。");
            break;
        default:
            System.out.println("输入的月份非法。");
            break;
    }
}

3. 代码2（合理使用break简化代码）：

public static void main(String[] args) {
/*需求：从键盘输入一个代表月份的数字，根据输入的结果，输出这个月有多少天（假定是平年）？
例如：1月31天，2月28天，3月31天..*/
    int month = 0;
    Scanner scanner = new Scanner(System.in);
    System.out.print("请输入一个月份：");
    month = scanner.nextInt();
    switch(month) {
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
        case 12:
            System.out.println(month + "月有31天。");
            break;
        case 2:
            System.out.println(month + "月有28天。");
            break;
        case 4:
        case 6:
        case 9:
        case 11:
            System.out.println(month + "月有30天。");
            break;
        default:
            System.out.println("输入的月份非法。");
            break;
    }
}

case连写的情况适用于多个case执行同样的代码。即省略break，不结束switch，让代码继续往下执行。

其他情况下，每个case都要有自己单独的代码和break

switch..case总结

1. switch..case语句和if语句作用一样，都是实现分支。

2. swicth..case语句中通过break关键字结束switch的执行。

3. switch中表达式的值决定了进入哪个case执行。

4. 没有对应的case就执行default，default一般写在所有case后面。

分支结构总结

在Java语言中，分支结构一共有2种：if语句和switch..case语句。

if语句有3种书写格式：if、if..else、if..else if..else if..else

无论哪种if格式，if后面表达式的值必须是一个boolean值，即true或false。

switch..case语句是多路分支，根据switch的值，决定进哪个case执行代码。没有对应的case就执行default。

break用于结束switch的执行。

虽然可以省略break，但要慎重。

循环结构

循环结构是三大流程控制结构的最后一种，相比于顺序结构和分支结构，循环结构略复杂一些。 循环结构的特点是能够重复的执行某些代码。

循环结构的基本概念

循环体：重复执行的代码称为循环体。可以是一条或者多条语句。

循环条件：循环体反复执行的判断条件。一般是关系表达式或者逻辑表达式。

循环结构的特征有2点：

1. 重复执行某些代码。----具有循环体

2. 有明确的开始和结束。----具有循环的初始状态、循环条件以及循环的控制语句

循环的初始状态：即循环的起始状态，简单说就是循环开始的时候什么样？

循环条件：循环体反复执行的判断条件。简单说就是判断循环是否能一直执行下去。

循环控制语句：循环执行中每次变化的内容，简单说就是控制循环是否执行下去。

为什么要使用循环？

循环结构特别适合解决这种大规模计算或执行代码雷同的场景。

Java中一共提供了3种实现循环的语法，分别是：

1. for循环 2. while循环 3. do..while循环

for循环

for循环是Java中最常用的循环。适用于知道循环次数的场景。

for循环的语法格式

for(表达式1;表达式2;表达式3){
    循环体;
}

for循环的执行流程

1. 首先执行表达式1，表达式1通常写循环的初始化内容，即循环的初始状态。表达式1只会执行一次。

2. 判断表达式2的真假。表达式2是循环的判断条件，表达式2的值为true，执行循环体，如果表达式2 的值为false，则结束循环，执行循环之外的代码。

3. 循环体执行完毕之后，执行表达式3。表达式3是循环的控制条件，这个条件可以影响循环的次数。

4. 表达式3执行完毕之后，回到步骤2继续判断。

表达式2的结果为false时，循环会结束。

for循环的示例

for循环示例1

1. 需求：通过for循环打印10遍"Hello World"

2. 代码：

public static void main(String[] args) {
    /*需求：通过for循环打印10遍"Hello World"
      分析：
    1.由题意可知循环次数是10次。
    2.循环体是 打印 Hello World
    */
    for(int i = 0; i < 10; i++) {
        System.out.println("Hello World");
    }
}

for循环的循环体一般来说比较容易理解，也比较容易找出来。在我们这个题中，循环体就是System.out.println("Hello World");

for循环的表达式1，表达式2，表达式3是配合使用的。三者共同控制循环的执行次数。表达式1用于指定初始条件，表达式2是一个boolean值，用于判断循环是否继续进行，表达式3往往是循环的增量，用于逼近判断条件。

一定要深入理解循环的执行流程，理解表达式1、表达式2、表达式3的关系，如何让3个表达式配合达到我们的目的。---打印10遍Hello World的变种写法。

for循环示例2

1. 需求：打印1~100之间（含1和100）所有的整数。

2. 代码：

public static void main(String[] args) {
//需求：打印1~100之间（含1和100）所有的整数。
//分析：
// 1.循环次数101次。
// 2.循环体：打印一个整数（1~100之间）。
    for(int i = 1; i <= 100; i++) {
        System.out.println(i);
    }
}

或者

public static void main(String[] args) {
//需求：打印1~100之间（含1和100）所有的整数。
//分析：
// 1.循环次数101次。
// 2.循环体：打印一个整数（1~100之间）。
    for(int i = 16; i <= 115; i++) {
        System.out.println(i-15);
    }
}

或者

public static void main(String[] args) {
//需求：打印1~100之间（含1和100）所有的整数。
//分析：
// 1.循环次数101次。
// 2.循环体：打印一个整数（1~100之间）。
    for(int i = 100; i >= 1; i--) {
        System.out.println(101 - i);
    }
}

通过上述的案例，你会发现同样的需求，可以使用不同的方法来实现。

在这个案例中，你要学会表达式1、表达式2、表达式3如何配合使用。---本质上是控制循环次数。

for循环示例3

1. 需求：打印出来100以内所有的奇数。

2. 代码：

public static void main(String[] args) {
/*需求：打印出来100以内所有的奇数。
分析：
 1.循环次数101次。
 2.循环体：打印一个奇数。---需要判断当前数是不是奇数，是就打印，不是就不打印。*/
    for(int i = 0; i <= 100; i++) {
        if(i % 2 == 1) {
            System.out.println(i);
        }
    }
}

虽然打印的是奇数，但是循环的次数是101次。只不过对于每个数做了一次判断，是奇数才打印。整体的循环次数并没有减少。

或者

public static void main(String[] args) {
//需求：打印出来100以内所有的奇数。
//分析：
// 1.循环次数50次。
// 2.循环体：打印一个奇数。---起始值设置为1，增量设置为2。
    for(int i = 1; i < 100; i += 2) {
        System.out.println(i);
    }
}

通过这个案例你会发现：表达式1，表达式2，表达式3是配合使用的，为的是控制循环次数。

for循环示例4

1. 需求：求1+2+3+...+9+10的和。

2. 代码：

public static void main(String[] args) {
//需求：求1+2+3+...+9+10的和。
//分析：
// 1.要有一个变量保存和。假定是sum
// 2.循环次数11次。
// 3.循环体：把数加到sum中去。
    int sum = 0;
    for(int i = 1; i <= 10; i++) {
        sum += i;
    }
    System.out.println(sum);
}

for循环示例5

1. 需求：在控制台打印出所有的水仙花数。水仙花数：是一个三位数，水仙花数的个位、十位、百位数字的立方之和等于原数。

2. 代码：

public static void main(String[] args) {
/*需求：在控制台打印出所有的水仙花数。水仙花数：是一个三位数，水仙花数的个位、十位、百位数字的立方之和等于原数。
判断从 100到999哪个是水仙花数，所以循环从100到999。
找出数字的 个位、十位、百位分别是什么，再判断立方和是不是等于原数。*/
    for(int i = 100; i < 1000; i++) {
        int gw = i % 10;
        int sw = i / 10 % 10;
        int bw = i / 100;
        if(gw * gw * gw + sw * sw * sw + bw * bw * bw == i) {
            System.out.println(i);
        }
    }
}

for循环案例6

1. 需求：产生5个[10, 80]之间的随机数，并输出产生的数。

2. 代码：

public static void main(String[] args) {
//需求：产生5个[10, 80]之间的随机数，并输出产生的数。
//思路：循环5次，每次产生一个随机数并打印随机数。
//先创建Random对象
    Random random = new Random();
    for(int i = 0; i < 5; i++) {
        int num = random.nextInt(80 - 10 + 1) + 10;
        System.out.print(num + " ");
    }
}

for循环案例7

1. 需求：产生5个[10,20]之间的随机数，输出产生的数，并计算随机数的和以及平均值。

2. 代码：

public static void main(String[] args) {
//需求：产生5个[10, 20]之间的随机数，输出产生的数，并计算随机数的和以及平均值。
//思路：
//1.定义一个变量sum保存随机数的和。
//2.定义一个变量avg保存随机数的平均数。
//3.循环5次，每次产生一个随机数并打印随机数，将随机数的值加到sum中。
//4.通过sum求avg
//先创建Random对象
    Random random = new Random();
//定义一个变量保存随机数的和。
    int sum = 0;
//定义一个变量保存随机数的平均值。
    double avg = 0;
    for (int i = 0; i < 5; i++) {
        int num = random.nextInt(20 - 10 + 1) + 10;
        System.out.print(num + " ");
        sum += num;
    }
    avg = 1.0 * sum / 5;
    System.out.println("sum = " + sum + ", avg = " + avg);
}

断点调试

断点调试是开发中常用的调试技巧之一。

所谓的断点调试，指的是在程序的某个位置打上断点，程序在以调试模式运行的过程中就会停在断点处，等待我们进行下一步的操作。

添加断点、移除断点

在代码行号的右侧，单击鼠标左键，即可添加上断点；再次单击鼠标左键，即可移除断点。

可以添加多少断点？

理论上来讲，每一行都可以添加断点。实际上我们只在关键代码处添加断点。

何为关键代码处？

1.复杂业务逻辑代码的开头位置

2.for循环的开始处

3.容易出现错误的代码处。

如何调试代码

Step Over：执行一行代码。

Step Into：进入代码内部（如果当前行是一个函数，会跳入到函数内部，如果只是一行普通代码，功能和step over一样）。

Step Return：与Step Into配套使用，用于跳出Step Into进入的函数。

Resume：结束当前断点，跳到下个断点位置。

断点调试有什么用？

断点调试就像电影的慢镜头一样，能让你看到每一步是怎么执行的。能看到每一步执行后，程序中的数据发生了什么样的变化。例如：变量值的更新。

断点调试总结

断点调试是开发项目必须具备的技能。一定要学会添加、删除断点，学会看断点下各个变量的变化。

随机数

在Java中使用Random类来产生随机数。具体使用步骤如下：

1. 导包。----import java.util.Random;

2. 创建Random对象。Random random = new Random();

3. 获取随机数。int num = random.nextInt(10);-----[0,10)

随机数案例：

1. 需求：产生1个取值范围在[0,50)的随机数。

2. 代码：

public static void main(String[] args) {
//需求：产生1个取值范围在[0,50)的随机数。
    Random random = new Random();
    int num = random.nextInt(50);
    System.out.println(num);
}

3. 需求：产生1个取值范围在[5,18)的随机数。

4. 代码：

public static void main(String[] args) {
//需求：产生1个取值范围在[5,18)的随机数。
//思路：
//1.产生一个[0,13)的随机数
//2.在上述记过的基础上+5
    Random random = new Random();
    int num = random.nextInt(13) + 5;
    System.out.println(num);
}

5. 需求：产生1个取值范围在[23,41]的随机数。

6. 代码：

public static void main(String[] args) {
//需求：产生1个取值范围在[23,41]的随机数。
//思路：
//1.产生一个[0,19)的随机数
//2.在上述记过的基础上+23
    Random random = new Random();
    int num = random.nextInt(19) + 23;
    System.out.println(num);
}

随机数的规律：要想产生一个[min, max]之间的随机数。

int num = random.nextInt(max - min + 1) + min;

for循环总结

for循环是最常用的循环，开发中几乎90%左右的循环都是for循环，for使用场景是明确知道循环次数的情形。

while循环

while是Java中第二常用的循环。while循环能实现for循环全部的功能，即：while循环可以替代for循环。除此以外，while循环还适用于不知道具体循环次数的循环（只知道循环结束条件，但不清楚循环多少次结束。）。

while循环最大的特点：适用于不知道循环次数的循环。

在开发中，如果知道循环次数，往往使用for循环（因为for循环的格式比较简洁，书写比较方便），只有不知道循环次数的时候，才使用while循环。

while循环的语法格式

while(条件表达式){
    循环体;
}

while循环的执行流程

1. 计算条件表达式的值。

2. 如果条件表达式的值为true，执行循环体。

3. 执行完循环体以后，回到步骤1。

4. 如果条件表达式的值为false，结束循环的执行。

while循环的示例

while循环替代for循环

while循环示例1

1. 需求：打印1~100之间（含1和100）所有的整数。

2. 代码：

public static void main(String[] args) {
//需求：打印1~100之间（含1和100）所有的整数。
//分析：
//1.循环体是打印整数
//2.循环结束的条件是打印完1~100之间所有的整数。
//---因此，需要有一个变量来表示当前正在打印的整数，当前数打印完之后要换下一个数。
//---循环条件：当前打印的整数没有超出[1, 100]范围
    int num = 1;
    while(num <= 100) {
        System.out.println(num);//打印当前的数
        num++;//换下一个数
    }
}

while循环的完整语法格式是：

循环的初始条件;//对应for循环的 表达式1
while(条件表达式){//对应for循环的 表达式2
    循环体;//对应for循环的 循环体
    循环增量;//对应for循环的表达式3
}

开发中，如果知道循环次数，一般使用for循环，不使用while循环。--因为for简单。

while循环自身特长：不知道循环次数

while循环示例2

1. 需求：世界上最高山峰是珠穆朗玛峰（8844.43米=8844430毫米），假如有一张足够大的纸，它的厚度是0.1毫米。请问折叠多少次，可以折成珠穆朗玛峰的高度？

2. 代码：

public static void main(String[] args) {
/*需求：世界上最高山峰是珠穆朗玛峰（8844.43米=8844430毫米），假如有一张足够大的纸，它的厚度是0.1毫米。
请问折叠多少次，可以折成珠穆朗玛峰的高度？
分析：
1.纸每折叠一次，都是上一次厚度的2倍。
2.循环体：更新当前厚度，更新折叠次数。
3.循环执行条件：厚度小于珠穆朗玛峰的高度。*/
    double thickness = 0.1;
    int count = 0;
    while(thickness <= 8844430) {
        thickness *= 2;
        count++;
    }
    System.out.println("达到珠穆朗玛峰的高度，需要折叠" + count + "次，此时纸的厚度是" + thickness + "毫米");
}

while循环总结---不知道循环次数

while循环最大的用途就是处理不知道循环次数的循环，这一点是for无法做到的。在开发中，凡是用到while的地方，都是因为需要循环，但不知道具体要循环几次。

代for循环总结

通过上述种种示例，不难发现while确实可以替代for循环。而且可以发现for循环中的表达式1，表达式2，表达式3以及循环体，在while循环中都有出现。

for循环的表达式1对应的是while循环之前的循环初始条件。

for循环的表达式2对应的是while循环的条件表达式。

for循环的表达式3对应的是while循环中的变量自增。

for循环的循环体对应的是while循环中除了变量自增之外的全部内容。

while总结

1. while可以实现for循环的全部功能。

2. while循环善于处理不知道循环次数的循环。

3. 开发中使用的是while的第二种功能。

do..while循环

do...while是Java中第三种循环结构，是使用频率最低的循环结构。do..while循环能实现while循环全部的功能，do...while循环和while循环的唯一区别是，do..while循环会至少执行一次循环。

do..while循环的语法格式

do{
    循环体;
}while(表达式);

注意：上述格式中，while(表达式)后面有一个分号。

do...while循环的执行流程

1. 执行循环体语句。

2. 判断表达式的值是否为true。如果为true，执行步骤1。

3. 如果表达式的值为false，结束循环。

while循环是先判断条件在决定是否执行循环体。

do..while是先执行循环体再判断条件。即：至少执行一次循环体。

do..while循环的示例

do..while循环示例：

1. 需求：打印1~100之间（含1和100）所有的整数。

2. 代码：

public static void main(String[] args) {
//需求：打印1~100之间（含1和100）所有的整数。
//分析：
//1.循环体：打印一个整数。
//2.循环次数：100次。
//3.起始条件：从数字1开始
//4.循环控制：数字增1
//4.循环条件：数字小于等于100
    int i = 1;
    do {
        System.out.println(i);
        i++;
    }while(i <= 100);
}

do..while总结

do..while本质上和while差不多，既能胜任知道循环次数的情形，也能胜任不知道循环次数的情形。与while的不同点是先执行循环体，再判断条件是否成立。

开发中do..while的使用频率比较低。因为while循环可以替代do..while，只需要在while循环之前，先把循环体的代码写一遍即可。

for、while、do..while区别

public static void main(String[] args) {
    for(int i = 5; i < 5; i++) {
        System.out.println("for循环");
    }
    int j = 5;
    while(j < 5) {
        System.out.println("while循环");
        j++;
    }
    int k = 5;
    do {
        System.out.println("do..while循环");
        k++;
    }while(k < 5);
}

do..while至少执行一次循环体。

public static void main(String[] args) {
    for(int i = 1; i < 3; i++) {
        System.out.println(i);
    }
//System.out.println(i);
    System.out.println("---华丽的分割线---");
    int j = 1;
    while(j < 3) {
        System.out.println(j);
        j++;
    }
    System.out.println(j);
    System.out.println("---华丽的分割线---");
    int k = 1;
    do {
        System.out.println(k);
        k++;
    }while(k < 3);
    System.out.println(k);
}

for循环中定义的变量i，只能在for循环里用，出了for循环就不能使用了。

对于while循环的 j 以及do..while循环的k来说，他们定义在了循环的外面，因此可以在循环结束后使用。