第三章、流程控制语句结构

最新推荐文章于 2022-05-04 13:21:30 发布

爱码者

最新推荐文章于 2022-05-04 13:21:30 发布

阅读量1.3k

点赞数 1

分类专栏： JavaSE

本文链接：https://blog.csdn.net/weixin_41043145/article/details/93780940

版权

JavaSE 专栏收录该内容

39 篇文章 17 订阅

订阅专栏

前言：

根据语句执行的特点：

（1）顺序结构

从上往下顺序执行的语句。

（2）分支结构

多个分支中只会选择一个执行

（3）循环结构

需要重复/反复执行某些语句时

输入与输出语句

其它类型输入：

数据类型变量名 = java.util.Scanner.nextXXX(); //XXX:表示数据类型

注意：char类型的输入。

① 需要先输入字符串（String引用数据类型）

String str = java.util.Scanner.next();

② 再使用charAt(下标位);进行接收

上两步结合：

String str = java.util.Scanner.next().charAt(下标位);

一、顺序结构

任何编程语言中最常见的程序结构就是顺序结构。顺序结构就是程序从上到下逐行地执行，中间没有任何判断和跳转。如果main方法的多行代码之间没有任何流程控制，则程序总是从上向下依次执行，排在前面的代码先执行，排在后面的代码后执行。

public static void main(String[] args){

//顺序执行，根据编写的顺序，从上到下运行

System.out.println(1);

System.out.println(2);

System.out.println(3);

}

二、复合语句

与C语言及其他语言相同，Java语言的复合语句是以整个块区为单位的语句，所以又称为块语句。复合语句由开括号“{”开始，闭括号“}”结束。

复合语句中的每一语句都是从上到下执行。复合语句以整个块为单位，并且在复合语句中可以嵌套复合语句。

Java代码结构：

class 类{

{

//代码块

}

方法签名{

//方法体

}

内部类{

内部类体

}

复合语句为变量创建了一个作用域。在该作用域中某个变量被创建并能够使用，如果在某个变量的作用域外使用该变量，则会发生错误。

三、分支结构

1、条件判断（if ...else）

1.1单分支条件判断

1.1.1 语法格式

if(关系表达式)｛

语句体;

｝

1.1.2 执行流程

（1表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量。

（2块只有一个语句时，{}可以省略，但是建议保留

执行过程：

条件成立就执行，条件不成立就不执行。

1.2双分支结构

1.2.1 语法格式

if(条件表达式){

//当条件表达式结果为true时，需要执行的语句块1

}else{

//当条件表达式结果为false时，需要执行的语句块2

}

1.2.2 执行流程

当条件成立执行语句块1，不成立执行语句块2

说明：

（1）条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量。

（2）if或else的语句块只有一个语句时，{}可以省略，但是建议保留

1.3多分支结构

1.3.1 语法格式

if(条件表达式1){

//当条件表达式1结果为true时，需要执行的复合语句1

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

//当条件表达式2结果为true时，需要执行的复合语句2

}

....

【else{

//当上述条件表达式结果都为false时，需要执行的语句

}】

1.3.2 执行流程

从上至下判断条件，如果一旦某个条件成立了，就执行对应的语句块，后面的条件就不看了，如果所有条件都不满足，如果存在else，那么执行else，如果不存在else，就什么也不执行。

注意：

（1）每个if或者else后面的{}不是必须的，但是如果没有{}，默认只能带一条语句。即if或else后面的语句块只有一条语句时，可以省略{}，但是可读性不够好。

（2）最后的else不是必须的，可以缺省

（3）当多个条件是互斥关系时，顺序无所谓

当多个条件是包含关系时，“小上大下/子上父下”

1.4嵌套

在if的语句块中，或者是在else语句块中，

又包含了另外一个条件判断（可以是单分支、双分支、多分支）

执行的特点：

（1）如果是嵌套在if语句块中的

只有当外部的if条件满足，才会去判断内部的条件

（2）如果是嵌套在else语句块中的

只有当外部的if条件不满足，进入else后，才会去判断内部的条件

2、选择结构（switch...case）

2．1语法格式：

switch(表达式){

case 常量值1:

语句块1;

【break;】

case 常量值2:

语句块2;

【break;】

case 常量值3:

语句块3;

【break;】

....

【default：

语句块n+1;

【break;】

】

}

说明：

default的分支，可以在任意位置，只是习惯上我们写在最后，但是不管在哪里，

都是先判断case的值，然后再去看default。

2.2 执行特点：因为switch可能存在“贯穿”

（1）入口

A：当switch(表达式)的值与某一个case后面的常量值匹配了，就会从这个case进入

B：当switch(表达式)的值与所有的case后面的常量值都不匹配，从default进入

（2）只要找到“入口”，就会一直“贯穿”执行，直到遇到“出口”为止

（3）出口

A：switch的结束 }

