流程控制-分支结构(选择结构)

向右看齐 2023-09-30 13:27 22阅读 0赞

流程控制

【1】流程控制的作用：  
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。  
【2】控制语句的分类：  
控制语句分为三类：顺序、选择和循环。  
“顺序结构”代表“先执行a，再执行b”的逻辑。  
“条件判断结构”代表“如果…，则…”的逻辑。  
“循环结构”代表“如果…，则再继续…”的逻辑。  
三种流程控制语句就能表示所有的事情！不信，你可以试试拆分你遇到的各种事情。这三种基本逻辑结构是相互支撑的，它们共同构成了算法的基本结构，无论怎样复杂的逻辑结构，都可以通过它们来表达。所以任何一种高级语言都具备上述两种结构。  
本章是大家真正进入编程界的“门票”。  
【3】流程控制的流程：

![77789766899699e0a32a77a5cd28b424.png][]

分支结构(选择结构)

if单分支

【1】语法结构:  
if(布尔表达式)\{  
语句块  
\}  
if语句对布尔表达式进行一次判定，若判定为真，则执行\{\}中的语句块，否则跳过该语句块。流程图如图所示：

![744b893bebf52f113af00711cf1b90f0.png][]

【2】代码：

public class Test004 {
        public static void main(String[] args){
            //实现一个功能：给出三个数（1-6），对三个数求和计算，根据和的大小来分配不同的奖品
            //1.给出三个数：
            int num1 = 6;
            int num2 = 2;
            int num3 = 3;
            //2.求和
            int sum = 0;
            sum += num1;
            sum += num2;
            sum += num3;
            System.out.println("和为："+sum);
    
            //3.根据和判断奖品：
            //如果和大于等于14，那么就是一等奖
            if(sum>=14){
                System.out.println("一等奖");
                System.out.println("恭喜你很幸运，中了一等奖");
            }
    
            if(sum>=10&&sum<14){
                System.out.println("二等奖");
            }
    
            if(sum>=6&&sum<10){
                System.out.println("三等奖");
            }
    
            if(sum<6){
                System.out.println("四等奖");
            }
    
                    /*
                    if-单分支：
                    （1）结构：
                            if(条件表达式，这个表达式的结果是布尔值：要么是false，要么是true){
                                    //如果上面()中的表达式返回结果是true，那么执行{}中代码
                                    //如果上面()中的表达式返回结果是false ，那么不执行{}中代码
                                    //PS:{}中的代码是否执行，取决于()中表达式的返回结果
                            }
                    （2）上面的代码中，我用四个单分支拼凑出四个选择，每个选择是独立的，依次判断执行的
                    （3）if后面的()中的条件，要按照自己需求尽量完善
                    （4）{}可以省略不写,但是一旦省略，这个if就只负责后面的一句话，所以我们不建议初学者省略
                    */
        }
    }

if 多分支

【1】语法结构：  
if(布尔表达式1) \{  
语句块1;  
\} else if(布尔表达式2) \{  
语句块2;  
\}……  
else if(布尔表达式n)\{  
语句块n;  
\} else \{  
语句块n+1;  
\}  
当布尔表达式1为真时，执行语句块1；否则，判断布尔表达式2，当布尔表达式2为真时，执行语句块2；否则，继续判断布尔表达式3······；如果1~n个布尔表达式均判定为假时，则执行语句块n+1，也就是else部分。流程图如图所示：

![2126344772051dc96ef36f5f10d12fd1.png][]

【2】  
数轴分析：

![acfb7ebb4db66037e0a8f43643ed84fd.png][]

【3】代码：

public class TestIf02{
            public static void main(String[] args){
                    //实现一个功能：给出三个数（1-6），对三个数求和计算，根据和的大小来分配不同的奖品
                    //1.给出三个数：
                    int num1 = 6;
                    int num2 = 4;
                    int num3 = 2;
                    //2.求和
                    int sum = 0;
                    sum += num1;
                    sum += num2;
                    sum += num3;
                    System.out.println("和为："+sum);
                    
                    //3.根据和判断奖品：
                    /*
                    利用一个多分支
                    【1】结构：
                    if(){
                            
                    }else if(){
                            
                    }else if(){
                            
                    }...
                    else{
                            
                    }
                    【2】else:隐藏了一个条件，跟上面分支条件表达式相反的功能 (详见数轴分析)
                    【3】多分支：好处：只要满足一个 分支以后，后面的分支就不需要判断了 --》效率高
                    【4】我们写代码的时候，尽量保证else的存在--》else分支相当于“兜底”“备胎”的作用，别的分支都不走，就会走这个分支了
                    */
                    if(sum>=14){
                            System.out.println("一等奖");
                    }else if(sum>=10){//隐藏了sum<14
                            System.out.println("二等奖");
                    }else if(sum>=6){//隐藏了sum<10
                            System.out.println("三等奖");
                    }else{//隐藏了sum<6
                            System.out.println("四等奖");
                    }
                    
                    
                    
            }
    }

