180天Java从入门到就业-Day04-01Java程序流程控制介绍、Java分支结构if语句

1.程序流程控制介绍

1.1 流程控制结构介绍

流程控制语句是用来控制程序中各语句执行顺序的语句，可以将语句组合成完成一定功能的逻辑模块。

一个程序会包含三种流程控制结构：顺序结构、分支结构、循环结构

• 顺序结构

在没有使用程序流程控制语句(if-else语句、switch-case语句、for语句、while语句、do while语句)之前，程序默认就是顺序结构，也就是从main方法的第一行开始执行，然后依次执行到main方法的最后一行退出程序，中间没有任何判断和跳转。

在学习变量和数据类型、运算符时编写的程序基本都是顺序结构

• 分支结构

分支结构就是根据条件判断的结果来选择性执行某段代码（代码块）

Java支持if-else语句和switch-case语句两种分支结构

• 循环结构

循环结构就是根据循环条件判断来重复执行某段代码(代码块)

Java支持for循环、while循环、do while循环以及JDK5.0以后新增的增强for循环(foreach循环) 四种循环结构，其中for循环、while循环和do while循环都具有以下四个要素。

1. 初始化部分

2. 循环条件部分

3. 循环体部分

4. 迭代部分

除此以外还提供了break语句和continue语句来控制循环结构

为了实现项目的复杂业务场景

分支结构是可以相互嵌套的，例如if语句和if语句是可以相互嵌套使用

循环结构是可以相互嵌套使用的，例如for循环嵌套for循环

分支结构和循环结构也是可以相互嵌套使用的，例如for循环嵌套if语句

而且如果你有过项目开发经验就会发现：顺序结构、分支结构、循环结构这三种程序流程控制结构可以搞定所有的事情。

1.2 流程控制结构学习方法

在学习程序流程控制结构的时候，可以参考如下的顺序

1. 掌握程序流程控制结构语法格式（固定的）

2. 掌握程序流程控制结构执行流程(画流程图)

3. 掌握程序流程控制结构应用场景（什么时候用）

4. 掌握程序流程控制结构注意事项（有什么坑）

5. 掌握程序流程控制结构灵活运用(编写大量的案例、疯狂的练习)

2. 单分支结构if语句

2.1 单分支结构if语句介绍

单分支结构if语句语法格式

if(布尔表达式){
  语句块;
}

需要注意的是

• 布尔表达式可以是布尔类型的字面量、变量、表达式（关系表达式或者逻辑表达式）

• 语句块可以有多条执行语句，语句块也可以称为代码块

单分支结构if语句执行流程

1. 首先执行布尔表达式，看执行结果是true还是false

2. 如果是true则执行语句块

3. 如果是false就不执行语句块

4. 继续执行后面的其他内容

单分支结构if语句使用场景：单个条件判断

2.2 单分支结构if语句使用

需求：提示用户输入年龄，判断用户输入的年龄是否满18岁，如果满了18岁就提示他可以去网咖上网

分析：略

1. 新建包net.ittimeline.java.core.foundational.control.branch.ifstatement

2. 新建源文件IfStatementUsage.java

3. 编辑源文件IfStatementUsage.java

 package net.ittimeline.java.core.foundational.control.branch.ifstatement;
    
    import java.util.Scanner;
    
    /**
     * 单分支结构if语句的使用
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/6 10:02
     * @since Java21
     */
    public class IfStatementUsage {
        public static void main(String[] args) {
            //创建Scanner对象
            //System.in表示标准输入，也就是键盘输入
            //Scanner对象可以扫描用户从键盘输入的数据
            Scanner scanner = new Scanner(System.in);
    
            System.out.println("请输入你的年龄");
            //接收用户从键盘输入的年龄并赋值给age
            int age = scanner.nextInt();
    
            //判断是否成年
            if (age >= 18) {
                System.out.println("你已经成年了，可以到网咖上网");
            }
    
            //关闭扫描器
            scanner.close();
        }
    }
    

4. 运行IfStatementUsage

程序运行结果

当输入18时满足条件，会输出你已经成年了，可以到网咖上网

当输入16时不满足条件，不会输出你已经成年了，可以到网咖上网

2.3 单分支结构if语句使用注意事项

2.3.1 单分支结构if语句使用注意事项1

如果对布尔类型的变量进行相等判断,不需要使用==号，可以直接将这个变量写在小括号()中，默认会判断布尔变量是否为true

1. 新建源文件IfStatementWarning1.java

2. 编辑源文件IfStatementWarning1.java

 package net.ittimeline.java.core.foundational.control.branch.ifstatement;
    
    /**
     * 单分支结构if语句注意事项1
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/6 10:13
     * @since Java21
     */
    public class IfStatementWarning1 {
        public static void main(String[] args) {
            boolean flag = true;
            if (flag == true) {
                System.out.println("1.flag等于true");
            }
            //1.如果对布尔类型的变量进行相等判断,不需要使用==号，可以直接将这个变量写在小括号()中，默认会判断布尔变量是否为true
            if (flag) {
                System.out.println("2.flag等于true");
            }
        }
    }
    

3. 运行IfStatementWarning1