B：break

要求：

（1）case后面必须是常量

（2）case后面的常量值不能重复

（3）case后面的常量值必须与switch(表达式)的类型一致或兼容

（4）switch(表达式)的类型只能是如下几种类型

四种基本数据类型：byte,short,int,char

两种引用数据类型：JDK1.5枚举，JDK1.7String

四、循环结构

（1）循环语句：for循环

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要通过修改循环变量使得循环判断条件为false，从而结束循环，否则循环将一直执行下去，形成死循环。

1、for循环语句格式：

for(初始化语句①; 循环条件语句②; 迭代语句④){
    循环体语句③
}
for(;;){
    循环体语句块；//如果循环体中没有跳出循环体的语句，那么就是死循环
}

注意：

（1）for(;;)中的两个；是不能多也不能少

（2）循环条件必须是boolean类型

（3）如果循环条件语句②省略的话，就默认为循环条件成立

执行流程：

第一步：执行初始化语句①，完成循环变量的初始化；
第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；
- 如果是true，执行第三步；
- 如果是false，循环语句中止，循环不再执行。
第三步：执行循环体语句③
第四步：执行迭代语句④，针对循环变量重新赋值
第五步：根据循环变量的新值，重新从第二步开始再执行一遍

语法演示案例1：打印10次的HelloWorld

public class ForDemo01 {
    public static void main(String[] args) {
    //控制台输出10次HelloWorld，不使用循环
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("-------------------------");

        //用循环改进，循环10次
        //定义变量从10开始，循环条件为<=10
        for(int x = 1; x <= 10; x++) {
            System.out.println("HelloWorld"+x);
        }
    }
}

语法演示案例2：打印1-5和5-1

/*
 * 练习：利用for语句打印1-5和5-1
 */
public class ForTest01 {
    public static void main(String[] args) {
        //原始做法
        System.out.println(1);
        System.out.println(2);
        System.out.println(3);
        System.out.println(4);
        System.out.println(5);
        System.out.println("===============");
        
        //用循环改进
        for(int x=1; x<=5; x++) {
            System.out.println(x);
        }
        System.out.println("===============");
        
        //1-5的数据我们获取到了，如何获取5-1呢?
        for(int x=5; x>=1; x--){
            System.out.println(x);
        }
    }
}

语法演示案例3：求出1-5之间数据之和

/*
 * 练习：求出1-5之间数据之和
 * 
 * 分析：
 *      1.定义求和变量，初始化值是0
 *      2.获取1-5之间的数据，用for循环实现
 *      3.把每一次获取到的数据，累加起来就可以了
 *      4.输出求和变量即可
 */
