10 2024-8-17（流程控制：顺序结构、分支结构（if、switch）、循环结构（for、while、do-while、死循环、循环嵌套））

一. 三种执行顺序

1.顺序结构

2.分支结构 

        1.if (根据条件（true or false）来执行某段代码)

         if的三种形式：

                

if (条件表达式){         代码； }

if (条件表达式){         代码1； } else{         代码2； }

if (条件表达式){         代码1； } else if {         代码2； } else if {         代码3； } …… else  {         代码n； }

package com.mofan.branch;

public class if1 {
    public static void main(String[] args) {
        //if 三种分支
        // eg1 :测体温，体温高于37告警
        double t1 = 38.9;
        if (t1 > 37) {
            System.out.println("体温过高"); // →→→→体温过高
        }

        //eg2 :测体温，提示体温是否超过37度
        double t2 = 38.9;
        if (t2 > 37) {
            System.out.println("体温高于37°");
        } else System.out.println("体温低于37°"); // →→→→体温高于37°

        // eg3 :测体温，提示提问是否正常 26.3 37.2
        double t3 = 38.9;
        if (t3 > 37.2) {
            System.out.println("体温已过高");
        }else if(t3 < 26.3){
            System.out.println("体温已过低");
        }else System.out.println("体温正常"); // →→→→体温已过高
    }
}

                注意if（条件）{} 中，（）后不能跟 " 分号 ; "       

      

       2. switch(通过比较值来决定执行哪条分支)     

switch（表达式）{         case 值1：                 代码……;                 break；         case 值2：                 代码……                 break；         case 值3：                 代码……                 break；         ……         case 值n-1：                 代码……                 break；         default:                 代码n; }

注意事项:

1. 表达式类型只能是byte、short、int、char、JDK5 开始支持枚举、JDK7 开始支持String,不支持double、float、long

2. case给出的值不允许重复，且只能是字面量，不能是变量。

3. 正常使用switch的时候，不要忘记写break，否则会出现穿透现象

package com.mofan.branch;

public class switch2 {
    public static void main(String[] args) {
        // switch 的注意事项
        // 1. 表达式类型只能是byte、short、int、char、JDK5 开始支持枚举、JDK7 开始支持String,不支持double、float、long
        // 2. case给出的值不允许重复，且只能是字面量，不能是变量。
        // 3. 正常使用switch的时候，不要忘记写break，否则会出现穿透现象

    // 1.表达式类型只能是byte、short、int、char、JDK5 开始支持枚举、JDK7 开始支持String,不支持double、float、long
//        long a = 10;
//        switch (a){} ----------→ 报错

    // 2. case给出的值不允许重复，且只能是字面量，不能是变量。
//        int a = 10;
//        int b = 20;
//        switch (a){
//            case b:  -----------→ 报错：变量会变化，可能造成重复现象
//                System.out.println(b);
//                break;
//            case 10:
//                System.out.println(a);
//                break;

    // 3. 正常使用switch的时候，不要忘记写break，否则会出现穿透现象
        String week = "周三"; // ---------→ 出现的并不是累，而是 累
//                                                          还是累
        switch (week) {
            case "周一":
                System.out.println("还没缓过来");
                break;
            case "周二":
                System.out.println("昏迷中");
                break;
            case "周三":
                System.out.println("累");
//                break;
            case "周四":
                System.out.println("还是累");
                break;
            case "周五":
                System.out.println("要周末了！");
                break;
            case "周六":
                System.out.println("放假了");
                break;
            case "周日":
                System.out.println("又剩最后一天了");
                break;
            default:
                System.out.println("你是外星人吗？地球一周只有七天 OvO");
        }
    }
}

        if与switch比较:

        if在功能上远远强大于switch。

        当前条件是区间的时候，应该使用if分支结构。

        当条件是与一个一个的值比较是，switch分支更适合：格式良好，性能较好，代码优雅。 

                

       

3.循环结构

       1. for循环：

for (初始化语句；循环条件；迭代语句){                                         循环体语句（重复执行的代码）；                  }

{
    public static void main(String[] args) {
        // for循环
        // 1. 打印五行("Hello World")
        /*
            流程：
                首先会执行初始化语句： int a = 0;
                a = 0,判断循环条件 0 < 3,返回true，计算机会进入循环中执行输入第一行"Hello World",接着执行迭代语句 a++
                a = 0,判断循环条件 1 < 3,返回true，计算机会进入循环中执行输入第二行"Hello World",接着执行迭代语句 a++
                a = 0,判断循环条件 2 < 3,返回true，计算机会进入循环中执行输入第三行"Hello World",接着执行迭代语句 a++
                a = 0,判断循环条件 3 < 3,返回false，并且直接结束
         */
        for( int a = 0; a < 5; a++) {
            System.out.println("Hello World"); //--------→ Hello World
//                                                         Hello World
//                                                         Hello World
//                                                         Hello World
//                                                         Hello World

        }
    }
}

        for循环案例:

                1. 批量产生数据

                2. 0~100求和，求偶数和，求奇数和