程序运行结果

2.3.2 单分支结构if语句使用注意事项2

如果单分支结构if语句的语句块{}中只有一条语句，那么if语句的语句块可以省略**{}**，但是不建议省略，因为会降低代码的可读性。

而且如果单分支结构if语句的语句块省略不写**{},那么单分支结构if语句只能控制距离它最近的一条语句**

1. 新建源文件IfStatementWarning2.java

2. 编辑源文件IfStatementWarning2.java

package net.ittimeline.java.core.foundational.control.branch.ifstatement;

/**
 * 单分支结构if语句注意事项2
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/6 10:15
 * @since Java21
 */
public class IfStatementWarning2 {
    public static void main(String[] args) {
        int age = 16;
        //2.如果单分支结构if语句的语句块{}中只有一条语句，那么if语句的语句块可以省略{}，但是不建议省略，因为会降低代码的可读性。
        //而且如果单分支结构if语句的语句块省略不写{},那么单分支结构if语句只能控制距离它最近的一条语句
        if (age >= 18)
            System.out.println("你已经成年了，可以到网咖上网");
            //这里的语句不属于if语句，因此会执行
            System.out.println("网上冲浪中");
    }
}

3. 运行IfStatementWarning2

程序运行结果

2.4 单分支结构if语句案例

2.4.1 心律检查

需求：成年人心率的正常范围是每分钟 60-100 次。体检时，如果心率不在此范围内，就提示需要做进一步的检查，心率由用户输入。

分析：略

1. 新建源文件IfStatementExample1HeartRateCheck.java

2. 编辑源文件IfStatementExample1HeartRateCheck.java

 package net.ittimeline.java.core.foundational.control.branch.ifstatement;
    
    import java.util.Scanner;
    
    /**
     * 单分支结构if语句案例1：心率检查
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/6 10:20
     * @since Java21
     */
    public class IfStatementExample1HeartRateCheck {
        public static void main(String[] args) {
            //需求：成年人心率的正常范围是每分钟 60-100 次。体检时，如果心率不在此范围内，就提示需要做进一步的检查，心率由用户输入。
            //创建Scanner对象
            //System.in表示标准输入，也就是键盘输入
            //Scanner对象可以扫描用户从键盘输入的数据
            Scanner scanner = new Scanner(System.in);
    
            System.out.println("请输入心率");
            int heartRate = scanner.nextInt();
            if (heartRate < 60 || heartRate > 100) {
                System.out.println("你的心率是" + heartRate + "需要做进一步检查");
            }
    
            //关闭扫描器
            scanner.close();
        }
    }

3. 运行IfStatementExample1HeartRateCheck

程序运行结果

89属于正常心率，因此没有任何输出

58属于不正常心率，因此输出需要做进一步检查

2.4.2 模拟交通灯

需求：模拟交通灯，实现红灯停，绿灯行，黄灯亮了等一等

分析：红灯、绿灯、黄灯每种灯分别有不同的状态：亮或者不亮

1. 新建源文件IfStatementExample2TrafficLight.java

2. 编辑源文件IfStatementExample2TrafficLight.java

 package net.ittimeline.java.core.foundational.control.branch.ifstatement;
    
    /**
     * 单分支结构if语句案例2：模拟交通灯
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/6 10:25
     * @since Java21
     */
    public class IfStatementExample2TrafficLight {
        public static void main(String[] args) {
            //红灯、绿灯、黄灯 亮使用true表示 不亮使用false表示
            boolean isRedLight = true;
            boolean isGreenLight = false;
            boolean isYellowLight = false;
    
            if (isRedLight) {
                System.out.println("红灯停");
            }
            if (isGreenLight) {
                System.out.println("绿灯行");
            }
            if (isYellowLight) {
                System.out.println("黄灯亮了等一等");
            }
        }
    }
    

3. 运行IfStatementExample2TrafficLight

2.4.3 掷骰子

需求：模拟掷骰子

游戏规则

一个骰子的值在1-6之间随机生成

如果三个骰子的和大于15 ，手气不错

如果三个骰子的和在10-15之间，手气一般

如果三个骰子的和在10以下，手气真差

分析：

1. 先生成三个1-6之间的随机数

2. 计算三个骰子的和，然后根据需求使用单分支if语句进行条件判断,满足不同的条件输出不同的结果

Q：如何生成指定范围的随机数

A：获取指定范围[a,b]随机数公式：(int)(Math.random() * (b - a + 1) ) + a

1. 新建源文件MathGeneratorRandomNumberTest.java

2. 编辑源文件MathGeneratorRandomNumberTest.java

package net.ittimeline.java.core.foundational.control;

/**
 * Math生成随机数
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/6 10:36
 * @since Java21
 */