if 双分支

【1】语法结构:  
if(布尔表达式)\{  
语句块1  
\}else\{  
语句块2  
\}  
当布尔表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分。流程图如图所示：

![68de51226c84a6736e7d412fc68243ea.png][]

随机数

随机数：这个数在生成之前我们不确定这个数是多少，不可知

在java中依靠一个类：Math类帮助我们生成，这个类中有一个方法专门用来生成随机数：

![3fd161b6e443f50acb89409b8a08874e.png][]

Math.random() -------> \[0.0,1.0)  
Math.random()\*6 ----->\[0.0,6.0)  
(int)(Math.random()\*6) ----->\[0,5\]  
(int)(Math.random()\*6) +1 ----->\[1,6\]

应用到程序中：

int num1 = (int)(Math.random()*6) +1;
    int num2 = (int)(Math.random()*6) +1;
    int num3 = (int)(Math.random()*6) +1;

public class Test008 {
        //这是一个main方法,是程序的入口:
        public static void main(String[] args) {
            //练习：
            //[36,92]  -----> [0,56]+32 ----> (int)(Math.random()*57)+32
            System.out.println((int)(Math.random()*57)+32);
        }
    }

分支的嵌套使用

练习：  
会员购物时，不同积分享受的折扣不同，规则如下：

![45fc80b4f190918b279664f098dcd278.png][]

计算会员购物时获得的折扣，效果如下：

![20ddab0b3cfced8f048084c71c4fe954.png][]

public class Test008 {
        public static void main(String[] args){
            //1.给出积分：
            Scanner sc = new Scanner(System.in);
            System.out.print("请输入会员积分：");
    
            //先判断键盘录入的数据是不是int类型的
            if(sc.hasNextInt()==true){//是int类型数据：
                //将这个int类型的数据接收：
                int score = sc.nextInt();
                //判断这个积分是否是正数：
                if(score>=0){
                    String discount = "";
                    //2.根据积分判断折扣：
                    if(score>=8000){
                        discount = "0.6";
                    }else if(score>=4000){
                        discount = "0.7";
                    }else if(score>=2000){
                        discount = "0.8";
                    }else{
                        discount = "0.9";
                    }
                    System.out.println("该会员享受的折扣为："+discount);
    
                }else{//score<0
                    System.out.println("对不起，你录入的积分是负数！不符合需求！");
                }
            }else{//不是int类型的数据
                System.out.println("你录入的积分不是整数！");
            }
        }
    }

练习：  
小朋友搬桌子：  
年龄大于7岁，可以搬桌子；  
如果年龄大于5岁，性别是男，可以搬桌子；  
否则不可以搬动桌子，提示：你还太小了

本题主要考的是：逻辑

方式1：性别用0或者1接收：

public class Test008 {
        public static void main(String[] args){
            //1.录入小朋友的年龄：
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入小朋友的年龄：");
            int age = sc.nextInt();
    
            //2.根据年龄判断：
            if(age>=7){
                System.out.println("yes");
            }else if(age>=5){
                //录入小朋友的性别；
                System.out.println("请录入小朋友的性别：男：1  女 ：0");
                int sex = sc.nextInt();
                if(sex==1){//男生
                    System.out.println("yes");
                }else{//女孩
                    System.out.println("no");
                }
            }else{//age<5
                System.out.println("no");
            }
        }
    }

方式2：性别用男或者女接收：

public class Test008 {
        public static void main(String[] args){
            //1.录入小朋友的年龄：
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入小朋友的年龄：");
            int age = sc.nextInt();
    
            //2.根据年龄判断：
            if(age>=7){
                System.out.println("yes");
            }else if(age>=5){
                //录入小朋友的性别；
                System.out.println("请录入小朋友的性别：");
                String str = sc.next();
                char sex = str.charAt(0);
                if(sex=='男'){
                    System.out.println("yes");
                }else{
                    System.out.println("no");
                }
            }else{//age<5
                System.out.println("no");
            }
        }
    }

switch 多分支结构

