Java的学习之路（Chp3 流程控制）

最新推荐文章于 2025-12-16 16:02:25 发布

原创最新推荐文章于 2025-12-16 16:02:25 发布 · 111 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #学习 #开发语言

Java学习之路专栏收录该内容

4 篇文章

订阅专栏

本文介绍了Java中的流程控制结构，包括Scanner类用于读取用户输入，if语句的使用及其语法，以及else分支的可选性。还探讨了多重分支的实现，如if...elseif...else结构和switch语句，并展示了它们在处理不同条件下的应用。此外，文章讲解了for、while和do...while循环的用法，以及break和continue在循环中的作用，最后提到了多重循环和如何在多层循环中使用break和continue。

Chp3 流程控制

0 读入数据

java.util.Scanner——一个非常简单的用来读入数据的类

//引入Scanner类
import java.util.Scanner;
public class TestScanner{
public static void main (String args[]){
    Scanner sc = new Scanner(System.in);        //创建了一个Scanner对象，为读入数据做准备
    System.out.println("请输入一个字符串：");
    String str = sc.nextLine();                 //读入一行字符串可以用sc.nextLine()语句
    System.out.println(str + "收到了！");
    System.out.println("请输入一个整数：");
    int n = sc.nextInt();                       //读入整数时，使用sc.nextLine语句
    System.out.println("请输入一个小数：");
    double d = sc.nextDouble();                   //读入浮点数时，使用sc.nextDouble语句
    System.out.println(n * d);
 }
}

运行结果如下：

1分支结构

1.1if语句

import java.util.Scanner;
public class TestDivid{
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int a = 10;
        int b = sc.nextInt();
        System.out.println(a/b);
 }
}

这段代码读取一个整数b的值，然后计算a/b

然而当b=0时，由于除法的除数不能为0，就产生了错误，如下图所示：

1.1.1if语句的基本语法

最基础的if语句语法的结构为：

if(布尔表达式）{
    代码块1
}
else{
    代码块2
}

有了if语句就可以对之前的TestDivide.java进行改写，修改后的代码如下：

import java.util.Scanner;
public class TestDivid{
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int a = 10;
        int b = sc.nextInt();
        if (b != 0){
            System.out.println(a/b);
        }
        else{
            System.out.println("b不能为0");
        }
        System.out.println(a/b);
    }
}

上面的代码，对b是否为0进行了判断，避免了编译错误的情况。

例：

import java.util.Scanner;
public class TestBiggerThanTen{
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        if (n > 10);{
            System.out.println("statement 1");
            System.out.println("statement 2");
        }
        else{
            System.out.println("statement 3");
            System.out.println("statement 4");
        }
    }
}

上边这段代码读入一个整数，如果这个整数大于10，则输出statement 1和statement 2，

如下图所示：

当输入的整数小于10时，则输出statement 3和statement 4。如下图所示：

if语句还有两种变化的形式

第一、else语句可以省略。当只需要执行条件为真的操作，当条件为假时不执行任何操作的时候，可以省略else。代码如下：

import java.util.Scanner;
public class TestAbs{
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int n =sc.nextInt();
        if(n > 0){
            n = -n;
        }
        System.out.println("绝对值为" + n);
    }
}

当n为负数时，n的绝对值为-n。而当n为正数和0时，n是本身，不需要执行代码。所以上述代码中的else可以省略。运行结果如下：

第二、当if或者else后面的代码块中只有一个语句时，花括号可以省略。例如TestDivide中

 if (b != 0){
    System.out.println(a/b);
        }
else{
    System.out.println("b不能为0");
        }

可以写成下边形式：

 if (b != 0)
            System.out.println(a/b);
        
        else
            System.out.println("b不能为0");

1.1.2流程图

int a;
a = sc.nextInt();
System.out.println(a);

这段代码执行了这些操作：定义变量，读取变量的值，输出变量。

        int n = sc.nextInt();
        if (n > 10){
            System.out.println("statement 1");
            System.out.println("statement 2");
        }else{
            System.out.println("statement 3");
            System.out.println("statement 4");
        }

