Java流程控制

原创 于 2026-07-26 12:51:14 发布 · 302 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
Java学习（基于各种学习视频所作的笔记）

当前文章被收录于：

Java学习（基于各种学习视频所作的笔记）
4 篇文章 0 人学习

个人在观看Java相关视频所作的笔记和分享 ps.会注明观看的视频作者 JavaSE——B站狂神说Java

订阅专栏 查看详情

顺序结构

Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。

顺序结构是最简单的算法结构。

在这里插入图片描述

语句与语句之间，框与框之间是按照从上到下的顺序进行的，它是由若干个执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

选择结构

if单选择结构

我们很多时候需要去判断一个东西是否可行，然后我们才去执行，这样一个过程在程序中用if语句来表示。

语法：

if (布尔表达式){
    // 如果布尔表达式为true将执行的语句
}

if双选择结构

if (布尔表达式){
    // 如果布尔表达式为true将执行的语句
} else {
    // 如果布尔表达式为false将执行的语句
}

import java.util.Scanner;

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

        System.out.println("请输入成绩：");

        double score = scanner.nextDouble();
        if(score >= 60) {
            System.out.println("及格");
        } else{
            System.out.println("不及格");
        }

        scanner.close();
    }
}

if多选择结构

if (布尔表达式){
    // 如果布尔表达式1为true将执行的语句
} else if {
    // 如果布尔表达式2为true将执行的语句
} else if {
    // 如果布尔表达式3为true将执行的语句
} ...{
    ...
} else {
    // 如果以上布尔表达式都为false将执行的语句
}
  • if语句至多有1个else语句，else语句在所有的else if语句之后。
  • if语句可以有若干个else if语句，它们必须在else语句之前。
  • 一旦其中一个else if 语句检测为true，其他的else if以及else语句 跳过执行。
import java.util.Scanner;

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

        System.out.println("请输入成绩：");

        double score = scanner.nextDouble();

        if (score >= 90 && score <= 100) {
            System.out.println("优秀");
        } else if (score >= 80 && score < 90){
            System.out.println("良好");
        } else if (score >= 60 && score < 80) {
            System.out.println("及格");
        } else if (score >= 0 && score < 60){
            System.out.println("不及格");
        } else {
            System.out.println("成绩不合法，请重新输入");
        }
        
        scanner.close();
    }
}

嵌套的if结构

顾名思义，在一个if语句中使用另外一个if语句。

语法：

if(布尔表达式1){
    // 如果布尔表达式1为true将执行的语句
    if(布尔表达式2){
       // 如果布尔表达式2为true将执行的语句
    }
}

switch多选择结构

switch case语句判断一个变量与与一系列值中某个值是否相等，每个值称为一个分支。

switch语句中的变量类型可以是：

  • byte, short, int 或者char
  • 从Java SE 7开始，switch支持字符串String 类型
  • 同时case标签必须为字符串常量或字面量

语法：

switch(expression){
    case value :
    	// 语句
    	break; // 可选
    case value :
        // 语句
    	break; // 可选
    ...
    default : // 可选
    	// 语句
}

public class SwichDemo01 {
    public static void main(String[] args) {
        // case穿透 --- 没有break语句的话，case匹配成功后，会将下面所有语句执行
        // 所以尽量加上break语句
        char grade = 'B';

        switch (grade){
            case 'A':
                System.out.println("优秀");
                break; // 可选
            case 'B':
                System.out.println("良好");
                break; // 可选
            case 'C':
                System.out.println("及格");
                break; // 可选
            case 'D':
                System.out.println("不及格");
                break; // 可选
            default:
                System.out.println("未知等级");
        }
    }
}

public class SwitchDemo02 {
    public static void main(String[] args) {
        // JDK7的特性，表达式结果可以是字符串！！！
        // 字符的本质还是数字
        // 反编译 java -- class(字节码文件) -- 反编译(IDEA)
        // 直接将class文件拖到IDEA打开即可看到反编译的文件，理解底层原理
        String name = "小明";

        switch (name){
            case "小丁":
                System.out.println("小丁");
                break;
            case "小冰":
                System.out.println("小冰");
                break;
            case "小明":
                System.out.println("小明");
                break;
            default:
                System.out.println("未知姓名");
        }
    }
}