public class MathGeneratorRandomNumberTest {
    public static void main(String[] args) {
        //Math.random()生成[0.0,1.0)之间的随机小数，包括0.0，但是不包括1.0
        //既然是随机数，那么每次生成的小数可能是不一样的
        System.out.println("Math.random() = " + Math.random());

        //生成[0.0,6.0)之间的随机小数，包括0.0，但是不包括6.0
        System.out.println("Math.random()* 6 = " + Math.random() * 6);

        //生成[0,6)之间的随机整数，包括0，但是不包括6
        System.out.println("(int) (Math.random() * 6) = " + (int) (Math.random() * 6));

        //生成[1,6]之间的随机整数，包括1，包括6
        System.out.println("((int) (Math.random() * 6) + 1) = " + ((int) (Math.random() * 6) + 1));

        //生成指定范围随机整数的公式：(int)(Math.random()*(b-a+1))+a
        //生成[65,97]之间随机整数
        System.out.println("((int) (Math.random() * (97 - 65 + 1)) + 65) = "
                + ((int) (Math.random() * (97 - 65 + 1)) + 65));

    }
}

3. 运行MathGeneratorRandomNumberTest

程序运行结果

每次运行程序可能得到不同的结果

知道如何生成随机数之后，再来实现掷骰子

1. 新建源文件IfStatementExample3ShootDice.java

2. 编辑源文件IfStatementExample3ShootDice.java

 package net.ittimeline.java.core.foundational.control.branch.ifstatement;
    
    /**
     * 单分支结构if语句案例3：掷骰子
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/6 10:58
     * @since Java21
     */
    public class IfStatementExample3ShootDice {
        public static void main(String[] args) {
            int first = (int) (Math.random() * 6) + 1;
            System.out.println("第一次是" + first);
    
            int second = (int) (Math.random() * 6) + 1;
            System.out.println("第二次是" + second);
    
            int third = (int) (Math.random() * 6) + 1;
            System.out.println("第三次是" + third);
    
            int sum = first + second + third;
    
            if (sum > 15) {
                System.out.println("如果三个骰子的和大于15 ，手气不错");
            }
    
            if (sum >= 10 && sum <= 15) {
                System.out.println("如果三个骰子的和在10-15之间，手气一般");
            }
            if (sum < 10) {
                System.out.println("如果三个骰子的和在10以下，手气真差");
            }
    
        }
    }
    

3. 运行IfStatementExample3ShootDice

程序运行结果

2.4.4 求最大值

需求：提示用户从键盘输入三个不同的整数，然后求出三个整数的最大值

分析：先求出两个整数的最大值，再求出三个整数的最大值

1. 新建源文件IfStatementExample4GetMaxValue.java

2. 编辑源文件IfStatementExample4GetMaxValue.java

package net.ittimeline.java.core.foundational.control.branch.ifstatement;

import java.util.Scanner;

/**
 * 单分支结构if语句案例4：求最大值
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/6 11:07
 * @since Java21
 */
public class IfStatementExample4GetMaxValue {
    public static void main(String[] args) {
        //创建Scanner对象
        //System.in表示标准输入，也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);

        //提示用户从键盘输入三个整数并接收
        System.out.println("请输入第一个整数");
        int firstNumber = scanner.nextInt();

        System.out.println("请输入第二个整数");
        int secondNumber = scanner.nextInt();

        System.out.println("请输入第三个整数");
        int thirdNumber = scanner.nextInt();

        //1.求出第一个数和第二个数的最大值
        //假设第一个数是最大值
        int secondLargest = firstNumber;
        //如果第一个数比第二个数小，那么第二个数就是最大值
        if (firstNumber < secondNumber) {
            secondLargest = secondNumber;
        }

        //2.求出三个数的最大值
        //假设第三个数是最大值
        int max = thirdNumber;
        //如果第三个数比第一个数、第二个数中的最大值小
        if (thirdNumber < secondLargest) {
            //第一个数、第二个数中的最大值就是三个整数的最大值
            max = secondLargest;
        }
        System.out.printf("%d、%d、%d三个整数的最大值是%d", firstNumber, secondNumber, thirdNumber, max);
        //关闭扫描器
        scanner.close();
    }
}

3. 运行IfStatementExample3GetMaxValue

程序运行结果

在测试程序时需要测试3组数据

① 10 20 30和10 30 20

② 20 10 30和20 30 10

③ 30 10 20和30 20 10

3.双分支结构if-else语句

3.1 双分支结构if-else语句介绍

双分支结构if-else语句语法格式

if(布尔表达式){
  语句块1;
}else{
  语句块2;
}

需要注意的是

• 布尔表达式可以是布尔类型的字面量、变量、表达式（关系表达式或者逻辑表达式）

• 语句块可以有多条执行语句，语句块也可以称为代码块

双分支结构if-else语句执行流程

5. 首先执行布尔表达式，看执行结果是true还是false

6. 如果是true则执行语句块1

7. 如果是false就执行语句块2

8. 继续执行后面的其他内容

双分支结构if-else语句应用场景：二选一条件判断

3.2 双分支结构if-else语句使用

需求：判断用户输入的整数是基数还是偶数

分析：整数如果能被2整除就是偶数，否则就是基数

1. 新建源文件IfElseStatementUsage.java

2. 编辑源文件IfElseStatementUsage.java

package net.ittimeline.java.core.foundational.control.branch.ifstatement;

import java.util.Scanner;

/**
 * 双分支结构if-else语句的使用
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/6 11:27
 * @since Java21
 */
