java_流程控制

最新推荐文章于 2024-06-16 09:46:44 发布

连梓豪

最新推荐文章于 2024-06-16 09:46:44 发布

阅读量45

点赞数

分类专栏： Java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_48213795/article/details/130491138

版权

Java基础专栏收录该内容

7 篇文章 0 订阅

订阅专栏

分支结构

if分支

单分支

语法结构

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

if语句对布尔表达式进行一次判定，若判定为真，则执行{}中的语句块，否则跳过该语句块。流程图如图所示：在这里插入图片描述
示例

public class TestIf01{
        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) {
        语句块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("四等奖");
                }        
        }
}

双分支

语法结构

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

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

switch分支

switch多分支结构(多值情况)

语法结构

switch (表达式) {
    case 值1:
         语句序列1;
         [break];
    case 值2:
         语句序列2;
         [break];
        … … …      … …
    [default:默认语句;]
}

case支持的数据类型

基本数据类型：byte, short, char, int
包装数据类型：Byte, Short, Character, Integer
枚举类型：Enum
字符串类型：String（Jdk 7+ 开始支持）

switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者是switch语句的末尾。如果表达式的值与任一case值不匹配，则进入default语句（如果存在default语句的情况）。根据表达式值的不同可以执行许多不同的操作。
在这里插入图片描述
示例

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,enum
                
                【3】这个()中的等值会依次跟case后面的值进行比较，如果匹配成功，就执				 行:后面的代码
                【4】为了防止代码的“穿透”效果：在每个分支后面加上一个关键词break，遇				  到break这个分支就结束了
                【5】类似else的“兜底”“备胎”的分支：default分支
                【6】default分支可以写在任意的位置上，但是如果没有在最后一行，后面必				  须加上break关键字，
                如果在最后一行的话，break可以省略
                【7】相邻分支逻辑是一样的，那么就可以只保留最后一个分支，上面的都可以省				去不写了
                【8】switch分支和if分支区别：
                表达式是等值判断的话--》if ，switch都可以
                如果表达式是区间判断的情况---》if最好
                【9】switch应用场合：就是等值判断，等值的情况比较少的情况下
                */
        }
}

循环结构

while循环

语法结构

while (布尔表达式) {
            循环体;
}

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

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

while循环结构流程图如图所示: 在这里插入图片描述
示例

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

循环的执行过程：在这里插入图片描述

do while循环

语法结构

do {
     循环体;
    } while(布尔表达式) ;

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

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(考试是否通过);
                ---》合适
                */
                
        }
}

for循环

语法结构

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

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

初始化部分设置循环变量的初值
条件判断部分为任意布尔表达式
迭代因子控制循环变量的增减

for循环在执行条件判定后，先执行的循环体部分，再执行步进。
for循环结构的流程图如图所示：在这里插入图片描述
示例

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】for的结构：
                for(条件初始化;条件判断;迭代){
                        循环体；
                }
                
                【2】i的作用域：作用范围：离变量最近{}  --->可以自己去控制
                【3】for循环格式特别灵活：格式虽然很灵活，但是我们自己写代码的时候不建				 议灵活着写。
                for(;;){}  -->死循环
                
                int i = 1;
                for(;i<=100;){
                        sum += i;
                        i++;
                }
                
                【4】死循环：
                for(;;){}
                
                while(true){}
                
                do{
                        
                }while(true);
                
                【5】循环分为两大类：
                第一类：当型   while(){}   for(;;){}
                第二类：直到型  do{}while();
                
                【6】以后常用：for循环 
                【7】do-while,while,for循环谁的效率高？  一样高 
                */
        }
}

break

作用：停止循环

示例

public class TestFor02{
        public static void main(String[] args){
                //功能：求1-100的和，当和第一次超过300的时候，停止程序
                int sum = 0;
                for(int i=1;i<=100;i++){	
                        sum += i;	
                        if(sum>300){//当和第一次超过300的时候
                                //停止循环
                                break;//停止循环
                        }
                        System.out.println(sum);
                }
                
        }
}

public class TestFor02{
        public static void main(String[] args){
                //功能：求1-100的和，当和第一次超过300的时候，停止程序
                int sum = 0;
                for(int i=1;i<=100;i++){	
                        sum += i;	
                        if(sum>300){//当和第一次超过300的时候
                                //停止循环
                                break;//停止循环
                        }
                        System.out.println(sum);
                }
                
        }
}

break带标签的使用：

public class TestFor04{
        public static void main(String[] args){
                outer:     ----》定义标签结束的位置
                for(int i=1;i<=100;i++){
                        System.out.println(i);
                        while(i==36){
                                break outer;    ----》根据标签来结束循环 
                        }
                }
        }
}

多层循环也可以使用标签，按照自己的需求去设定即可：

continue

作用：结束本次循环，继续下一次循环

示例

public class TestFor05{
        public static void main(String[] args){
                //功能：输出1-100中被6整除的数：
                //方式1：
                /*
                for(int i=1;i<=100;i++){	
                        if(i%6==0){//被6整除
                                System.out.println(i);
                        }
                }
                */
                
                //方式2：
                for(int i=1;i<=100;i++){	
                        if(i%6!=0){//不被6整除
                                continue;//停止本次循环，继续下一次循环
                        }
                        System.out.println(i);
                }
        }
}

public class TestFor06{
        public static void main(String[] args){
                //continue:结束本次离它近的循环，继续下一次循环
                /*
                for(int i=1;i<=100;i++){	
                        if(i==36){
                                continue;//1-100中间没有36
                        }
                        System.out.println(i);
                }
                */
                
                for(int i=1;i<=100;i++){	
                        while(i==36){
                                System.out.println("------");
                                continue; //1-35+死循环
                        }
                        System.out.println(i);
                }
        }
}

continue带标签的使用：

public class TestFor07{
        public static void main(String[] args){
           
                outer:
                for(int i=1;i<=100;i++){	
                        while(i==36){ 
                                continue outer;  //1-100没有36
                        }
                        System.out.println(i);
                }
        }
}

return

作用：跟循环无关，就是程序中遇到return那么return所在的那个方法就停止执行了。

示例

public class TestFor08{
        public static void main(String[] args){
                //return:遇到return结束当前正在执行的方法
                for(int i=1;i<=100;i++){	
                        while(i==36){ 
                                return;  
                        }
                        System.out.println(i);
                }
                
                System.out.println("-----");
        }
}

连梓豪

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
java_流程控制

随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环；当布尔表达式1为真时，执行语句块1；do-while循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。if语句对布尔表达式进行一次判定，若判定为真，则执行{}中的语句块，否则跳过该语句块。当布尔表达式为真时，执行语句块1，否则，执行语句块2。for循环在执行条件判定后，先执行的循环体部分，再执行步进。
复制链接

扫一扫