【无标题】三. 流程控制

最新推荐文章于 2024-09-14 22:07:12 发布

IT boy板砖人

最新推荐文章于 2024-09-14 22:07:12 发布

阅读量116

点赞数

文章标签：大数据

本文链接：https://blog.csdn.net/m0_59621633/article/details/125810957

版权

本文详细介绍了Java中的流程控制，包括顺序执行、分支选择和循环。重点讲解了分支选择的if语句，如单分支if、if-else、if-else if...else和switch-case结构，以及循环的while、do-while和for循环。通过实例演示了如何在不同场景中使用这些控制结构，如计算最大值、分数评级、累加和以及解决数学问题等。

摘要由CSDN通过智能技术生成

三. 流程控制

概述
控制代码的执行的流程。
分类：
- 顺序执行
- 分支选择
- 循环

3.1 流程控制-分支选择

3.1.1 if - 嵌套if

class TestIf{
    
    public static void main(String[] args){
        /*单分支 if语句：
            
          作用：控制一个分支代码是否被执行。
          
          语法：if(条件){if 分支代码}
          
          解释：
            if：java 的关键字，用来控制单分支条件的。
            (条件)：条件 必须是一个 boolean 表达式。
            {需要执行的分支代码}：
                所有的合法的java代码都可以作为内容。
                
         执行过程：
            1：判断条件是否成立：true or false。
            2：如果 true，成立了，那么就执行分支。
            3：如果false，不成立，那么就不执行分支。
            
        注意：
            如果分支代码只有一条语句，那么可以省略大括号。多条语句，必须使用大括号。
            通过条件控制整个大括号中的内容是否被执行。
        */
        final int MIN = 0;
        final int MAX = 100;
        
        int num = (int)(Math.random()*(MAX-MIN)+MIN);
        
        System.out.println(num);
        
        if(num % 2 != 0)
            System.out.println("奇数");
        
        if(num % 2 == 0)
            System.out.println("偶数");
        
        //求三个数的最大值。
        int num1 = (int)(Math.random()*(MAX-MIN)+MIN);
        int num2 = (int)(Math.random()*(MAX-MIN)+MIN);
        int num3 = (int)(Math.random()*(MAX-MIN)+MIN);
        System.out.println("num1 = " +num1 + "\tnum2 = "+ num2+ "\tnum3 = "+ num3);
        int max = 0;
        if(num1 >= num2 && num1 >= num3){
            max = num1;
        }
        if(num2 >= num1 && num2 >= num3){
            max = num2;
        }
        if(num3 >= num1 && num3 >= num2){
            max = num3;
        }
        
        System.out.println("max = "+max);
        
        //升序输出三个随机数。
        if(num1 <= num2 && num2 <= num3){   
        }
    }
}

3.1.2 if-else


class TestIfElse{
    
    public static void main(String[] args){
        /*
        if- else:
            双分支的流程控制语句。
        语法：
            if(条件){
                //if 分支代码
            }else{
                //else 分支。
            }
        if  else 都是 关键字。
        
        执行过程：
            1：计算if 条件。
            2：条件是true：执行 if 分支。不执行esle 分支。
            3：false，那么就跳过if 分支，直接执行esle 分支。
            
        特点：
            1：执行且必须执行其中的一个分支。互斥的。
            2：else 不能单独存在。必须和if 配对。
            3：2个分支代码，如果只有一条语句，可以省略大括号。
            
        使用的场景：问题只有两种可能。
        */
        
        //随机得到一个大写的字符。
        final int MIN_CHAR = 'A';
        final int MAX_CHAR = 'Z'+1;
        
        boolean isUpperCase = true;
        //大写的。
        char ranChar = (char)(Math.random()*(MAX_CHAR-MIN_CHAR)+MIN_CHAR);
        //50% 切换成小写。
        if(Math.random()>0.5){
            ranChar += 32;
            isUpperCase = false;
        }
        
        System.out.println(ranChar);
        
        if(isUpperCase){
            ranChar += 32;
        }else{
            ranChar -= 32;
        }
        System.out.println("转换后："+ranChar);
        
        //判断一个随机数 奇数  偶数。
        final int MIN = 0;
        final int MAX = 100;
        
        int ran = (int )(Math.random()*(MAX-MIN)+MIN);
        if(ran % 2 == 0){
            System.out.println(ran + "偶数");
        }else{
            System.out.println(ran + "奇数");
        }
    }
}

3.1.3 if-else if...else


class TestIfElseIf{
    