public class IfElseStatementUsage {
    public static void main(String[] args) {
        //创建Scanner对象
        //System.in表示标准输入，也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入一个整数");
        int number = scanner.nextInt();
        if (number % 2 == 0) {
            System.out.println("你输入的" + number + "是偶数");
        } else {
            System.out.println("你输入的" + number + "是奇数");

        }

        //关闭扫描器
        scanner.close();
    }
}

3. 运行IfElseStatementUsage

程序运行结果

3.3 双分支结构if-else语句案例

3.3.1 QQ登录

需求：提示用户输入QQ账号和密码，如果账号是190864639，并且密码是124578963则提示登录成功，否则提示账号或密码错误，登录失败

分析：判断用户输入的账号、密码和正确的账号、密码是否相等，相等就提示登录成功，不相等就提示账号、密码错误，登录失败

1. 新建源文件IfElseStatementExample1QQLogin.java

2. 编辑源文件IfElseStatementExample1QQLogin.java

package net.ittimeline.java.core.foundational.control.branch.ifstatement;

import java.util.Scanner;

/**
 * 双分支结构if-else语句案例1：QQ登录
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/6 12:49
 * @since Java21
 */
public class IfElseStatementExample1QQLogin {
    public static void main(String[] args) {
        //需求：提示用户输入QQ账号和密码，如果账号是190864639，并且密码是124578963则提示登录成功，
        // 否则提示账号或密码错误，登录失败

        //创建Scanner对象
        //System.in表示标准输入，也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);

        //正确的账号和密码
        int targetAccount = 190864639;
        String targetPassword = "124578963go";
        //提示用户输入账号和密码
        System.out.println("请输入账号");
        int inputAccount = scanner.nextInt();
        System.out.println("请输入密码");
        String inputPassword = scanner.next();

        //拿用户输入的账号、密码和正确的账号、密码进行比较，如果相等则提示用户登录成功
        //字符串相等使用字符串对象的equals()方法
        if (targetAccount == inputAccount && targetPassword.equals(inputPassword)) {
            System.out.println("用户登录成功");
        }
        //否则提示账号或密码错误，用户登录失败
        else {
            System.out.println("账号或密码错误，用户登录失败");
        }

        //关闭扫描器
        scanner.close();
    }
}

3. 运行IfElseStatementExample1QQLogin

程序运行结果

3.3.2 吃网红餐厅还是沙县

需求：根据用户输入口袋里的钱判断是去吃网红餐厅还是沙县小吃，如果大于2000就吃网红餐厅，否则就吃经济实惠的沙县小吃

分析：略

1. 新建源文件IfElseStatementExample2JudgeMoneyEatSomething.java

2. 编辑源文件IfElseStatementExample2JudgeMoneyEatSomething

 package net.ittimeline.java.core.foundational.control.branch.ifstatement;
    
    import java.util.Scanner;
    
    /**
     * 双分支结构if-else语句案例2：吃网红还是沙县
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/6 13:09
     * @since Java21
     */
    public class IfElseStatementExample2JudgeMoneyEatSomething {
        public static void main(String[] args) {
            //需求：根据口袋里的钱判断是去吃网红餐厅还是沙县小吃，如果大于2000就吃网红餐厅，否则就吃经济实惠的沙县小吃
            //创建Scanner对象
            //System.in表示标准输入，也就是键盘输入
            //Scanner对象可以扫描用户从键盘输入的数据
            Scanner scanner = new Scanner(System.in);
    
            System.out.println("请输入你口袋里面的钱，单位：元");
            int money = scanner.nextInt();
            if (money > 2000) {
                System.out.println("吃网红餐厅");
            } else {
                System.out.println("吃经济实惠的沙县小吃");
            }
    
            //关闭扫描器
            scanner.close();
        }
    }
    

3. 运行IfElseStatementExample2JudgeMoneyEatSomething

程序运行结果

3.4 双分支结构if-else语句和三元运算符比较

需求：分别使用双分支结构if-else语句和三元运算符求两个整数的最大值

1. 新建源文件IfElseStatementTernaryOperatorGetMaxValue.java

2. 编辑源文件IfElseStatementTernaryOperatorGetMaxValue.java

package net.ittimeline.java.core.foundational.control.branch.ifstatement;

/**
 * 分别使用双分支结构if-else语句和三元运算符求两个整数的最大值
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/6 13:26
 * @since Java21
 */
public class IfElseStatementTernaryOperatorGetMaxValue {
    public static void main(String[] args) {
        int left = 10;
        int right = 20;
        int ternaryOperatorMaxValue = left > right ? left : right;
        System.out.println("使用三元运算符实现 两个整数中的最大值是" + ternaryOperatorMaxValue);

        int ifElseStatementMaxValue;
        if (left > right) {
            ifElseStatementMaxValue = left;
        } else {
            ifElseStatementMaxValue = right;
        }
        System.out.println("使用双分支结构if-else语句实现 两个整数中的最大值是" + ifElseStatementMaxValue);
    }
}

3. 运行IfElseStatementTernaryOperatorGetMaxValue

程序运行结果