public class ForTest02 {
    public static void main(String[] args) {
        //定义求和变量，初始化值是0
        int sum = 0;
        
        //获取1-5之间的数据，用for循环实现
        for(int x=1; x<=5; x++) {
            //把每一次获取到的数据，累加起来就可以了
            //sum = sum + x;
            /*
             * 第一次：sum = 0 + 1 = 1
             * 第二次：sum = 1 + 2 = 3
             * 第三次：sum = 3 + 3 = 6
             * 第四次：sum = 6 + 4 = 10
             * 第五次：sum = 10 + 5 = 15
             */
            sum += x;
        }
        
        //输出求和结果
        System.out.println("sum:" + sum);
    }
}

语法演示案例4：求出1-100之间偶数和

/*
 * 练习：求出1-100之间偶数和
 * 
 * 分析：
 *      1.定义求和变量，初始化值是0
 *      2.获取1-100之间的数据，用for循环实现
 *      3.把获取到的数据进行判断，看是否是偶数
 *          如果是，就累加
 *      4.输出求和结果
 */
public class ForTest03 {
    public static void main(String[] args) {
        //定义求和变量，初始化值是0
        int sum = 0;
        
        //获取1-100之间的数据，用for循环实现
        for(int x=1; x<=100; x++) {
            //把获取到的数据进行判断，看是否是偶数
            if(x % 2 == 0) {
                sum += x;
            }
        }
        
        //输出求和结果
        System.out.println("sum:"+sum);
    }
}

（2）循环结构：while循环

1、while循环语句标准格式：

while (循环条件语句①) {
    循环体语句②；
}

注意：

while(循环条件)中循环条件必须是boolean类型

执行流程：

第一步：执行循环条件语句①，看循环条件语句的值是true，还是false；
- 如果是true，执行第二步；
- 如果是false，循环语句中止，循环不再执行。
第二步：执行循环体语句②；
第三步：循环体语句执行完后，重新从第一步开始再执行一遍

2、while循环语句扩展格式：

初始化语句①；
while (循环条件语句②) {
    循环体语句③；
    迭代语句④；
}

执行流程：

第一步：执行初始化语句①，完成循环变量的初始化；
第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；
- 如果是true，执行第三步；
- 如果是false，循环语句中止，循环不再执行。
第三步：执行循环体语句③
第四步：执行迭代语句④，针对循环变量重新赋值
第五步：根据循环变量的新值，重新从第二步开始再执行一遍

语法演示案例1：遍历1-100之间的偶数

int num = 2;
while(num<=100){
    System.out.println(num);
    num+=2;
}

语法演示案例2：趣味折纸

/*
 *  练习：趣味折纸
 *  
 *  题目：
 *      世界最高山峰是珠穆朗玛峰，它的高度是8844.43米，假如我有一张足够大的纸，它的厚度是0.1毫米。
 *      请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
 */
public class WhileTest01 {
    public static void main(String[] args) {
        //定义一个计数器，初始值为0
        int count = 0;
        
        //定义纸张厚度
        double paper = 0.1;
        
        //定义珠穆朗玛峰的高度
        int zf = 8844430;
        
        //因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
        //折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
        while(paper <= zf) {
            //循环的执行过程中每次纸张折叠，纸张的厚度要加倍
            paper *= 2;
            
            //在循环中执行累加，对应折叠了多少次
            count++;
        }
        
        //打印计数器的值
        System.out.println("需要折叠：" + count + "次");
    }
}

（3）循环结构：do...while循环

1、do...while循环语句标准格式：

do {
    循环体语句①；
} while (循环条件语句②)；

注意：

（1）while(循环条件)中循环条件必须是boolean类型

（2）do{}while();最后有一个分号

（3）do...while结构的循环体语句是至少会执行一次，这个和for和while是不一样的

执行流程：

第一步：执行循环体语句①；
第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；
- 如果是true，执行第三步；
- 如果是false，循环语句终止，循环不再执行。
第三步：循环条件语句执行完后，重新从第一步开始再执行一遍

2、do...while循环语句扩展格式：

初始化语句①
do {
    循环体语句②；
    迭代语句③；
} while (循环条件语句④)；

执行流程：