循环结构

  • while循环
  • do…while循环
  • for循环

在Java5中引入了一种主要用于数组的增强型for循环。

while循环

while循环是最基本的循环，其结构为：

while(布尔表达式){
    // 循环内容
}

只要布尔表达式为true，循环就会一直执行下去。**我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。**少部分情况下需要循环一直执行，比如服务器的请求相应监听等。

循环条件一直为true就会造成无限循环（死循环），我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死崩溃！

public class WhileDemo01 {
    public static void main(String[] args) {
        // 输出1-100
        int count = 0;

        while (count < 100){
            count++;
            System.out.println(count);
        }
    }
}

public class WhileDemo02 {
    public static void main(String[] args) {
        // 计算1+2+...+100
        int count = 0;
        int sum = 0;
		
        while(count <= 100){
            sum += count;
            count++;
        }
//        while (++count <= 100){
//            sum += count;
//        }

        System.out.println(sum);
    }
}

do…while

对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件也至少执行一次。

do…while循环和while循环相似，不同的是，do…while循环至少会执行一次。

do {
    // 代码语句
} while(布尔表达式);

while和do…while的区别:

  • while先判断后执行。do…while是先执行后判断。
  • do…while总是保证循环体至少会被执行一次，这是主要的差别。
public class DoWhileDemo01 {
    public static void main(String[] args) {
        int count = 0;
        int sum = 0;

        do {
            sum += count;
            count++;
        } while (count <= 100);

        System.out.println(sum);
    }
}

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

        while (a < 0){
            System.out.println(a);  // 未执行
            a++; // 未执行
        }

        System.out.println(a); // 0

        System.out.println("==============");
        do {
            System.out.println(a); // 0
            a++;
        } while(a < 0);

        System.out.println(a); // 1
    }
}

For循环（必须熟练掌握）

虽然所有循环结构都可以用while或者do…while表示，但Java提供了另一种语句—for循环，是一些循环结构变的简单。

for循环语句是 支持迭代的一种通用结构，是最有效、最灵活的循环结构。

for循环语句的次数是在执行前就确定的。语法格式如下：

for(初始化;布尔表达式;更新){
    // 代码语句
}

在IDEA的快捷写法，可以直接在数字后面加入".for"，快速生成默认的for语句。默认情况下，变量为i，初始化为0，条件判断为"<“该数字，更新为"i++”。或者直接输入"fori"，也会生成默认结构。