从程序运行结果可以看出对于简单的需求来说，双分支结构if-else语句和三元运算符是可以相互替换的。

3.5 双分支结构if-else语句嵌套

在一个分支结构中又嵌套了另一个完整的分支结构就构成了分支嵌套，里面的分支结构称为内层分支，外面的分支结构称为外层分支。

双分支结构if-else语句是可以嵌套的,但是在实际项目开发过程中通常最多只会嵌套三层

双分支结构if-else语句嵌套语法格式

if(布尔表达式1){
  if(布尔表达式2){
    代码块2;
  }else{
    代码块3;
  }
}else{
  代码块4;
}

双分支结构if-else语句嵌套执行流程

1. 首先执行外层if语句的布尔表达式1，看执行结果是true还是false

2. 如果执行结果是false，那么就是执行外层else语句的代码块4;，然后结束外层if-else语句

3. 如果执行结果是true，就执行内层if语句的布尔表达式2;，看执行结果是true还是false

   1. 如果执行结果是true，就执行内层if语句的代码块2;，然后结束外层if-else语句

   2. 如果执行结果是false，就执行内层else语句的代码块3;，然后结束外层if-else语句

4. 执行其他剩下语句

需求：提示用户输入考试成绩，如果大于等于60分，恭喜他考试及格，否则提醒他考试不及格，下次补考

分析：首先判断用户输入的考试成绩是否合法，即在0-100分之内，然后再判断考试成绩是否及格

1. 新建源文件IfElseStatementNested.java

2. 编辑源文件IfElseStatementNested.java

package net.ittimeline.java.core.foundational.control.branch.ifstatement;

import java.util.Scanner;

/**
 * 双分支结构if-else语句嵌套
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/6 13:45
 * @since Java21
 */
public class IfElseStatementNested {
    public static void main(String[] args) {
        // 需求：提示用户输入考试成绩，如果大于等于60分，恭喜他考试及格，否则提醒他考试不及格，下次补考
        //创建Scanner对象
        //System.in表示标准输入，也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入考试成绩");
        int score = scanner.nextInt();
        if (score >= 0 && score <= 100) {
            if (score >= 60) {
                System.out.println("恭喜你考试及格");
            } else {
                System.out.println("考试不及格，下次补考");
            }
        } else {
            System.out.println("考试成绩非法");

        }
        //关闭扫描器
        scanner.close();


    }
}

3. 运行IfElseStatementNested

程序运行结果

4. 多分支结构if-else if-else语句

4.1 多分支结构if-else if-else语句介绍

多分支结构if-else if-else语句语法格式

if(布尔表达式1){
  语句块1;
}else if (布尔表达式2){
  语句块2;
}else if(布尔表达式3){
  语句块3;
}else if(布尔表达式n){
  语句块n;
}else{
  语句块n+1;
}

需要注意的是

• else if 可以有n个，具体几个根据业务需求决定

• else可以没有

多分支结构if-else if -else语句执行流程

需要说明的是一旦布尔表达式为true，则执行相应的语句块。执行完对应的语句块之后就结束当前多分支结构

1. 首先执行布尔表达式1，看其执行结果是true还是false

2. 如果是true就执行语句块1，然后结束当前多分支结构

3. 如果是false就继续执行布尔表达式2，看其执行结果是true还是false

4. 如果是true就执行语句块2，然后结束当前多分支结构

5. 如果是false就继续执行执行剩下的布尔表达式，看其执行结果是true还是false

6. 如果没有任何布尔表达式为true，那么就执行语句块n+1，然后结束当前多分支结构

7. 继续执行其他剩下语句

多分支结构if-else if-else语句应用场景：多选一条件判断

4.2 多分支结构if-else if-else语句使用

需求：根据用户输入的考试成绩的分数奖励不同的物品

  如果成绩为100分，奖励一台宝马3系
  如果成绩为`(80,99]`时，奖励一台MacBook Pro  16
  如果成绩为`[60,80]`时，奖励一台iPad Pro  12.9
  其他时，一顿胖揍

分析：略

1. 新建源文件IfElseIfElseStatementUsage.java

2. 编辑源文件IfElseIfElseStatementUsage.java

从实现方式1可以看出如果多个条件表达式之间没有交集（互斥关系）则哪个条件表达式声明在上面或者下面都可以

