Java笔记——流程控制

于 2024-10-02 22:45:44 发布
阅读量672 收藏 10
点赞数 10
文章标签： 笔记 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72047169/article/details/142684370
版权

前言:

       流程控制:用来控制程序中各个语句执行顺序,将语句组合成可以完成一定功能的小逻辑模块。

在设计程序时，规定的流程结构有三种：

  1. 顺序结构：程序从上到下执行，中间过程中没有任何判断和跳转。
  2. 分支结构：根据条件，选择性的执行某段代码；例：if-else语句和switch-case语句。
  3. 循环结构：根据循环结构，重复性的执行某段代码；例：for、while、do-while。

1.分支语句

1.1 if-else结构

1.1.1 单分支条件判断

if(条件表达式) {

       语句块;

}

执行流程：

  1. 运行结果为true，执行代码块。
  2. 结果为false，结束运行。

流程图：

1.1.2 双分支条件判断

if(条件表达式){

      语句块1;     

}else{

      语句块2;

}

执行流程：

  1. 结果为true，执行语句1。
  2. 结果为false，执行语句2。

流程图:

1.1.3 多分支条件判断

if(条件表达式){

      语句块1;     

}else{

      语句块2;

}

...

}else if(条件表达式n){

      语句块n;

} else{

      语句块n+1;

}

执行流程：

  1. 先判断关系表达式1结果为true还是false。
  2. 如果为true，执行语句块1，然后结束当前多分支。
  3. 如果是false，就继续判断关系表达式2的结果为true还是false（下同）

流程图：

1.1.4 if-else的嵌套使用示例

假设我们想根据一个学生的分数判断他的成绩等级。具体来说，我们可以定义如下等级：

  • 90分及以上：优秀
  • 80到89分：良好
  • 70到79分：中等
  • 60到69分：及格
  • 60分以下：不及格
//这里使用了Scanner类从键盘获取数据
import java.util.Scanner;
public class Person{
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            // 输入学生分数
            System.out.print("请输入学生的分数: ");
            int score = scanner.nextInt();

            // 嵌套if-else语句来判断成绩等级
            if (score >= 90) {
                System.out.println("成绩等级: 优秀");
            } else if (score >= 80) {
                System.out.println("成绩等级: 良好");
            } else if (score >= 70) {
                System.out.println("成绩等级: 中等");
            } else if (score >= 60) {
                System.out.println("成绩等级: 及格");
            } else {
                System.out.println("成绩等级: 不及格");
            }

            scanner.close();
        }
}

结果:

 

1.2 switch-case结构

1.2.1 格式与执行流程

switch(表达式){

      case 常量值1:

            语句块1；

            break;

      case 常量值2:

            语句块2；

            break;

      ...

      [default:

            语句块n=1；

            break;           

      ]

}

执行过程:

  1. 首先计算表达式的值，并与每个case标签进行比较。
  2. 找到第一个匹配的case后，执行对应的代码块。
  3. 如果没有匹配的case，可以选择执行default块。
  4. 如果没有使用break，控制流将继续执行下一个case，直到遇到break或结束整个switch。
  5. 一旦执行了break，或所有case都执行完毕，控制流将跳出switch结构。

流程图：

1.2.2 示例

题目：输入1-7 判断并输出星期几

import java.util.Scanner;

public class Person{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 输入星期几
        System.out.print("请输入一个数字（1-7）代表星期几: ");
        int day = scanner.nextInt();

        // switch-case 结构
        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("无效的输入，请输入1到7之间的数字。");
                break;
        }

        scanner.close();
    }
}

结果：

 

1.2.3 注意事项

  1. switch中的表达式只能是特定的数据类型，如：byte \ short \ char \ int \ enum \ String()

2.循环语句

概念：循环语句具有在某些条件满足的情况下，反复执行特定代码的功能。

循环结构四要素：

  1. 初始化部分
  2. 循环条件部分
  3. 循环体部分
  4. 迭代部分

2.1 for循环

2.1.1 for循环结构

说明：for循环是一种控制结构，用于重复执行一段代码块，直到满足特定条件。for循环通常用于已知次数的迭代。

for (初始化①; 条件②; 迭代④) {

      循环体③

}

执行过程：①-②-③-④-②-③-④...

2.1.2 示例

题目：遍历1到100以内的偶数，并计算偶数的个数和它们的总和

public class Person {
    public static void main(String[] args) {
        int count = 0;  // 用于记录偶数的个数
        int sum = 0;    // 用于计算偶数的和

        // 使用for循环遍历1到100的数字
        for (int i = 1; i <= 100; i++) {
            // 检查当前数字是否为偶数
            if (i % 2 == 0) {
                count++;       // 偶数个数加1
                sum += i;      // 累加偶数到sum
            }
        }

        // 输出结果
        System.out.println("1到100之间的偶数个数: " + count);
        System.out.println("1到100之间的偶数的和: " + sum);
    }
}