    public static void main(String[] args){
        /*
        多分支：if-else if ... else
        
        语法：
            if(条件1){
                分支1
            }else if(条件2){
                ...分支2
            }else if(条件n){
                分支3
            }else{
                分支n
            }
            
        执行过程：
            1：先判断条件1. 成立，执行 对应的分支。后面的都被跳过。
            2：条件不成立，判断下一个条件。依次类推。
            3：如果所有的条件都没有成立，那么就执行最后的else 分支。
            
            
        使用的场景：
            1：多分支选择的场景。
            2：只能执行其中的一个分支。
            
        注意：
            1：如果多分支，最后有else。那么必须有一个分支会被执行。
            2：最后的else 不是必须要有的。如果没有else，那么可能一个分支都不被执行。
            3：每个else 必须和一个if 配对。else 的数量小于等于 if。
        */
        
        final int MIN = 0;
        final int MAX = 101;
        
        int score = (int)(Math.random()*(MAX-MIN)+MIN);
        System.out.println("score = " + score);
        
        char ch;
        if(score >=90){
            ch = 'A';
        }else if(score >= 80){
            ch = 'B';
        }else if(score >= 70){
            ch = 'C';
        }else if(score >= 60){
            ch = 'D';
        }else{
            ch = 'E';
        }
        System.out.println("分数评级 = " + ch);
        
        //打印人的一个上学的状态。
        final int MAX_AGE = 30;
        final int MIN_AGE = 0;
        
        int age = (int)(Math.random()*(MAX_AGE-MIN_AGE)+MIN_AGE);
        
        System.out.println("age = " + age);
        
        if(age>=3 && age<6){
            System.out.println("幼儿园小朋友！");
        }else if(age>=6 && age <= 11){
            System.out.println("小学生！");
        }else if(age>=12 && age <= 14){
            System.out.println("初中生！");
        }else if(age>=15 && age <= 17){
            System.out.println("高中生！");
        }else if(age>=18 && age <= 21){
            System.out.println("大学生！");
        }
    }
}

3.1.4 switch

case 穿透


class TestSwitch{
    
    public static void main(String[] args){
        /*
        多分支选择：switch
        
        switch：开关
        case：条件，箱子。
        break：打断
        default：默认的
        
        语法：
            switch(变量表达式){
                case 常量表达式1:
                    分支代码1
                [break;]
                case 常量表达式2:
                    分支代码3
                break;
                ....
                case 常量表达式n:
                    分支代码n
                break;
                default:
                    分支代码..
                break;
            }
        
        解释：
            1：变量表达式，必须包含至少一个变量的表达式。
            2：变量表达式 返回值的类型有要求：
                    byte、short int char String enum。
            3：case 后跟必须是常量表达式。不能包含变量。必须是一个固定的值。
                表达式的返回值类型 必须和 switch 后的返回值兼容。byte、short int char String enum。
            
        执行过程：
            1：计算变量表达式的返回值。
            2：使用该返回值和后面每个case 后的值进行等值比较（比较是否相等）。如果相等了，那么就执行对应的分支。遇到break 结束switch。
            3：如果所有的分支都不相等，那么就执行最后的default 分支代码。
            
        注意：
            1：每个case 后的值必须不同。
            2：break 是可选的。如果一个case 后没有break。那么它后面的case 会被穿透，会被当做普通的代码执行。直到遇到break 结束switch。
            3: 最后的default 可以没有。如果没有，那么可能一个分支都不执行。
            
        if-else 多分支 和 switch 的区别：
            1：switch case 有数据类型的限制。
            2：switch case 只能进行等值判断。不能进行不等值判断。
            3：if-else 多分支可以进行不等值和等值比较，数据类型没有限制。
        总结：
            switch case 结构能实现的功能，if-else if 一定可以的。，反之不可以。
        */
        
        final int MIN = 0;
        final int MAX = 101;
        
        int score = (int)(Math.random()*(MAX-MIN)+MIN);
        System.out.println("score = " + score);
        
        char ch;
        score /= 10;
        switch(score){
            //多个case 执行同一个分支的写法。
            case 10:case 9:
                ch = 'A';
            break;
            case 8:
                ch = 'B';
            break;
            case 7:
                ch = 'C';
            break;
            case 6:
                ch = 'D';
            break;
            default:
                ch = 'E';
            break;
        }
        System.out.println("分数评级 = " + ch);
    }
}

3.2 流程控制 - 循环

loop
如果需要反复的执行某些代码。

3.2.1 循环的分类

while
do-while（了解）
for

3.2.2 while

class TestWhile{
    