从实现方式2可以看出如果多个条件表达式之间是包含关系，则需要将范围小的条件表达式声明在范围大的条件表达式上面，否则范围小的条件表达式没有机会执行

 package net.ittimeline.java.core.foundational.control.branch.ifstatement;
    
    import java.util.Scanner;
    
    /**
     * 多分支结构if-else if-else语句的使用
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/6 14:18
     * @since Java21
     */
    public class IfElseIfElseStatementUsage {
        public static void main(String[] args) {
            //需求：根据用户输入的考试成绩的分数奖励不同的物品
            //如果成绩为100分，奖励一台宝马3系
            //如果成绩为(80,99]时，奖励一台MacBook Pro 16
            //如果成绩为[60,80]时，奖励一台iPad Pro 12.9
            //其他时，一顿胖揍
    
            //创建Scanner对象
            //System.in表示标准输入，也就是键盘输入
            //Scanner对象可以扫描用户从键盘输入的数据
            Scanner scanner = new Scanner(System.in);
    
            System.out.println("请输入你的考试成绩");
            int score = scanner.nextInt();
            //实现方式1
            //①和②else if交换顺序不会改变程序的运行结果
            //因为①和②没有交集部分，即如果多个条件表达式之间没有交集（互斥关系）则哪个条件表达式声明在上面或者下面都可以
            System.out.println("实现方式1：");
            if (score == 100) {
                System.out.println("奖励一台宝马3系");
            } else if (score > 80 && score <= 99) { //①
                System.out.println("奖励一台MacBook Pro 16");
            } else if (score >= 60 && score <= 80) {//②
                System.out.println("奖励一台iPad Pro 12.9");
            } else {
                System.out.println("一顿胖揍");
            }
    
            //实现方式2
            //①和②的else if交换顺序会改变程序的运行结果
            //因为②包含①，即如果多个条件表达式之间是包含关系，则需要将范围小的条件表达式声明在范围大的条件表达式上面，
            //否则范围小的条件表达式没有机会执行
            System.out.println("实现方式2：");
            if (score == 100) {
                System.out.println("奖励一台宝马3系");
            } else if (score > 80) { //①
                System.out.println("奖励一台MacBook Pro 16");
            } else if (score >= 60) { //②
                System.out.println("奖励一台iPad Pro 12.9");
            } else {
                System.out.println("一顿胖揍");
            }
    
            //关闭扫描器
            scanner.close();
        }
    }
    

3. 运行IfElseIfElseStatementUsage

程序运行结果

4.3 多分支结构if-else if-else语句案例

4.3.1 高铁票计费

需求：实现根据用户输入的身份计算高铁票的价格，输出他的身份以及高铁票的价格

高铁票的价格计算规则

• 原价 380

• 军人免费

• 学生半价

• 其他人原价

分析：略

1. 新建源文件IfElseIfElseStatementExample1HighSpeedRailBillingSystem.java

2. 编辑源文件IfElseIfElseStatementExample1HighSpeedRailBillingSystem.java

 package net.ittimeline.java.core.foundational.control.branch.ifstatement;
    
    import java.util.Scanner;
    
    /**
     * 多分支结构if-else if -else语句案例1：高铁计费系统
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/6 15:07
     * @since Java21
     */
    public class IfElseIfElseStatementExample1HighSpeedRailBillingSystem {
        public static void main(String[] args) {
            //需求：实现根据用户输入的身份计算高铁票的价格，输出他的身份以及高铁票的价格
            //高铁票的价格计算规则
            //● 原价 380
            //● 军人免费
            //● 学生半价
            //● 其他人原价
    
            //创建Scanner对象
            //System.in表示标准输入，也就是键盘输入
            //Scanner对象可以扫描用户从键盘输入的数据
            Scanner scanner = new Scanner(System.in);
    
            System.out.println("请输入你的身份");
            String identity = scanner.next();
            double price = 380.0;
            if ("军人".equals(identity)) {
                price *= 0;
            } else if ("学生".equals(identity)) {
                price *= 0.5;
            }
            System.out.println("你的身份是" + identity);
            System.out.println("高铁票的价格是" + price);
    
    
            //关闭扫描器
            scanner.close();
        }
    }
    

3. 运行IfElseIfElseStatementExample1HighSpeedRailBillingSystem

程序运行结果

4.3.2 出租车计费系统

需求：实现出租车计费系统

出租车的计费方式：里程费用和等待时间费用

• 里程费用

1. 不超过3公里 21元

2. 超过3公里但是不超过15公里 每公里2元

3. 超过15公里 每公里3元

• 等待时间费用

  1. 每等待150秒(2分半钟)收费1元

  2. 不超过150秒不收钱

为了考虑程序的灵活性，里程数和等待时间的秒数都是由用户从键盘输入的。

分析：假如里程数是16公里，等待时间是299秒，那么应该如何计算打车费，打车费用是49

里程费用

1.  不超过3公里：21元
    
2.  超过3公里但是不超过15公里，每公里2元：(15 - 3) * 2 = 24
    
3.  超过15公里 每公里3元(16 - 15 )*3 =3
    

等待时间费用：299 / 150 * 1 = 1

总费用=里程费用+等待时间费用：（21+ 24 +3）  +1 =49

1. 新建源文件IfElseIfElseStatementExample2TaxiBillingSystem.java

2. 编辑源文件IfElseIfElseStatementExample2TaxiBillingSystem.java

package net.ittimeline.java.core.foundational.control.branch.ifstatement;

import java.util.Scanner;

/**
 * 多分支结构if-else if-else语句案例2：出租车计费系统
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/6 15:34
 * @since Java21
 */