2.2 while循环

2.2.1 while循环结构

说明：在条件为true时反复执行循环体，直到条件为false。while循环适用于在不确定循环次数的情况下反复执行的场景。

while (条件) {

        循环体

}

2.2.2 示例

题目：使用while循环遍历1到100的偶数

public class Person {
    public static void main(String[] args) {
        int i = 1;        // 循环变量，从1开始
        int count = 0;   // 用于记录偶数的个数
        int sum = 0;     // 用于计算偶数的和

        // 使用while循环遍历1到100的数字
        while (i <= 100) {
            // 检查当前数字是否为偶数
            if (i % 2 == 0) {
                count++;       // 偶数个数加1
                sum += i;      // 累加偶数到sum
            }
            i++; // 增加循环变量，避免无限循环
        }

        // 输出结果
        System.out.println("1到100之间的偶数个数: " + count);
        System.out.println("1到100之间的偶数的和: " + sum);
    }
}

结果：

2.3 do-while循环

2.3.1 do-while结构

说明：do-while循环会 先执行一次循环体，然后再检查循环条件。也就是说，do-while循环至少会执行一次，即使条件一开始就是false。

do {

       循环体

} while (条件);

2.3.2 示例

题目：使用 do-while 循环遍历1到100的偶数

public class Person {
    public static void main(String[] args) {
        int i = 1;        // 循环变量，从1开始
        int count = 0;    // 用于记录偶数的个数
        int sum = 0;      // 用于计算偶数的和

        // 使用 do-while 循环遍历 1 到 100 的数字
        do {
            // 检查当前数字是否为偶数
            if (i % 2 == 0) {
                count++;       // 偶数个数加 1
                sum += i;      // 累加偶数到 sum
            }
            i++; // 增加循环变量，避免无限循环
        } while (i <= 100); // 循环条件，直到 i 超过 100

        // 输出结果
        System.out.println("1到100之间的偶数个数: " + count);
        System.out.println("1到100之间的偶数的和: " + sum);
    }
}

结果：

2.4 无限循环结构

2.4.1 无限循环的结构

说明：它会不断重复执行某段代码，直到程序被强制停止或循环内部存在某种条件来中断循环。

1. 使用 while 循环
while (true) {
    // 循环体
    System.out.println("这是无限循环");
}


2. 使用 for 循环
for (;;) {
    // 循环体
    System.out.println("这是无限循环");
}

3. 使用 do-while 循环
do {
    // 循环体
    System.out.println("这是无限循环");
} while (true);

2.4.2 示例

题目：带有条件的无限循环

public class Person {
    public static void main(String[] args) {
        int count = 0;

        while (true) {
            System.out.println("循环次数: " + count);
            count++;

            // 假设在10次后退出循环
            if (count >= 10) {
                break; // 退出循环
            }

            // 休眠1秒钟
            try {
                Thread.sleep(1000); // 休眠1000毫秒（1秒）
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("循环结束。");
    }
}

结果：

注意：

  1. 容易引发死循环。
  2. 在合适的场景下，它是非常有用的，如服务器监听、实时数据处理、GUI事件监听、游戏主循环以及后台任务。
  3. 设计时，要确保有清晰的退出条件，以避免资源泄露和性能问题

2.5 嵌套循环

2.5.1 嵌套循环的结构

说明：嵌套循环是指在一个循环内部再包含一个或多个循环的结构。在Java中，嵌套循环可以用于处理多维数组、生成图形、执行复杂的算法等。是处理多维数据和执行重复任务等有效方法。

1.嵌套for循环的基本结构：
for (int i = 0; i < 外部条件; i++) {
    // 外层循环代码
    for (int j = 0; j < 内部条件; j++) {
        // 内层循环代码
    }
}

2.嵌套while循环的基本结构：

while (条件1) {
    // 外层循环的代码

    while (条件2) {
        // 内层循环的代码
    }

    // 外层循环的其他代码
}
3.嵌套do-while循环的基本结构：

do {
    // 外层循环的代码

    do {
        // 内层循环的代码
    } while (条件2);

    // 外层循环的其他代码
} while (条件1);

2.5.2 示例

题目：二维数组的遍历

public class Person {
    public static void main(String[] args) {
        int[][] array = {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 9}
        };

        for (int i = 0; i < array.length; i++) { // 遍历行
            for (int j = 0; j < array[i].length; j++) { // 遍历列
                System.out.print(array[i][j] + " "); // 打印元素
            }
            System.out.println(); // 换行
        }
    }
}

结果：

3.关键字break和continue

3.1 break

说明：break用于立即终止当前循环。它可以用于for、while和do-while循环中。当程序执行到break语句时，循环将被完全退出，控制权将转移到循环后面的第一条语句。

示例：打印5遍内容

public class Person{
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                break; // 当 i 等于 5 时，终止循环
            }
            System.out.println(i);
        }
        System.out.println("循环已终止");
    }
}