{
    public static void main(String[] args) {
        // 使用for循环批量产生数据
        for (int i = 1; i <= 100; i++) {
            System.out.println(i); // ------------→1、2、……、100
        }

//         eg1: 对100以内整数进行求和

    //  1.设置一个容器，用于存放每次循环的值
        int sum = 0;
    //  2.构造for循环
        for (int i = 1; i <= 100; i++) {
            sum = sum + i; // 也可用 sum += i;
        }
        System.out.println("1~100的数据总和" + sum); // --------→ 5050
                                                   // 【若将此段代码放在FOR循环的大括号内则会输出（1、3、6、10、……、5050）】

//         eg2（1）: 求100以内奇数的和
    //  1.定义一个变量用于求和
        int sum1 = 0;
    //  2.求和
    for (int i = 1; i <= 100; i += 2) {
        sum1 += i;
    }
        System.out.println("0~100奇数和" + sum1);// --------→ 2500

 //        eg2(2):  求100以内奇数的和（利用一个if语句，通过取余挑出100以内的奇数）
    // 1.设置一个容器，用来存放奇数
        int sum2 = 0;
    // 2.求和
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 1) {
                sum2 += i;
            }
        }
        System.out.println("0~100奇数和" + sum2 ); // ---------→ 2500
    }
}

      2.  while循环（与for循环类似，只是循环不同）

初始化语句； while（循环语句）{         循环体语句（被重复执行的代码）；         迭代语句； }

​
package com.mofan.branch;

public class while1 {
    public static void main(String[] args) {
        // while循环
        int i = 0;
        while (i < 5) {
            System.out.println("Hello World");
            i++;
        }
    }
}

​

        注意：

                1.与for循环类似，只是写法不同；知道循环次数选择for反之则用while

                2.for循环中的变量在循环外不可用，反之则可以

         while循环案例：

                 ge1: 折纸测珠峰

package com.mofan.branch;

public class while2 {
    public static void main(String[] args) {
        // ge1: 珠峰0048860mm,一张无限大的纸，厚度0.1mm
        //     求：只涨跌多少次，可以叠成珠峰高度
//   1.分别设置记录珠峰高度与纸张高度的变量,与折叠次数
        double peakHeight = 8848860;
        double paperHeight = 0.1;
        int count = 0;
//   2.定义while循环控制纸张折叠
        while(paperHeight < peakHeight) {
            paperHeight *= 2;
            count++;
        }
        System.out.println("纸张需要折叠次数 ：" + count); //----------→ 27
        System.out.println("纸张需要折叠次数 ：" + paperHeight); //------------→1.34217728E7
    }
}

        3.do-while循环（先循环，再判断）

初始化语句； do {         循环体语句；         迭代语句； } while（循环条件）；

        do-while循环案例:

                ge1: Hello World

package com.mofan.branch;

public class do_whlie1 {
    public static void main(String[] args) {
        // do-while循环
        //ge1: 打印五次"Hello World"
        int i = 0;
        do {
            System.out.println("Hello World");
            i++;
        }while (i < 5);

//        【特点是： 先循环，后判断】
        do{
            System.out.println("Hello World1");
        }while (false);// -------------→Hello World1
    }
}

4.死循环

死循环的写法：

for (  ;  ;  ) {          system.out.println( "Hello World" ) }

// 经典写法 while (true) {           system.out.println( "Hello World" ) }

do {           system.out.println( "Hello World" ) }while (true);

5.跳转关键字       

        break：跳出并结束当前循环的执行

        continue：跳出当前循环的当次执行，直接进入下一次执行

package com.mofan.branch;

public class BreakAndContinue1 {
    public static void main(String[] args) {
        // break:开始希望总共展示五次"Hello World",但现在只希望展示三次即可。
        for (int i = 1; i <= 5; i++) {
            System.out.println("Hello World" + i); // -----------→ Hello World1……3
            if (i == 3){
                break;
            }
        }
        // continue:开始希望展示五次"Hello World",但现在希望不展示第三次。
        for (int i = 1; i <= 5; i++) {
            if (i == 3){
                continue;
            }
            System.out.println("输出 Hello World 第" + i + "次"); // --------→ 输出 Hello World 第1……5次
        }
    }
}