public class IfElseIfElseStatementExample2TaxiBillingSystem {
    public static void main(String[] args) {
        //需求：实现出租车计费系统
        //出租车的计费方式：里程费用和等待时间费用
        //● 里程费用
        //1. 不超过3公里 21元
        //2. 超过3公里但是不超过15公里 每公里2元
        //3. 超过15公里 每公里3元
        //● 等待时间费用
        //    1. 每等待150秒(2分半钟)收费1元
        //    2. 不超过150秒不收钱
        //为了考虑程序的灵活性，里程数和等待时间的秒数都是由用户从键盘输入的。
        //创建Scanner对象
        //System.in表示标准输入，也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入里程");
        int mileage = scanner.nextInt();
        System.out.println("请输入等待时间 单位：秒");
        int waitTime = scanner.nextInt();
        //计算里程费用
        int mileageCost = 0;
        if (mileage <= 3) {
            mileageCost = 21;
        } else if (mileage > 3 && mileage < 15) {
            mileageCost = 21 + (mileage - 3) * 2;
        } else if (mileage > 15) {
            mileageCost = 21 + (15 - 3) * 2 + (mileage - 15) * 3;
        }
        //等待时间费用
        int waitTimeCost = waitTime / 150;
        //总费用(打车费用)
        int totalCost = mileageCost + waitTimeCost;
        System.out.printf("里程数是%d 等待的秒数是%d 打车费是%d \n", mileage, waitTime, totalCost);

        //关闭扫描器
        scanner.close();
    }
}

3. 运行IfElseIfElseStatementExample2TaxiBillingSystem

程序运行结果

4.3.3 个税计算器

需求：提示用户输入期望税前月薪，根据用户输入的税前月薪所在区间对应的税率和速算扣税数计算个人所得税

个人所得税起征点是5000，大于5000的部分（全月应纳税所得额）才需要纳税

个税计算公式：全月应纳税所得额*税率-速算扣税数

全月应纳税额所得额	税率	速算扣税数(元)
全月应纳税额所得额不超过3000元(8000元)	3%	0
全月应纳税额所得额超过3000元至12000元(17000)	10%	210
全月应纳税额所得额超过12000元至25000元(30000元)	20%	1410
全月应纳税额所得额超过25000元至35000元(40000元)	25%	2660
全月应纳税额所得额超过35000元至55000元(60000元)	30%	4410
全月应纳税额所得额超过55000元至80000元(85000元)	35%	7160
全月应纳税额所得额超过80000元(85000元)	45%	15160

分析： 先计算应纳税所得额，再根据公式 应纳税所得额*税率-速算扣税数 计算个人所得税

1. 新建源文件IfElseIfElseStatementExample3PersonalIncomeTaxCalculator.java

2. 编辑源文件IfElseIfElseStatementExample3PersonalIncomeTaxCalculator.java

package net.ittimeline.java.core.foundational.control.branch.ifstatement;

import java.util.Scanner;

/**
 * 多分支结构if-else if-else语句案例3：个税计算器
 *
 * @author tony 18601767221@163.com
 * @version 2023/12/6 16:07
 * @since Java21
 */
public class IfElseIfElseStatementExample3PersonalIncomeTaxCalculator {
    public static void main(String[] args) {
        //创建Scanner对象
        //System.in表示标准输入，也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入你期望的税前月薪");
        int salary = scanner.nextInt();
        //根据期望的税前工资所在的区间对应税率计算个人所得税
        //计算公式：全月应纳税所得额 * 税率 - 速算扣税数
        double taxAmount = 0.0;

        if (salary <= 5000) {
            System.out.println("期望的税前工资不超过5000不需要纳税");
        }
        //期望的税前工资超过5000但是不超过8000,全月应纳税额所得额不超过3000元 3%
        else if (salary <= 8000) {
            taxAmount = (salary - 5000) * 0.03 - 0;
        }
        //期望的税前工资超过8000但是不超过17000,全月应纳税额所得额超过3000元至12000元 10%
        else if (salary <= 17000) {
            taxAmount = (salary - 8000) * 0.1 - 210;
        }
        //期望的税前工资超过17000但是不超过30000,全月应纳税额所得额超过12000元至25000元 20%
        else if (salary <= 30000) {
            taxAmount = (salary - 5000) * 0.2 - 1410;
        }
        //期望的税前工资超过30000但是不超过40000,全月应纳税额所得额超过25000元至35000元(40000元) 25%
        else if (salary <= 40000) {
            taxAmount = (salary - 5000) * 0.25 - 2660;
        }
        //期望的税前工资超过40000但是不超过60000,全月应纳税额所得额超过35000元至55000元(60000元) 30%
        else if (salary <= 60000) {
            taxAmount = (salary - 5000) * 0.3 - 4410;
        }
        //期望的税前工资超过60000但是不超过85000,全月应纳税额所得额超过55000元至80000元(85000元) 35%
        else if (salary <= 85000) {
            taxAmount = (salary - 5000) * 0.35 - 7160;
        }
        //期望的税前工资超过85000,全月应纳税额所得额超过80000元(85000元) 45%
        else if (salary > 85000) {
            taxAmount = (salary - 5000) * 0.45 - 15160;
        }
        System.out.printf("期望的税前薪水是%d对应的个人所得税是%.2f\n", salary, taxAmount);

        //关闭扫描器
        scanner.close();
    }
}

3. 运行IfElseIfElseStatementExample3PersonalIncomeTaxCalculator

程序运行结果