【1】switch多分支结构(多值情况)  
语法结构：  
switch (表达式) \{  
case 值1:  
语句序列1;  
\[break\];  
case 值2:  
语句序列2;  
\[break\];  
… … … … …  
\[default:默认语句;\]  
\}

switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者是switch语句的末尾。如果表达式的值与任一case值不匹配，则进入default语句（如果存在default语句的情况）。根据表达式值的不同可以执行许多不同的操作。switch语句中case标签在JDK1.5之前必须是整数（long类型除外）或者枚举，不能是字符串，在JDK1.7之后允许使用字符串(String)。大家要注意，当布尔表达式是等值判断的情况，可以使用if-else if-else多分支结构或者switch结构，如果布尔表达式区间判断的情况，则只能使用if-else if-else多分支结构。switch多分支结构的流程图如图所示：

![f3d27f8e211858d205484c12be7f418d.png][]

【2】练习

public class TestSwitch{
            public static void main(String[] args){
                    /*
                    实现一个功能：
                    根据给出的学生分数，判断学生的等级：
                    >=90  -----A
                    >=80  -----B
                    >=70  -----C
                    >=60  -----D
                    <60   -----E
                    
                    用if分支：
                    if(score>=90){
                            
                    }else if(score>=80){
                            
                    }
                    */
                    //1.给出学生的成绩：
                    int score = 167;
                    //2.根据成绩判断学生的等级：
                    switch(score/10){
                            case 10 : 
                            case 9 : System.out.println("A级");break;
                            case 8 : System.out.println("B级");break;
                            case 7 : System.out.println("C级");break;
                            case 6 : System.out.println("D级");break;
                            default:System.out.println("成绩错误");break;
                            case 5 :  
                            case 4 :  
                            case 3 :  
                            case 2 :  
                            case 1 :  
                            case 0 : System.out.println("E级");break;
                            
                    }
                    /*
                    【1】语法结构：
                    switch(){
                            case * :
                            case * :
                            .......
                    }
                    【2】switch后面是一个()，()中表达式返回的结果是一个等值，这个等值的类型可以为：
                    int,byte,short,char,String,枚举类型
                    【3】这个()中的等值会依次跟case后面的值进行比较，如果匹配成功，就执行:后面的代码
                    【4】为了防止代码的“穿透”效果：在每个分支后面加上一个关键词break，遇到break这个分支就结束了
                    【5】类似else的“兜底”“备胎”的分支：default分支
                    【6】default分支可以写在任意的位置上，但是如果没有在最后一行，后面必须加上break关键字，
                    如果在最后一行的话，break可以省略
                    【7】相邻分支逻辑是一样的，那么就可以只保留最后一个分支，上面的都可以省去不写了
                    【8】switch分支和if分支区别：
                    表达式是等值判断的话--》if ，switch都可以
                    如果表达式是区间判断的情况---》if最好
                    【9】switch应用场合：就是等值判断，等值的情况比较少的情况下
                    */
            }
    }

[77789766899699e0a32a77a5cd28b424.png]: https://img-blog.csdnimg.cn/img_convert/77789766899699e0a32a77a5cd28b424.png
[744b893bebf52f113af00711cf1b90f0.png]: https://img-blog.csdnimg.cn/img_convert/744b893bebf52f113af00711cf1b90f0.png
[2126344772051dc96ef36f5f10d12fd1.png]: https://img-blog.csdnimg.cn/img_convert/2126344772051dc96ef36f5f10d12fd1.png
[acfb7ebb4db66037e0a8f43643ed84fd.png]: https://img-blog.csdnimg.cn/img_convert/acfb7ebb4db66037e0a8f43643ed84fd.png
[68de51226c84a6736e7d412fc68243ea.png]: https://img-blog.csdnimg.cn/img_convert/68de51226c84a6736e7d412fc68243ea.png
[3fd161b6e443f50acb89409b8a08874e.png]: https://img-blog.csdnimg.cn/img_convert/3fd161b6e443f50acb89409b8a08874e.png
[45fc80b4f190918b279664f098dcd278.png]: https://img-blog.csdnimg.cn/img_convert/45fc80b4f190918b279664f098dcd278.png
[20ddab0b3cfced8f048084c71c4fe954.png]: https://img-blog.csdnimg.cn/img_convert/20ddab0b3cfced8f048084c71c4fe954.png
[f3d27f8e211858d205484c12be7f418d.png]: https://img-blog.csdnimg.cn/img_convert/f3d27f8e211858d205484c12be7f418d.png