    public static void main(String[] args){
        /*
            while 循环：
            语法：
                while(条件);{
                    //循环体 
                }
                
            解释：
                1：while 关键字。
                2：循环条件：boolean 表达式。
                3：循环体：需要反复执行的代码。
                
            执行过程：
                1：判断条件，如果是true，那么就执行循环体。执行完循环体，继续判断循环条件。
                2：依次类推，直到循环条件为false，立即结束循环。
                
            注意：
                1：如果循环体只有一句代码，可以省略大括号。
                2：不要在循环条件后添加分号，如果添加了，那么分号就作为了循环体。
        */
        
        //100个helloworld。
        //计数器。
        int counter = 0;
        while(counter < 10){
            System.out.println("hello world!--" + ++counter);
        }
        
        //1--100的累加和。
        int sum = 0;//累加和
        int num = 1;
        
        while(num <= 100){
            sum = sum + num;
            num ++;
        }
        System.out.println("sum = " + sum);//5050
        
        //1--100的偶数的累加和。
        sum = 0;
        num = 2;
        while(num <= 100){
            sum = sum + num;
            num += 2;
        }
        System.out.println("sum = " + sum);//2550
        
        //1--100的奇数的累加和。
        sum = 0;
        num = 1;
        while(num < 100){
            if(num % 2 != 0){
                sum = sum + num;
            }
            num ++;
        }
        System.out.println("sum = " + sum);//2500
        
        //今有雉兔同笼，上有三十五头，下有九十四足，问雉兔各几何？
        final int COUNT = 35;
        final int FOOTS_COUNT = 94;
        int chickenCount = 0;
        int rabbitCount = COUNT-chickenCount;
        
        while(chickenCount <= COUNT){
            //求兔子的数量
             rabbitCount = COUNT-chickenCount;
             
             //判断是否满足条件。
             if(chickenCount * 2 + (rabbitCount << 2) == FOOTS_COUNT){
                 System.out.println("兔子的数量："+rabbitCount + "\t公鸡的数量："+chickenCount);
             }
             
             chickenCount++;
        }
        //小刚带着100钱去买水喝。一瓶水2元，退一个空瓶子1元，退一个空瓶盖5毛，问可以买多少瓶水。
        double money = 100;
        final int WATER_PRICE = 2;
        final int ENPTY_PRICE = 1;
        final double BOTTLE_COVER = 0.5;
        
        counter = 0;
        while(money >= WATER_PRICE){
            //买水
            money -= WATER_PRICE;
            
            //喝水
            counter ++;
            
            //退瓶
            money += ENPTY_PRICE;
            
            //退瓶盖
            money += BOTTLE_COVER;
        }
        
        System.out.println("counter = " + counter + "\tmoney = " + money);
        
        //要求使用随机数，使用循环，得到一个5和7的公倍数。
        final int MIN = 1;
        final int MAX = 100;
        
        int ran = (int)(Math.random()*(MAX-MIN)+MIN);
        
        while(ran % 5 != 0 || ran % 7 != 0){//ran  不是 5和 7 的公倍数。
            ran = (int)(Math.random()*(MAX-MIN)+MIN);
        }
        
        System.out.println(ran);
        ran = (int)(Math.random()*(MAX-MIN)+MIN);
        
        while(!(ran % 5 == 0 && ran % 7 ==0)){//ran  不是 5和 7 的公倍数。
            ran = (int)(Math.random()*(MAX-MIN)+MIN);
        }
        
        System.out.println(ran);
    }
}

3.2.3 循环的构成

循环条件初始化部分。
循环条件。
循环体。
迭代 a++；

3.2.4 do-while


class TestDoWhile{
    
    public static void main(String[] args){
        /*
            do-while 循环。
            
            语法：
                do{
                    //循环体。
                }while(条件);
                
            执行过程：
                1：直接执行循环体，然后再做条件的判断。
                2：条件成立，执行循环体，然后再判断，依次类推，直到条件为false。结束循环。
                
            注意：
                1：do while 最后需要使用  ;  结尾。
        */
        
        //1-100的累加和。
        int sum = 0;
        int num = 1;
        do{
            sum += num;
            num ++;
        }while(num <= 100);
        System.out.println("sum = " + sum);
        
        //随机获取一个5和7的公倍数。
        final int MIN = 1;
        final int MAX = 100;
        
        int ran;
        do{
            ran = (int)(Math.random()*(MAX-MIN)+MIN);
        }while(ran % 5 !=0 || ran % 7 != 0);
        System.out.println("ran = " + ran);
    }
}

3.2.5 for

3.2.6 break 和 continue


class TestBreak{
    
    public static void main(String[] args){
        /*
            break:
                1: java 关键字。
                2：在switch 中使用break; 用来结束switch 语句.
                3: break 还可以在循环体中使用， break; 用来结束循环。
                
            注意：尽量使用循环条件结束循环，不要过于依赖break。
        */
        
        //要求使用随机数，使用循环，得到一个5和7的公倍数。
        final int MIN = 1;
        final int MAX = 100;
        
        int ran = (int)(Math.random()*(MAX-MIN)+MIN);
        
        while(true){//ran  不是 5和 7 的公倍数。
            ran = (int)(Math.random()*(MAX-MIN)+MIN);
            
            if(ran % 5==0 && ran % 7 ==0)
                break;
        }
        System.out.println(ran);
        
        int sum = 0;
        for(int i=1;;i++){
            sum += i;
            if(i==100)
                break;
        }
        System.out.println(sum);
    }
}