这段代码可以完成一个菱形判断流程图

1.1.3用if语句做多重分支

Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
if(score>=0 && score<60){
    System.out.println("E");
}else if(score>=60 && score<70){
    System.out.println("D");
}else if(score>=70 && score<80){
    System.out.println("C");
}else if(score>=80 && score<90){
    System.out.println("B");
}else if(score>=90 && score<100){
    System.out.println("A");
}else{
    Syetem.out.println("Error!");
}

首先判断整数是否是大于等于0 且小于60，如果满足这个条件，则学生成绩为E，输出E；以此类推……

if…elseif…else，是一种很常见的语法结构，其结构的语法如下：

if(条件1){
    条件1的代码块
}else if (条件2){
    条件2的代码块
}else if (条件3) {
    条件3的代码块
}
…
else{
    所有条件都不满足时的代码块
}

1.2swich语句

根据输入不同的值，进入多个不同的流程，这种程序结构成为多重分支。在Java中，用switch语句来完成多重分支。最基本的语法如下：

switch(表达式){
    case value1 :
        语句块1;
        break;
    case value2 :
        语句块2;
        break;
    case value3 ：
        语句块3;
        break;
    …
    case valueN ：
        语句块N;
        break;
    default :
        default语句块;
        break;
}

switch语句会根据表达式的值不同，对每一个case所对应的value进行比较。如果有一个value与表达式的值相等，则流程跳转到该case语句的位置。

例如，我们从命令行读入一个整数，整数范围是1~5，分别表示成绩"A"~"E"。然后根据整数的不同，输出该等级的成绩范围。例如，如果读入的值是1，则表示“A”级，输出90~100；如果读入的值是3，则表示“C”级，输出70~79。

利用switch语句，基本代码如下：

import java.util.Scanner;
public class  TestSwitch{
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        switch(n)(){
            case 1 :
                System.out.println("恭喜你！成绩不错！")；
                System.out.println("90~100");
                break;
            case 2 :
                System.out.println("80~89");
                break;
            case 3 :
                System.out.println("70~79");
                break;
            case 4 :
                System.out.println("60~69");
                break;
            case 5 :
                System.out.println("0~59");
                System.out.println("不及格，要加油咯");
                break;
            default :
                System.out.println("输入错误");
                break;
        }
    }
}

虽然switch语句能够做多重分支，但是不能做范围上的判断。例如可以表示读入值为1，2时候如何，却不能表示读入值在50~100范围内如何。

此外，switch语句只能用来判断四种类型的值：byte、short、int、char。也就是说，switch语句的圆括号中，表达式的值只能是这四种类型。

2循环控制

从四个方面思考：

1、初始化：指的是循环开始之前，所需要做的准备工作。

2、循环条件：指的是控制循环是否能够继续的条件。

3、循环体：指的是需要反复执行的重复性操作。

4、迭代操作：每次执行循环体时所产生的不同。

迭代操作往往是和循环条件联系在一起的，在迭代操作中，往往会修改循环条件中使用的变量值。

但是并不是每一个循环都具有四个要素，有些循环里，循环条件和迭代操作是同一个语句，等等。

2.1for循环

for循环的语法如下：

for(初始化;循环条件;迭代操作){
    循环体;
}

例：用for循环输出10个HelloWorld

public class TestFor{
    public static void main(String args[]){
        int i;                                    
//定义了一个变量i,i用来总共循环了多少次，成为计数器
        for(i = 0;i < 10;i++){
//初始化就是把计数器清零，每循环一次i就加一，因此迭代操作是i++,循环条件则是判断循环的次数
            System.out.println(i + "HelloWorld");
        }
    }
}

例：求出sum=1+2+3+...+50

public class TestSum {
    public static void main(String[] args){
        int sum = 0;
        for(int i = 1;i<=50;i++){
            sum = sum + i;
        }
        System.out.println(sum);
    }
}

结果如下：

2.2while循环和do...while循环

while循环语法：

while(循环条件){
    循环体
}