4.4 双分支结构if-else语句与多分支结构if-else if-else语句嵌套

在一个分支结构中又嵌套了另一个完整的分支结构就构成了分支嵌套，里面的分支结构称为内层分支，外面的分支结构称为外层分支。

双分支结构if-else语句与多分支结构if-else if-else语句是可以被嵌套使用的，但是日常项目开发时通常不会嵌套三层以上（最多嵌套三层）

双分支结构if-else语句嵌套多分支结构if-else if-else语句语法格式

if(布尔表达式1){
  if(布尔表达式2){
    语句块2;
  }else if(布尔表达式3){
    语句块3;
  }else{
    语句块4;
  }
}else{
  if(布尔表达式5){
    语句块5;
  }else if(布尔表达式6){
    语句块6;
  }else{
    语句块7;
  }
}

双分支结构if-else语句嵌套多分支结构if-else if-else语句执行流程

1. 首先执行外层if语句的布尔表达式1，看执行结果是true还是false

2. 如果执行结果是true

   1. 就执行内层if语句的布尔表达式2，看执行结果是true还是false

   2. 如果执行结果是true，就执行内层if语句的语句块2;，然后结束整个分支嵌套结构

   3. 如果是false,就执行内层else if语句的布尔表达式3，看执行结果是true还是false

   4. 如果是true就执行内层else if语句的语句块3;,然后结束整个分支嵌套结构

   5. 如果是false就执行语句块4，然后结束整个分支嵌套结构

3. 如果执行结果是false

   1. 就执行外层else语句中if语句的布尔表达式5，看执行结果是true还是false

   2. 如果执行结果是true，就执行内层if语句的语句块5;，然后结束整个分支嵌套结构

   3. 如果是false,就执行内层else if语句的布尔表达式6;，看执行结果是true还是false

   4. 如果是true就执行内层else if语句的语句块6;,然后结束整个分支嵌套结构

   5. 如果是false就执行语句块7;，然后结束整个分支嵌套结构

需求：提示用户从键盘输入三个整数，然后从大到小排序输出

分析：先比较第一个整数和第二个整数，然后再将第三个数分别和第一个数、第二个数进行比较

1. 新建源文件IfElseStatementNestedIfElseIfElseStatement.java

2. 编辑源文件IfElseStatementNestedIfElseIfElseStatement.java

 package net.ittimeline.java.core.foundational.control.branch.ifstatement;
    
    import java.util.Scanner;
    
    /**
     * 双分支结构if-else语句嵌套多分支结构if-else if-else语句
     *
     * @author tony 18601767221@163.com
     * @version 2023/12/6 18:44
     * @since Java21
     */
    public class IfElseStatementNestedIfElseIfElseStatement {
        public static void main(String[] args) {
            //需求：提示用户从键盘输入三个整数，然后从大到小排序输出
            //创建Scanner对象
            //System.in表示标准输入，也就是键盘输入
            //Scanner对象可以扫描用户从键盘输入的数据
            Scanner scanner = new Scanner(System.in);
            //提示用户从键盘输入三个整数并赋值给相应的整数变量
            System.out.println("请输入第一个整数");
            int first = scanner.nextInt();
            System.out.println("请输入第二个整数");
            int second = scanner.nextInt();
            System.out.println("请输入第三个整数");
            int third = scanner.nextInt();
            //先比较第一个整数和第二个整数
            //如果第一个数比第二个数大
            if (first > second) {
                //将第三个数分别和第一个数、第二个数进行比较
                //第三个数比第一个数大，那么第三个数是三个整数中最大的一个
                if (third > first) {
                    System.out.printf("三个整数按照从大到小的顺序排序依次是%d > %d > %d\n", third, first, second);
                }
                //第三个数比第二个数小,那么第三个数就是三个整数中最小的一个
                else if (third < second) {
                    System.out.printf("三个整数按照从大到小的顺序排序依次是%d > %d > %d\n", first, second, third);
                }
                //第三个数位于第一个数和第二个数的中间
                else {
                    System.out.printf("三个整数按照从大到小的顺序排序依次是%d > %d > %d\n", first, third, second);
                }
            }
            //第一个数比第二个数小
            else {
                //将第三个数分别和第一个数、第二个数进行比较
                //第三个数比第二个数大，那么第三个数是三个整数中最大的一个
                if (third > second) {
                    System.out.printf("三个整数按照从大到小的顺序排序依次是%d > %d > %d\n", third, second, first);
                }
                //第三个数比第一个数小,那么第三个数就是三个整数中最小的一个
                else if (third < first) {
                    System.out.printf("三个整数按照从大到小的顺序排序依次是%d > %d > %d\n", second, first, third);
                }
                //第三个数位于第二个数和第一个数的中间
                else {
                    System.out.printf("三个整数按照从大到小的顺序排序依次是%d > %d > %d\n", second, third, first);
                }
            }
    
            //关闭扫描器
            scanner.close();
        }
    }
    

3. 运行IfElseStatementNestedIfElseIfElseStatement

三组测试数据

① 10、20、30和10、30、20

② 20、10、30和20、30、10

③ 30、10、20和30、20、10