结果：当i等于5时，break语句被触发，循环终止，因此只打印出0到4的数字。

3.2 continue

说明：continue用于跳过当前循环中的剩余语句，并立即开始下一次循环的迭代。也就是说，当程序执行到continue语句时，当前迭代将被跳过，控制权将转移到循环的开始部分。

示例：打印10以内的所有奇数

public class Person {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                continue; // 跳过偶数
            }
            System.out.println(i);
        }
    }
}

结果：当i为偶数时，continue语句被触发，跳过了System.out.println(i);语句，因此只打印出奇数。

3.3 综合使用

示例：跳过所有能被3整除的数字，并在num大于15时终止循环。

public class Person {
    public static void main(String[] args) {
        for (int num = 0; num < 20; num++) {
            if (num % 3 == 0) {
                continue; // 跳过能被3整除的数字
            }
            if (num > 15) {
                break; // 当 num 大于15时，终止循环
            }
            System.out.println(num);
        }
    }
}

结果：

注意：

  1. break和continue都是用于控制循环执行流的关键字。
  2. break用于完全退出循环，而continue则跳过当前迭代并继续下一次循环。
编程的幸
关注
个人学习的java笔记——思维导图
01-25
这份"个人学习的java笔记——思维导图"是作者学习Java过程中的总结，通过思维导图的形式，将复杂的概念和知识结构化，便于理解和记忆。下面，我们将深入探讨其中涉及的一些关键知识点。 1. **基础语法**：Java的...
jBPM-jPDL学习笔记——流程设计与控制(转载)
03-06
在《jBPM-jPDL学习笔记——流程设计与控制》这篇博文中，作者主要介绍了如何使用jPDL进行流程设计和控制，包括以下几个关键知识点： 1. **jPDL介绍**： jPDL是jBPM的核心组成部分，它定义了流程实例的行为。通过...
Java笔记——流程控制LOOP循环
u013430418的博客
06-30 1119
LOOP循环第一篇
Java笔记——流程控制LOOP循环 笔记二
u013430418的博客
07-04 296
本篇笔记2延续流程控制LOOP循环的讲解，如需要全部笔记，请 移步笔记1
Java 笔记——流程控制——增强for循环
TGFXK的博客
04-16 225
Java5 引入了一种主要用于数组或集合的增强型 for 循环。 Java 增强 for 循环语法格式如下: for(声明语句 : 表达式) { //代码句子 } 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。 演示：增强for循环遍历输出数组元素 package com.tang; public class ForDemo { public st
从零开始的Java笔记——流程控制
qq_40509784的博客
05-26 492
从零开始的Java笔记（day6——流程控制） 本次笔记的重点流程控制顺序结构分支结构(选择结构)if分支if-单分支：if-多分支if双分支拓展：随机数分支结构练习练习1：练习2：switch分支if分支与switch分支的区别循环结构while循环do-while循环for循环循环关键字循环的嵌套使用双重循环多重循环 流程控制 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。 分类：控制语句分为三类——顺序控制结构、选择控制结构和循环控制结构。 顺序结构
Java项目——瑞吉外卖笔记
做一个善良的人，做好自己的事，如果愿意，再发一份光。
04-06 1025
需要掌握：Java基础知识Java WebMySQLMaven学完后会掌握——了解企业项目开发的完整流程，增长开发经验了解需求分析的过程，提高分析和设计能力对所学技术进行灵活应用，提高编码能力解决各种异常情况，提高代码调试能力1.移动端与管理后台展示2.项目上线后3.管理后台登录4.管理后台详细页面两端应用过滤器的作用与必要性请求的顺序及层次细化分析效果——JS文件重新启动后，一切都可以了——加入category表，重点字段type。
Java自学笔记——Java流程控制（六）流程控制练习
Blue
05-16 287
目录流程控制练习代码： 流程控制练习 代码： package com.blue.struct; public class TextDemo { public static void main(String[] args) { // 打印三角形 5行 for (int i = 0; i <= 5; i++) { for (int j = 5; j>=i;j--){ System.out.print(
Java学习笔记——网络原理1
qq_38592678的博客
05-21 2016
TCP是有连接的，而UDP是无连接的。​ TCP要想通信需要先建立连接，且需保存对方信息。​ UDP可以直接发送数据，不用保存对方信息(但是写程序的人需要保存，调用UDP api的时候要将对方的信息发送过去)。TCP是可靠传输，而UDP是不可靠传输。​ TCP传输数据有一系列保障数据的传输，如超时重传，应答机制，流量控制，序列号机制，拥塞控制，数据校验。​ UDP的不可靠传输体现在，其发送完数据后不保证数据能够到达目标地址。​ 可靠传输也是有代价的——机制更复杂，传输效率更低。
Java自学笔记——Java流程控制（五）break & continue
Blue
05-16 367
目录break & continue1. break代码:2. continue代码1：代码2： break & continue break在任何循环语句的主体部分，均可用 break控制循环的流程。 break用于强行退出循环，不执行循环中剩余的语句。( break语句也在 switch语句中使用) continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定. 关于goto关键字 ◆ goto关键字很早就在程序设
Java自学笔记——Java流程控制（二）顺序结构
Blue
05-09 226
Java流程控制目录 Java自学笔记——Java流程控制（一）用户交互Scanner——next（） nextLine（） 顺序结构 JAVA的基本结构就是顺序结构,除非特别指明,否则就按照顺序一句一句执行。 顺序结构是最简单的算法结构。 语句与语句之间,框与框之间是按从上到下的顺序进行的,它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。 package com.blue.struct; public class ShunXuDemo { public st
Java自学笔记——Java流程控制（四）循环结构——While 循环结构
Blue
05-14 589
目录While 循环结构while 循环代码1：代码2代码3：do…while 循环代码1：**代码2：** While 循环结构 while 循环 do.……while 循环 for 循环 在 Java5 中引入了一种主要用于数组的增强型 for 循环。 while 循环 while是最基本的循环,它的结构为: While (布尔表达式) { //循环内容 } 只要布尔表达式为true,循环就会一直执行下去 我们大多数情况是会让循环停止下来的,我们需要一个让表达式失效的方式来结束循环。 少部分
狂神Java学习笔记————前端入门——html、css、JavaScript学习代码
06-17
【狂神Java学习笔记——前端入门——HTML、CSS、JavaScript学习代码】是针对初学者的一份详实的学习资料，这份笔记记录了跟随B站知名up主“遇见狂神说”的java系列视频中关于前端开发的基础内容。笔记内容不仅与视频...
jBPM-jPDL学习笔记——流程设计与控制
04-22
jBPM-jPDL提供了强大的流程控制机制，允许开发者控制流程的执行、监控流程的状态和处理流程的异常。 在流程控制中，我们需要定义流程的执行顺序、流程的状态转换和流程的异常处理。例如，在借款申请流程中，我们...
AIGC学习笔记—minimind详解+训练+推理
m0_56569131的博客
09-27 287
这个开源项目是带我的一个导师，推荐我看的，记录一下整个过程，总结一下收获。这个项目的slogan是“大道至简”，确实很简。作者说是这个项目为了帮助初学者快速入门大语言模型（LLM），通过从零开始训练一个仅26MB的微型语言模型MiniMind，最快可在3小时内完成。降低学习LLM的门槛，让更多人能够轻松上手。MiniMind极其轻量，约为GPT-3的1/7000，适合普通个人GPU进行快速推理和训练。
（笔记）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第2关Python 基础知识
haidizym的博客
10-02 321
学员闯关手册：https://aicarrier.feishu.cn/wiki/ZcgkwqteZi9s4ZkYr0Gcayg1n1g?课程视频：https://www.bilibili.com/video/BV1mS421X7h4/课程文档：https://github.com/InternLM/Tutorial/tree/camp3/docs/L0/Python。
H.264学习笔记
zfenggo的博客
09-26 848
H.264凭借其出色的压缩效率、灵活的编码方式以及高质量的视频表现，成为了现代视频技术的核心标准之一。它不仅减少了存储需求，还提高了流媒体和实时视频传输的可行性。对于从高清到超高清视频，H.264的编码能力仍然广泛适用。H.264的帧结构设计（I帧、P帧和B帧）极大地提高了视频编码的压缩效率。I帧保存完整的图像信息，P帧通过参考之前的帧减少冗余数据，而B帧则通过双向参考提供进一步的压缩优势。这种帧间的协同工作大幅降低了带宽需求和存储成本，同时保持了视频的高质量。NALU头。
江科大笔记—LED闪烁& LED流水灯& 蜂鸣器
m0_62005595的博客
09-28 467
LED闪烁& LED流水灯& 蜂鸣器
【韩顺平Java笔记】第6章：数组、排序和查找
最新发布
随手写写
10-02 514
排序是将多个数据，依指定的顺序进行排列的过程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值