do...while循环语法：

do{
    循环体
}while(循环条件);

两种循环，循环条件的含义是一样的：当布尔表达式为true时，循环继续；为false时，循环退出。

两种循环都没有单独的地方写迭代操作，如果需要，应当写入循环体中。

例：用while循环输出10个HelloWorld

public class TestWhile {
    public static void main(String[] args) {
        int i = 0;
        while (i<10){
            System.out.println(i + "HelloWorld");
            i++;
        }
    }
}

例：用do...while循环输出10个HelloWorld

public class TestDoWhile {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println(i + "HelloWorld");
            i++;
        }while (i < 10);
    }
}

例：

public class TestLoop {
    public static void main(String[] args) {
        int i = 100;
        while (i < 10){
            System.out.println(i + "HelloWorld");
            i++;
        }
    }
}

这段代码在进入循环体之前先判断，由于循环条件为假，所以没有输出。

例：

public class TestLoop2 {
    public static void main(String[] args) {
        int i = 100;
        do {
            System.out.println(i + "HelloWorld");
            i++;
        }while (i < 10);
    }
}

由于先进入循环体，所以先执行一次，执行完后i变为101，判断循环条件为假，退出循环。

三种循环如何选择：

①能够确定次数的循环，用for循环；相反，如果循环次数不确定，就用while或者do...while循环。

②如果要对循环变量进行赋值操作，用while循环

③如果循环体至少需要执行一次，用do...while循环

2.3break和continue

break会跳出for循环，而continue是跳出本次循环

例：

public class TestBreak {
    public static void main(String[] args) {
        for (int i = 0;i <= 5;i++) {
            if (i == 3) break;
            System.out.println("i=" + i);
        }
    }
}

运行结果如下：

例：

public class TestContinue {
    public static void main(String[] args) {
        for (int i = 0;i <= 5;i++){
            if (i == 3) continue;
            System.out.println("i="+i);
        }
    }
}

结果如下：

2.4多重循环

例：从命令行读取一个正整数，根据正整数输出不同行数的*

import java.util.Scanner;

public class TestStar {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for (int i = 1;i <= n;i++){
            for (int j = 1;j <= i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

运行结果如下：

在外层循环的基础上，再嵌套一个内层循环，这种结构叫循环的嵌套。

如果嵌套只有两层，成为二重循环。如果有多层循环之间嵌套，成为多重循环。

2.5多重循环下的break和continue

public class TestBreakContinue {
    public static void main(String[] args) {
        for (int i = 1;i <= 3;i++){
            for (int j = 1;j <= 4;j++){
                System.out.println("i=" + i + "j=" + j);
            }
        }
    }
}

输出结果如下：

如果增加一个break语句：

public class TestBreakContinue {
    public static void main(String[] args) {
        for (int i = 1;i <= 3;i++){
            for (int j = 1;j <= 4;j++){
                if(j == 3) break;
                System.out.println("i=" + i + "j=" + j);
            }
        }
    }
}

输出结果如下：

为了在break语句中区分内层和外层循环，首先给两层循环分别起个名字，也就是循环的标签。（该标签必须符合标识符的语法）代码如下：

public class TestBreakContinue {
    public static void main(String[] args) {
        outer:for (int i = 1;i <= 3;i++){
            inner:for (int j = 1;j <= 4;j++){
                if(j == 3) break outer;
                System.out.println("i=" + i + "j=" + j);
            }
        }
    }
}

当i=1，j=3的时候，执行break outer。这样就跳出了外层循环。输出结果如下：

同样的，continue也有类似的使用方式，代码如下:

public class TestBreakContinue {
    public static void main(String[] args) {
        outer:for (int i = 1;i <= 3;i++){
            inner:for (int j = 1;j <= 4;j++){
                if(j == 3) continue outer;
                System.out.println("i=" + i + "j=" + j);
            }
        }
    }
}

执行continue的时候，会让continue语句对outer标签起作用，因此程序会跳转到外层循环的最末尾，然后执行外层循环的迭代操作。运行结果如下：