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

目录

  

前言:

根据语句执行的特点:

输入与输出语句

一、顺序结构

二、复合语句

三、分支结构

1、条件判断(if ...else)

     1.1单分支条件判断

     1.2双分支结构

     1.3多分支结构

     1.4嵌套

2、选择结构(switch...case)

四、循环结构

(1) 循环语句:for循环

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

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

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

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

(2)循环结构:while循环

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

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

(3)循环结构:do...while循环

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

(4) 循环语句的区别

(5) 控制语句

1、 break

2、 continue

(6) 嵌套循环

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

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


 

 

前言:

 

根据语句执行的特点:

(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();
        }
    }

 

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 终极编程指南 设计师:CSDN官方博客 返回首页