【无标题】流程控制语句

最新推荐文章于 2024-08-23 15:54:50 发布

木笛そ

最新推荐文章于 2024-08-23 15:54:50 发布

阅读量52

点赞数 1

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_67138897/article/details/132113151

版权

文章目录

前言
一、流程控制的作用
二、控制语句的分类
- 1.顺序j结构
- 2.选择结构
- 3.循环结构
这三种基本逻辑结构是相互支撑的，它们共同构成了算法的基本结构，无论怎样复杂的逻辑结构，都可以通过它们来表达。所以任何一种高级语言都具备上述两种结构。

前言

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

提示：以下是本篇文章正文内容，下面案例可供参考

一、流程控制的作用

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

二、控制语句的分类

1.顺序结构

（1）语法结构

if(布尔表达式){

语句块

}

例：

if(条件表达式，这个表达式的结果是布尔值：要么是false，要么是true){

//如果上面()中的表达式返回结果是true，那么执行{}中代码

//如果上面()中的表达式返回结果是false ，那么不执行{}中代码

//PS:{}中的代码是否执行，取决于()中表达式的返回结果

}

（2）代码：

public class TestIf01{
        public static void main(String[] args){
                //需求：键盘录入女婿的酒量，如果大于2斤，老丈人给出回应，反之不回应
                //1、键盘录入女婿的酒量
                Scanner sc = new Scanner(System.in);
                System.out.println("请输入女婿的酒量：");
                int wine = sc.nextInt();
                //2、对酒量进行判断
                if(wine > 2){
                    System.out.println("小伙子，不错哟！");
                }
               
        }
}

2、选择结构

2.1 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部分。流程图如图所示：

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("四等奖");
                }   
        }
}

（2）双分支结构

语法结构:

if(布尔表达式){

语句块1

}else{

语句块2

}

当布尔表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分。流程图如图所示：

（3）多分支嵌套

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

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

【本题主要考的是 if语句的嵌套使用：】

import java.util.Scanner;
public class TestIf04{
        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("你录入的积分不是整数！");
                }
        }
}

2.2 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多分支结构的流程图如图所示：

【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应用场合：就是等值判断，等值的情况比较少的情况下

3.循环结构

3.1 while

【1】语法结构：

while (布尔表达式) {

循环体;

}

在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。

语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。

while循环结构流程图如图所示:

【2】代码：求1—5的和

public class TestWhile{
        public static void main(String[] args){
                //功能：1+2+3+4+5
                //1.定义变量：
                int num = 1;[1]条件初始化
                //2.定义一个求和变量，用来接收和：
                int sum = 0;              
                while(num<=5){[2]条件判断
                        sum += num;[3]循环体
                        num++;[4]迭代
                }      
                //3.输出和
                System.out.println(sum);
        }
}

3.2 do-while

【1】语法结构：

do {

循环体;

} while(布尔表达式) ;

do-while循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while循环的循环体至少执行一次。do-while循环结构流程图如图所示：

【2】代码：

public class TestDoWhile{
        public static void main(String[] args){
                //1+2+3+4+...100
                //while方式:
                /*
                int i = 101;
                int sum = 0;
                while(i<=100){
                        sum += i;
                        i++;
                }
                System.out.println(i);//101
                System.out.println(sum);//0
                */
                //do-while方式：
                
                int i = 101;
                int sum = 0;
                do{
                        sum += i;
                        i++;
                }while(i<=100);//一定要注意写这个分号，否则编译出错
                System.out.println(i);//102
                System.out.println(sum);//101
                
        }
}

（1）while和do-while的区别:
while:先判断，再执行
do-while:先执行，再判断---》至少被执行一次，从第二次开始才进行判断
（2）什么场合使用do-while:

while(考试是否通过){
考试；
}
---》不合适
do{
考试；
}while(考试是否通过);
---》合适

3.3 for

【1】语法结构：

for (初始表达式; 布尔表达式; 迭代因子) {

循环体;

}

for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式；随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环；最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。

初始化部分设置循环变量的初值

条件判断部分为任意布尔表达式

迭代因子控制循环变量的增减

for循环在执行条件判定后，先执行的循环体部分，再执行步进。

for循环结构的流程图如图所示：

【2】代码：

public class TestFor01{
        public static void main(String[] args){
                //1+2+3+..+100
                //while:
                int i = 1;
                int sum = 0;
                while(i<=100){
                        sum += i;
                        i++;
                }
                System.out.println(sum);
                
                
                //for:
                int sum = 0;
                int i;
                for(i = 1;i<=100;i++){
                        sum += i;
                }
                System.out.println(sum);
                System.out.println(i);
                
               
                }

总结

1.if多分支语句和switch多分支语句的异同之处

相同之处：都是分支语句，多超过一种的情况进行判断处理。

不同之处：

（1）SWITCH更适合用于多分支情况，就是有很多种情况需要判断处理，判断条件类型单一，只有一个入口，在分支执行完后（如果没有break跳出），不加判断地执行下去;而if—elseif---else多分枝主要适用于分支较少的分支结构，判断类型不是单一，只要一个分支被执行后，后边的分支不再执行。

（2）switch为等值判断（不允许比如>= <=），而if为等值和区间都可以，if的使用范围大。

2.和do-while循环的区别

while先判断后执行，第一次判断为false,循环体一次都不执行

do while先执行后判断，最少执行1次。

如果while循环第一次判断为true, 则两种循环没有区别。

3.break和continue的作用

break: 结束当前循环并退出当前循环体。