public class ForDemo01 {
    public static void main(String[] args){
        int a = 1;  // 初始化条件

        while (a <= 100) {// 条件判断
            System.out.println(a);  // 循环体
            a += 2;
        }

        System.out.println("while循环结束！");

        for (int i = 1; i <= 100; i += 2){
            System.out.println(i);
        }


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

关于for循环有以下几点说明：

  1. 最先执行初始化步骤，可以声明一种类型，还可初始化一个或多个循环控制变量，也可以是空语句。
  2. 然后检测布尔表达式的值，如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
  3. 执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）。
  4. 再次检测布尔表达式，循环执行上面的过程。
// 死循环
for (; ; ) {
}

下面是几道练习题：

public class ForDemo02 {
    public static void main(String[] args) {
        // 练习1：计算0到100之间的奇数和偶数的和
        int sum_odd = 0;
        int sum_even = 0;

        for (int i = 1; i <= 100; i += 2) {
            sum_odd += i;
        }

        System.out.println("sum_odd:" + sum_odd);

        for (int i = 0; i <= 100; i += 2) {
            sum_even += i;
        }

        System.out.println("sum_even:" + sum_even);
        
        // 上面的写法其实有点冗余
        
        int oddSum = 0;
        int evenSum = 0;
        
        for (int i = 0; i <= 100; i++) {
            if (i % 2 = 0){
                evenSum += i;
            } else {
                oddSum += i;
            }
        }
        
    }
}

public class ForDemo03 {
    public static void main(String[] args) {
        // 用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个
        int cnt = 1;

        while(cnt <= 1000) {
            if(cnt % 5 == 0){
                System.out.print(cnt + "\t");
                if (cnt % 3 == 0){
                    System.out.println();
                }
            }
            cnt++;
        }

        System.out.println();
        System.out.println("=====================");

        int count = 1;
        for (int i = 5; i <= 1000; i += 5) {  // 利用计数变量，且减少循环次数
            System.out.print(i + "\t");
            if(count % 3 == 0){
                System.out.println();
            }
            count++;
        }

        System.out.println();
        System.out.println("=====================");

        for (int i = 5; i <= 1000; i++) {
            if (i % 5 == 0){
                System.out.print(i + "\t");
            }

            if (i % (5 * 3) == 0){     // 不嵌套到if里面，需要同时符合整除5和整除3
                System.out.println();
            }
        }
    }
}

其实第二个和第三个的只要是先计算整除3还是先计算整除5的区别。而第一个是直接先满足整除5的条件下，再满足整除3。

// 1*1=1
// 1*2=2	2*2=4
// 1*3=3	2*3=6	3*3=9
// 1*4=4	2*4=8	3*4=12	4*4=16
// 1*5=5	2*5=10	3*5=15	4*5=20	5*5=25
// 1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36
// 1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49
// 1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64
// 1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

public class ForDemo04 {
    public static void main(String[] args) {
        for (int j = 1; j <= 9 ; j++) {
            // 打印九九乘法表
            for (int i = 1; i <= j; i++) {  // i<=j去除重复项
                System.out.print(i + "*" + j + "=" + (j * i) + "\t");
            }
            System.out.println();
        }
    }
}
增强for循环

这里我们先只是见一面，做个了解，之后数组我们重点使用。

Java5引入了一种主要用于数组或集合的增强型for循环。

Java增强for循环语法格式如下：

for(声明语句 : 表达式){
    // 代码句子
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

public class ForDemo05 {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};

        for (int i = 0; i < 5; i++) {
            System.out.println(numbers[i]);
        }

        System.out.println("===========================");

        // 遍历数组的元素
        for (int x : numbers){
            System.out.println(x);
        }
    }
}

break和continue语句

break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）

continue语句在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

public class BreakDemo {
    public static void main(String[] args) {
        int i = 0;
        while (i < 100){
            i++;
            
            System.out.print(i + " ");
            
            if (i >= 30){
                break;
            }
        }
        
        System.out.println("123");
    }
    // 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 123
}

public class ContinueDemo {
    public static void main(String[] args) {
        int i = 0;
        while (i < 100){
            i++;

            if (i % 10 == 0){
                System.out.println();
                continue;
            }
            System.out.print(i + " ");
        }
    }
//        1 2 3 4 5 6 7 8 9
//        11 12 13 14 15 16 17 18 19
//        21 22 23 24 25 26 27 28 29
//        31 32 33 34 35 36 37 38 39
//        41 42 43 44 45 46 47 48 49
//        51 52 53 54 55 56 57 58 59
//        61 62 63 64 65 66 67 68 69
//        71 72 73 74 75 76 77 78 79
//        81 82 83 84 85 86 87 88 89
//        91 92 93 94 95 96 97 98 99
}

关于goto关键字（了解即可）：