class TestContinue{
    
    public static void main(String[] args){
        /*
            continue：继续的意思。
                1：java 的关键字。
                2：continue 只能在循环体中使用。
                3：作用：跳过本次循环，继续下次循环。
                
            1：while 中执行到了continue。那么直接跳转到 while 的循环条件判断处去执行。
            2：for 中执行到了continue。那么直接跳转到 迭代处去执行。
        */
        
        //偶数的累加和。
        int sum = 0;
        for(int i=2;i<=100;i+=2){
            sum += i;
        }
        System.out.println("sum = " + sum);
        
        //奇数的累加和。
        sum = 0;
        for(int i=99;i>=1;i--){
            if(i % 2 != 0){
                sum += i;
            }
        }
        System.out.println("sum = " + sum);
        
        //使用continue 实现1-100的奇数的累加和。
        sum = 0;
        for(int i=1;i<100;i++){
            if(i%2==0)
                continue;
            sum += i;
        }
        System.out.println("sum = " + sum);
    }
}

3.3 石头剪刀布

//猜丁壳
import java.util.Scanner;
class Game{
    
    public static void main(String[] args){
        //功能：和电脑玩猜丁壳的游戏，五局三胜制。打印比赛的过程。输出最终的结果。
        //变量：
        int playerInput;
        int computerInput;
        
        int playerWinCount = 0;
        int computerWinCount = 0;
        
        int counter = 1;
        
        //常量
        final int STONE = 0;
        final int SCISSOR = 1;
        final int PAPER = 2;
        
        final int MAX_WIN_COUNT = 3;
        
        //创建扫描器对象。
        Scanner scan = new Scanner(System.in);
        
        
        while(playerWinCount <MAX_WIN_COUNT && computerWinCount < MAX_WIN_COUNT){
            System.out.println("***********************第【"+counter+"】局开始了***********************");
            //玩家输入一个
            System.out.println("请您选择手势：【0-->石头】【1-->剪刀】【2-->布】的值：");
            playerInput = scan.nextInt();
            
            //电脑随机一个。
            computerInput = (int)(Math.random()*(PAPER + 1 - STONE) + STONE);
            
            //打印玩家和电脑的选择的手势信息。
            switch(playerInput){
                case STONE:
                    System.out.println("玩家选择的是：【石头】");
                break;
                case SCISSOR:
                    System.out.println("玩家选择的是：【剪刀】");
                break;
                case PAPER:
                    System.out.println("玩家选择的是：【布】");
                break;
            }
            
            if(computerInput == STONE){
                System.out.println("电脑选择的是：【石头】");
            }else if(computerInput == SCISSOR){
                System.out.println("电脑选择的是：【剪刀】");
            }else{
                System.out.println("电脑选择的是：【布】");
            }
            
            //比较
            switch(playerInput){
                case STONE://玩家石头。
                    if(computerInput == STONE){
                        //
                        System.out.println("本局平局~~~~");
                    }else if(computerInput == SCISSOR){
                        System.out.println("本局【玩家】胜利了~~~~");
                        playerWinCount ++;
                    }else{
                        System.out.println("本局【电脑】胜利了~~~~");
                        computerWinCount ++;
                    }
                break;
                case SCISSOR://玩家剪刀
                    if(computerInput == STONE){
                        //
                        System.out.println("本局【电脑】胜利了~~~~");
                        computerWinCount ++;
                        
                    }else if(computerInput == SCISSOR){
                        System.out.println("本局平局~~~~");
                        
                    }else{
                        System.out.println("本局【玩家】胜利了~~~~");
                        playerWinCount ++;
                    }
                break;
                case PAPER://玩家布
                    if(computerInput == STONE){
                        System.out.println("本局【玩家】胜利了~~~~");
                        playerWinCount ++;
                        //
                    }else if(computerInput == SCISSOR){
                        System.out.println("本局【电脑】胜利了~~~~");
                        computerWinCount ++;
                    }else{
                        System.out.println("本局平局~~~~");
                    }
                break;
            }
            
            //输出当前比分。
            System.out.println("【玩家】vs【电脑】\t\t 【"+playerWinCount+"】vs【"+computerWinCount+"】");
            
            System.out.println("***********************第【"+counter++ +"】局结束了***********************");
        }
        
        //输出比赛结果。
        if(playerWinCount == MAX_WIN_COUNT){
            System.out.println("【玩家】胜利了");
        }else{
            System.out.println("【电脑】胜利了");
        }
    }
}

3.4 嵌套循环