第一步：执行初始化语句①，完成循环变量的初始化；
第二步：执行循环体语句②；
第三步：执行迭代语句③，针对循环变量重新赋值；
第四步：执行循环条件语句④，看循环条件语句的值是true，还是false；
- 如果是true，根据循环变量的新值，重新从第二步开始再执行一遍；
- 如果是false，循环语句中止，循环不再执行。

语法演示案例1：统计正数、负数个数

    public static void main(String[] args) {
        java.util.Scanner input = new java.util.Scanner(System.in);
        
        int positive = 0;
        int negative = 0;
        int num;
        do{
            System.out.print("请输入整数（0）结束：");
            num = input.nextInt();
            if(num>0){
                positive++;
            }else if(num<0){
                negative++;
            }
        }while(num!=0);
        System.out.println("正数：" + positive + "个，负数：" + negative +"个");
    }

（4）循环语句的区别

从循环次数角度分析
- do...while循环至少执行一次循环体语句
- for和while循环先循环条件语句是否成立，然后决定是否执行循环体，至少执行零次循环体语句
从循环变量的生命周期角度分析
- for循环的循环变量在for()中声明的，在循环语句结束后，不可以被访问；
- while和do...while循环的循环变量因为在外面声明的，所以while和do...while结束后可以被继续使用的；
如何选择
- 遍历有明显的循环次数（范围）的需求，选择for循环
- 遍历没有明显的循环次数（范围）的需求，循环while循环
- 本质上：三种循环之间是可以互相转换的，都能实现循环的功能
三种循环结构都具有四要素：
- （1）循环变量的初始化表达式
- （2）循环条件
- （3）循环变量的修改的迭代表达式
- （4）循环体语句块

（5）控制语句

1、 break

使用场景：终止switch或者当前循环
- 在选择结构switch语句中
- 在循环语句中
- 离开使用场景的存在是没有意义的

语法案例演示1：判断某个数是否是素数

    public static void main(String[] args){
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("请输入一个正整数：");
        int num = input.nextInt();
        
        boolean flag = true;
        for (int i = 2; i <= Math.sqrt(num) ; i++) {
            if(num%i==0){
                flag = false;
                break;
            }
        }
        System.out.println(num + (flag?"是":"不是") + "素数");
    }

语法案例演示2：统计正数、负数个数

    public static void main(String[] args) {
        java.util.Scanner input = new java.util.Scanner(System.in);
        
        int positive = 0;
        int negative = 0;
        while(true){
            System.out.print("请输入整数（0）结束：");
            int num = input.nextInt();
            if(num==0){
                break;
            }else if(num>0){
                positive++;
            }else{
                negative++;
            }
        }
        System.out.println("正数：" + positive + "，负数：" + negative);
    }

2、 continue

使用场景：结束本次循环，继续下一次的循环

public static void main(String[] args) {
    for (int i = 1; i <= 10; i++) {
        //需求:不打印3的倍数
        if(i % 3 == 0){
            continue;
        }
        System.out.println(i);
    }
}

（6）嵌套循环

所谓嵌套循环，是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数。当然可以是三种循环任意互相嵌套。
- 嵌套循环格式：

for(初始化语句①; 循环条件语句②; 迭代语句⑦) {
    for(初始化语句③; 循环条件语句④; 迭代语句⑥) {
        循环体语句⑤;
    }
}

语法案例演示1：打印5行5列矩形

    public static void main(String[] args){
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

语法案例演示2：打印5行直角三角形

    public static void main(String[] args){
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

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

爱码者

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
第三章、流程控制语句结构

目录前言：根据语句执行的特点：输入与输出语句一、顺序结构二、复合语句三、分支结构1、条件判断（if ...else） 1.1单分支条件判断 1.2双分支结构 1.3多分支结构 1.4嵌套2、选择结构（switch...case）四、循环结构（1）循环语句：for循环语法演示案例1：打印10次的H...
复制链接

扫一扫