  • goto关键字很早就在程序设计语言中出现。尽管goto关键字仍是Java的一个保留字，但并未在语言中得到正式使用；Java没有goto。然而，在break和continue这两个关键字身上，我们仍然可以看到一些goto的影子——带标签的break和continue。
  • ”标签“是指后面跟一个冒号的标识符，例如：label:
  • 对Java来说唯一用到标签的地方是在循环语句之前，而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断在存在标签的地方。
public class LabelDemo {
    public static void main(String[] args) {
        // 打印100-150之间所有的质数

        // 质数是大于1的自然数中，除了1和它本身以外不在其他因数的自然数。

        int cnt = 0;

        outer:for (int i = 101; i < 150; i++) {
            for (int j = 2; j < i / 2; j++) {
                if (i % j == 0) {
                    continue outer; // 不是质数，返回到标签处
                }
            }
            System.out.print(i + " ");
        }

    }
}

练习——打印三角形

我个人对打印三角形这种题目的理解是，可以按照正常的思路从左往右依次打印，把空格，'*'都想成一个字符，根据外层循环的次数，找到这个循环的次数与内层需要打印字符个数之间的关系，写出来即可。菱形本质就是两个三角形的组合，其他图形也按照这种规律进行理解。也可以在IDEA利用debug慢慢去理解每一层循环。

//     *
//    ***
//   *****
//  *******
// *********
public class TestDemo01 {
    public static void main(String[] args) {
    // 打印三角形 5行
    // 下面思路是先打印空格（4个，3个，2个，1个，0个），再打印*的对应行个数（1个，3个，5个，7个，9个）
        for (int i = 0; i < 5; i++) {
            for (int k = 0; k < 4 - i; k++) {
                System.out.print(" ");
            }
            for (int j = 0; j < 2 * i + 1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
        
        System.out.println("======================");

   // 下面思路是完全按照从左往右理解的，先打印左半部分空格，再打印左半部分*，再打印右半部分*
        for (int i = 0; i < 5; i++) {
            for (int j = 5; j > i + 1 ; j--) {
                System.out.print(" ");  // 打印空格，但只需前四行打印即可
            }
            for (int j = 0; j <= i; j++) {
                System.out.print("*");  // 打印左半部分*
            }
            for (int j = 0; j < i; j++) {
                System.out.print("*");  // 打印右半部分*
            }
            System.out.println();
        }
    }
}
标签
#java #开发语言
Java流程控制详解
波哩个波的博客
09-08 7093
一、流程控制概述 在Java程序中，JVM默认总是顺序执行以分号;结束的语句。但是，在实际的代码中，程序经常需要做条件判断、循环，因此，需要有多种流程控制语句，来实现程序的跳转和循环等功能。 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即： 顺序结构 分支结构 ...
Java流程控制语句
热门推荐
ThinkWon的博客
09-28 3万+
定义 流程是指程序运行时，各语句的执行顺序。流程控制语句就是用来控制程序中各语句执行的顺序。 分类 顺序结构 Java流程控制语句-顺序结构 分支结构（选择结构） Java流程控制语句-分支结构（选择结构） 循环结构 Java流程控制语句-循环结构 ...
java学习之流程控制
踏雪寻梅
04-23 278
编写代码如下： package 第1章.java概要; public class _4_流程控制 { //if-else public static void testIfElse(int num){ System.out.println(" num = " + num); if(num < 10){ System.out.println(" num < 10...
java流程控制
weixin_73485327的博客
12-03 1686
System.out.println("输入的数字的平均数为："+(sum/m));System.out.println("你输入的是一个整数数据："+i);System.out.println("你输入的是一个小数数据："+f);System.out.println("使用next用法："+str1);System.out.println("输入的数字总和为："+sum);System.out.println("请输入一个数据：");System.out.println("请输入数据：");
Java的流程控制
最新发布
m0_64455221的博客
02-05 709
1.经典for循环，while循环，do-while循环2循环三要素：循环变量的声明和初始化，循环条件，循环步长3.for循环适用于知道循环次数的场景，while和do-while适用于不知道循环次数的场景4.for循环和while循环都是先执行循环条件，当条件成立时才会执行循环体，do-while是先执行一次循环体再执行判断条件。拓展：死循环：不能结束的循环就是死循环，应该尽量避免。for循环的其他写法1.可以讲循环起点放在for关键字之前写2.循环步长可以放到循环体的最后一行3。
java 流程控制_JAVA流程控制
weixin_31444279的博客
02-16 246
java的流程控制结构有三种：顺序、选择、循环 顺序结构：Java的基本结构就是顺序结构，除非特别指明，否则就是按照顺序一句一句执行。顺序结构是最简单的算法结构。语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。选择结构：我们很多时候需要去判断一个东西是否可行，然后我们才去执行，这样一个过程在程序...
java 流程控制_Java流程控制
weixin_42467088的博客
02-12 82
Java流程控制Java语言的出现背景、主要特点、发展历程以及Java技术的.应用，指出 Java 是当今IT产业和人类文明的创新和希望。下面小编为你分享Java流程控制，欢迎大家阅读！更多相关信息请关注相关栏目！Java流程控制的语法与 C/C++ 类似，也有 if...else、while、do...while、for、switch...case等，这里不再讲述具体语法，仅举例说明。输出九九乘...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值