流程控制语句

Y423x發表於2024-02-29

流程控制语句

顺序结构

//范例：
public class Test {
    public static void main(String[] args) {
        System.out.println("努力做主人喜欢的事");
        System.out.println("大小姐驾到！通通闪开！");
        System.out.println("凌冬已至，故乡的梅花开了吗");
        System.out.println("心怀不惧，方能翱翔于天际");
    }
}

顺序结构语句是Java程序默认的执行流程，按照代码的先后顺序，从上到下依次执行

分支结构

If语句

If语句在程序中是用来判断的

第一种格式（单条件判断）

格式：

if (关系表达式) {
    语句体;
}

举例：

if (酒量 > 2) {
    System.out.println("小伙子，不错！");
}

执行流程：

  1. 首先计算关系表达式的值
  2. 如果关系表达式的值为true就执行语句体
  3. 如果关系表达式的值为false就不执行语句体
  4. 继续执行后面的其他语句

练习--老丈人选女婿

需求：键盘录入女婿酒量，如果大于2斤，老丈人给出回应，反之不回应

import java.util.Scanner;

public class IfDemo1 {
    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("小伙子，不错呦！！");
        }
    }
}

if的注意点：

  1. 大括号的开头可以另起一行书写，但是建议写在第一行的末尾
  2. 在语句体中，如果只有一句代码，大括号可以省略不写。（个人建议，大括号还是不要省略的）
  3. 如果对一个布尔类型的变量进行判断，建议不要用号（因为可能会把写成=），直接把变量写在小括号即可

练习--考试奖励

小红：如果你这次考试全班第一，我就做你女朋友。

public class Test1 {
    public static void main(String[] args) {
        //小红：如果你这次考试全班第一，我就做你女朋友。

        //分析：
        //1.定义变量记录小明的名次
        int ranking = 1;
        //2.对小明的名次进行判断
        if(ranking == 1){
            System.out.println("小红成为了小明的女朋友");
        }
    }
}

练习--自动驾驶

需求：红灯停，绿灯行，黄灯请你等一等

public class Test2 {
    public static void main(String[] args) {
        //需求：红灯停，绿灯行，黄灯请你等一等

        //1.定义三个变量表示灯的状态
        //true 亮  false 灭
        boolean isLightGreen = false;
        boolean isLightYellow = false;
        boolean isLightRed = true;

        //2.判断
        //红灯亮，就停止
        //黄灯亮，就减速
        //绿灯亮，就行驶
        if(isLightGreen){
            System.out.println("Go!");
        }

        if(isLightYellow){
            System.out.println("slow!");
        }

        if(isLightRed){
            System.out.println("stop!");
        }
    }
}

第二种格式（双条件判断）

格式：

if (关系表达式) {
    语句体1；
} else {
    语句体2；
}

执行流程：

  1. 首先计算关系表达式的值
  2. 如果关系表达式的值为true就执行语句体1
  3. 如果关系表达式的值为false就执行语句体2
  4. 继续执行后面的其他语句

练习--吃饭

需求：

键盘录入一个整数，表示身上的钱。

如果大于等于100块，就吃网红餐厅。

否则，就吃经济实惠的沙县小吃。

import java.util.Scanner;

public class Test3 {
    public static void main(String[] args) {
        /*需求：键盘录入一个整数，表示身上的钱。
        如果大于等于100块，就吃网红餐厅。
        否则，就吃经济实惠的沙县小吃。*/

        //分析：
        //1.键盘录入一个整数，表示身上的钱。
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入身上的钱");
        int money = sc.nextInt();

        //2.对钱进行判断（二选一）
        if(money >= 100){
            System.out.println("吃网红餐厅");
        }else{
            System.out.println("吃经济实惠的沙县小吃");
        }
    }
}

练习--商品付款

需求：

假设，用户在超市实际购买，商品总价为：600元。

键盘录入一个整数表示用户实际支付的钱。

如果付款大于等于600，表示付款成功。否则付款失败。

import java.util.Scanner;

public class Test4 {
    public static void main(String[] args) {
        /*需求：
        假设，用户在超市实际购买，商品总价为：600元。
        键盘录入一个整数表示用户实际支付的钱。
        如果付款大于等于600，表示付款成功。否则付款失败。
         */

        //分析：
        //1.键盘录入一个整数表示用户实际支付的钱。
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个整数表示实际支付的钱");
        int money = sc.nextInt();

        //2.判断
        if(money >= 600){
            System.out.println("支付成功");
        }else{
            System.out.println("支付失败");
        }
    }
}

练习--影院选座

需求：

假设某影院收买了100张票，跑的序号为1~100。

其中奇数票号坐左侧，偶数票号坐右侧。

键盘录入一个整数表示电影票的票号。

根据不同情况，给出不同的提示：

如果票号为奇数，那么打印坐左边

如果票号为偶数，那么打印坐右边。

import java.util.Scanner;

public class Test5 {
    public static void main(String[] args) {
        /*假设某影院收买了100张票，跑的序号为1~100。
        其中奇数票号坐左侧，偶数票号坐右侧。
        键盘录入一个整数表示电影票的票号。
        根据不同情况，给出不同的提示：
        如果票号为奇数，那么打印坐左边
        如果票号为偶数，那么打印坐右边。
         */

        //分析：
        //1.键盘录入一个整数表示电影票的票号。
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个票号");
        int ticket = sc.nextInt();
        //只有当ticket在0~100之间，才是真是有效的票
        //if的嵌套
        if(ticket >= 0 && ticket <= 100){
            //2.判断票号是奇数还是偶数
            if (ticket % 2 == 1) {
                System.out.println("坐左边");
            } else {
                System.out.println("坐右边");
            }
        }
    }
}

第三种格式（多条件判断）

格式：

if (关系表达式1) {
    语句体1;
} else if (关系表达式2) {
    语句体2;
}
 ...
  else {
      语句体 n + 1;
  }

执行流程：

  1. 首先计算关系表达式1的值
  2. 如果为true就执行语句体1；如果为false就计算关系表达式2的值
  3. 如果为true就执行语句体2；如果为false就计算关系表达式3的值
  4. ......
  5. 如果关系表达式结果都为false，就执行语句体n+1。

练习--小明的礼物

import java.util.Scanner;

public class Test6 {
    public static void main(String[] args) {
        /*
        根据不同的分数送不同的礼物。
        95~100分，送一辆自行车
        90~94分，游乐场玩一天
        80~89分，送一个变形金刚
        80分一下，揍一顿。
         */

        //分析：
        //1.键盘录入小明的成绩
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个整数表示小明的成绩");
        int score = sc.nextInt();
        //2.根据不同的成绩，给出不同的奖励
        if(score >= 0 && score <= 100) {
            if (score >= 95 && score <= 100) {
                System.out.println("送一辆自行车");
            } else if (score >= 90 && score <= 94) {
                System.out.println("游乐场玩一天");
            } else if (score >= 80 && score <= 89) {
                System.out.println("送一个变形金刚");
            } else {
                System.out.println("揍一顿");
            }
        }else {
            System.out.println("当前录入的成绩不合法");
        }
    }
}

练习--商品的价格

需求：

商场都会有VIP的会员制，根据不同的会员会有不同的折扣。

假设商品总价为1000。

键盘录入会员级别，并计算出实际支付的钱。

会员1级：打9折。

会员2级：打8折。

会员3级：打7折。

非会员：不打折。

import java.util.Scanner;

public class Test7 {
    public static void main(String[] args) {
        /*
        需求：
        商场都会有VIP的会员制，根据不同的会员会有不同的折扣。
        假设商品总价为1000。
        键盘录入会员级别，并计算出实际支付的钱。
        会员1级：打9折。
        会员2级：打8折。
        会员3级：打7折。
        非会员：不打折。
         */


        //分析：
        //1.定义变量记录总价
        int price = 1000;
        //2.键盘录入会员的级别
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入会员的级别");
        int vip = sc.nextInt();
        //3.根据级别来计算实际要支付的钱
        if(vip == 1){
            System.out.println("实际支付的钱为" + (price * 0.9));
        }else if(vip == 2){
            System.out.println("实际支付的钱为" + (price * 0.8));
        }else if(vip == 3){
            System.out.println("实际支付的钱为" + (price * 0.7));
        }else{
            System.out.println("实际支付的钱为" + price);
        }
    }
}

switch语句

switch

格式：

switch(表达式) {
    case 值1:
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
    ...
    default:
        语句体n+1;
        break;
}

执行流程：

  1. 首先计算表达式的值。
  2. 依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
  3. 如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后结束整个switch语句。

格式说明：

  1. 表达式: (将要匹配的值)取值为byte、short. int、 char。JDK5以后可以是枚举，JDK7以后可以是String。
  2. case: 后面跟的是要和表达式进行比较的值(被匹配的值)。
  3. break: 表示中断，结束的意思，用来结束switch语句。
  4. default: 表示所有情况都不匹配的时候，就执行该处的内容,和if语句的else相似。
  5. case后面的值只能是字面量，不能是变量
  6. case给出的值不允许重复
//范例：
public class SwitchDemo1 {
    public static void main(String[] args) {
        //兰州拉面、武汉热干面、北京炸酱面、陕西油泼面

        //1.定义变量记录我心里想吃的面
        String noodles = "兰州拉面";

        //2.拿着这个面利用switch跟四种面条匹配
        switch (noodles){
            case "兰州拉面":
                System.out.println("吃兰州拉面");
                break;
            case "武汉热干面":
                System.out.println("吃武汉热干面");
                break;
            case "北京炸酱面":
                System.out.println("吃北京炸酱面");
                break;
            case "陕西油泼面":
                System.out.println("吃陕西油泼面");
                break;
        }
    }
}

练习--运动计划

需求：键盘录入星期数，显示今天的减肥活动。

周一：跑步

周二：游泳

周三：慢走

周四：动感单车

周五：拳击

周六：爬山

周日：好好吃一顿

import java.util.Scanner;

public class Test8 {
    public static void main(String[] args) {
        /*需求：键盘录入星期数，显示今天的减肥活动。
        周一：跑步
        周二：游泳
        周三：慢走
        周四：动感单车
        周五：拳击
        周六：爬山
        周日：好好吃一顿
         */

        //分析：
        //1.键盘录入星期数
        Scanner sc = new Scanner(System.in);
        System.out.println("情录入星期");
        int week = sc.nextInt();
        //2.利用switch语句对星期进行匹配
        switch (week){
            case 1:
                System.out.println("跑步");
                break;
            case 2:
                System.out.println("游泳");
                break;
            case 3:
                System.out.println("慢走");
                break;
            case 4:
                System.out.println("动感单车");
                break;
            case 5:
                System.out.println("拳击");
                break;
            case 6:
                System.out.println("爬山");
                break;
            case 7:
                System.out.println("好好吃一顿");
                break;
            default:
                System.out.println("没有这个星期");
                break;
        }
    }
}

switch其他知识点

  • default的位置和省略

    • 位置：default不一定是写在最下面的，可以写在任意位置。
    • 省略：default可以省略，语法不会有问题，但是不建议省略。

  • case穿透

    • 就是语句体中没有写break导致的。

    • 执行流程:

      首先还是会拿着小括号中表达式的值跟下面每一个case进行匹配。

      如果匹配上了，就会执行对应的语句体，如果此时发现了break，那么结束整个switch语句。

      如果没有发现break，那么程序会继续执行下一个case的语句体，一直遇到break或者右大括号为止。

    • 使用场景：

      如果多个case的语句体重复了，那么我们考虑利用case穿透去简化代码。

  • switch新特性

    • switch(表达式) {
    case 值1 -> {
        语句体1;
    }
    case 值2 -> {
        语句体2;
    }
    ...
    default -> {
        语句体n+1;
    }
}

      （大括号内如果只有一行代码，可以去掉大括号。）

  • switch和if第三种格式各自的使用场景

    • if的第三种格式:一般用于对范围的判断
    • switch:把有限个数据一列举出来，让我们任选其一

练习--休息日和工作日

需求：键盘录入星期数，输出工作日、休息日。

（1-5）工作日，（6-7）休息日。

import java.util.Scanner;

public class Test9 {
    public static void main(String[] args) {
        /*需求：键盘录入星期数，输出工作日、休息日。
        （1-5）工作日，（6-7）休息日。
         */
        //分析：
        //1.键盘录入星期数
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个整数表示星期");
        int week = sc.nextInt();
        //2.利用switch语句来进行选择
        switch (week){
            case 1,2,3,4,5 -> System.out.println("工作日");
            case 6,7 -> System.out.println("休息日");
            default -> System.out.println("没有这个星期");
        }
    }
}

练习--用户选择

在实际开发中，如果我们需要在多种情况下选择其中一个，就可以使用switch语句。

当我们拨打了某些服务电话时，一般都会有按键选择。

假设现在我们拨打了一一个机票预定电话。

电话中语音提示:

1机票查询

2机票预订

3机票改签

4退出服务

其他按键也是退出服务。请使用switch模拟该业务逻辑。

import java.util.Scanner;

public class Test10 {
    public static void main(String[] args) {
        /*在实际开发中，如果我们需要在多种情况下选择其中一个，就可以使用switch语句。
        当我们拨打了某些服务电话时，一般都会有按键选择。
        假设现在我们拨打了一一个机票预定电话。
        电话中语音提示:
        1机票查询
        2机票预订
        3机票改签
        4退出服务
        其他按键也是退出服务。请使用switch模拟该业务逻辑。
         */


        //分析：
        //1.键盘录入一个整数表示我们的选择
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的选择");
        int choose = sc.nextInt();
        //2.根据选择执行不同的代码
        switch (choose){
            case 1 -> System.out.println("机票查询");
            case 2 -> System.out.println("机票预订");
            case 3 -> System.out.println("机票改签");
            default -> System.out.println("退出服务");
        }
    }
}

循环结构

循环的分类

  • for
  • while
  • do...while

for循环

格式：
for (初始化语句；条件判断语句；条件控制语句){
    循环体语句;
}
范例：
for (int i == 1;i <= 10;i++){
    System.out.println("HelloWorld")
}
执行流程：

① 执行初始化语句

② 执行条件判断语句，看其结果是true还是false

  • 如果是false，循环结束
  • 如果是true，执行循环体语句

③ 执行条件控制语句

④ 回到②继续执行条件判断语句

练习

基础案例1：输出HelloWorld

需求：打印5次HelloWorld

public class ForDemo1 {
    public static void main(String[] args) {
        //1.需求：打印5次HelloWorld

        //分析：
        //i 1 ~ 5
        for( int i = 1;i <= 5;i++){
            System.out.println("HelloWoeld");
        }
    }
}

基础练习2：输出数字/基础练习3：倒着输出数字

需求：打印15/打印51

public class Test11 {
    public static void main(String[] args) {
        //需求1：打印1~5
        //分析：
        //开始条件：1
        //结束条件：5
        for(int i = 1;i <= 5;i++){
            System.out.println(i);
        }

        //需求2：打印5~1
        //分析：
        //开始条件：5
        //结束条件：1
        for (int i = 5; i >= 1; i--) {
            System.out.println(i);
        }
    }
}

案例4：断线重连

在实际开发中，需要重复执行的代码，会选择循环实现。

比如:玩游戏的时候，如果网不好那么会经常断线重连。那么断线重连这个业务逻辑就需要重复执行。

假设现在公司要求,断线重连的业务逻辑最多只写5次。

请用代码实现。

备注:断线重连的业务逻辑可以用输出语句替代。

public class Test12 {
    public static void main(String[] args) {
        /*在实际开发中，需要重复执行的代码，会选择循环实现。
        比如:玩游戏的时候，如果网不好那么会经常断线重连。那么断线重连这个业务逻辑就需要重复执行。
        假设现在公司要求,断线重连的业务逻辑最多只写5次。
        请用代码实现。
        备注:断线重连的业务逻辑可以用输出语句替代。
         */

        //分析：
        //循环的次数5次
        //开始条件：1
        //结束条件：5

        for(int i = 1;i <= 5;i++){
            System.out.println("第" + i + "次执行断线重连的业务逻辑");
        }
    }
}

案例5：求和

需求：在实际开发中，如果要获取一个范围中的每一个数据时，也会用到循环。

比如：求1-5之间的和

public class Test13 {
    public static void main(String[] args) {
        /*需求：在实际开发中，如果要获取一个范围中的每一个数据时，也会用到循环。
        比如：求1-5之间的和
         */

        //分析：
        //1.循环1~5得到里面的每一个数字
        //开始条件：1
        //结束条件：5
        //用来进行累加
        int sum = 0;
        for(int i = 1;i <= 5;i++){
            sum = sum + i;//或sum +=i;
        }
        System.out.println(sum);//当循环结束之后，表示已经把1~5累加到变量sum当中
        //扩展小点：
        //1.求和的变量不能定义在循环的里面，因为变量只在所属的大括号里有效
        //2.如果我们把变量定义在循环的里面，那么当前变量只能在本次循环中有效。
        //当本次循环结束之后，变量就会在内存中消失。
        //第二次循环开始的时候，又会重新定义一个新的变量。
        //结论：如果以后我们要写累加求和的变量。可以吧变量定义在循环的外面。
    }
}

案例6：求和

需求：在实际开发中，如果要获取一个范围中的每-个数据时，会用到循环。

但是此时，大多情况下，不会获取所有的数据，而是获取其中符合要求的数据。

此时就需要循环和其他语句结合使用了。

比如：求1-100之间的偶数和

public class Test14 {
    public static void main(String[] args) {
        /*需求：在实际开发中，如果要获取一个范围中的每-个数据时，会用到循环。
        但是此时，大多情况下，不会获取所有的数据，而是获取其中符合要求的数据。
        此时就需要循环和其他语句结合使用了。
        比如：求1-100之间的偶数和
         */

        //分析：
        //1.获取1~100之间的每个数
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            //2.累加求和（先判断，再求和）
            if(i % 2 == 0){
                sum += i;
            }
        }
        //打印sum
        System.out.println(sum);
    }
}

案例7：统计满足条件的数字

需求：键盘录入两个数字，表示一个范围。

统计这个范围中。

既能被3整除,又能被5整除数字有多少个?

import java.util.Scanner;

public class Test15 {
    public static void main(String[] args) {
        /*需求：键盘录入两个数字，表示一个范围。
        统计这个范围中。
        既能被3整除,又能被5整除数字有多少个?
         */

        //分析：
        //1.键盘录入两个数字
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个数字表示范围的开始");
        int statr = sc.nextInt();
        System.out.println("请录入一个数字表示范围的结束");
        int end = sc.nextInt();

        //统计变量
        //简单理解：统计符合要求的数字的个数
        int count = 0;

        //2.利用循环获取这个范围中的每一个数字
        //开始条件：start
        //结束条件：end
        for (int i = statr; i <= end; i++) {
            //3.对每一个数字进行判断，统计有多少歌满足要求的数字
            if (i % 3 == 0 && i % 5 == 0){
                count++;
            }
        }
        System.out.println(count);
    }
}

while循环

格式：
初始化语句;
while(条件判断语句){
    循环体语句;
    条件控制语句;
}
  • 初始化语句只执行依次
  • 判断语句为true，循环继续
  • 判断语句为false，循环结束
练习

需求：利用while循环打印1~100

public class WhileDemo1 {
    public static void main(String[] args) {
        //需求：利用while循环打印1~100
        //分析：
        //开始条件：1
        //结束条件：100

        int i = 1;
        while(i <= 100){
            System.out.println(i);
            i++;
        }
    }
}

for和while的对比

➢相同点：运行规则都是一样的

for和while的区别：

➢for循环中， 控制循环的变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了

➢while循环中，控制循环的变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用

for:

for(int i = 0;i < 4;i++){
    System.out.println(i);
}

while:

int i = 0;
while(i < 4){
    i++;
}
System.out.println(i);

for和while的区别：

➢for循环中：知道循环次数或者循环的范围

➢while循环：不知道循环的次数和范围，只知道循环的结束条件。

练习

案例1：打印折纸的次数

需求：世界最高山峰是珠穆朗玛峰（8844.43米=8844430毫米），假如我有一张足够大的纸，它的厚度是0.1毫米。

请问，我折叠多少次，可以折成珠穆朗玛峰的高度？

public class Test16 {
    public static void main(String[] args) {
        /*需求：世界最高山峰是珠穆朗玛峰（8844.43米=8844430毫米），假如我有一张足够大的纸，它的厚度是0.1毫米。
        请问，我折叠多少次，可以折成珠穆朗玛峰的高度？
         */

        //分析：每一次折叠纸张的厚度都是原先的两倍
        //1.定义一个变量用来记录山峰的高度
        double height = 8844430;
        //2.定义一个变量用来记录纸张的初始厚度
        double paper = 0.1;
        //3.定义一个变量用来统计次数
        int count = 0;
        //4.循环折叠纸张，只要纸张的厚度小于等于山峰的高度，那么循环就继续
        //每折叠一次，统计次数就要++
        while(paper <= height){
            paper *= 2;
            count++;
        }
        System.out.println(count);
    }
}

案例2：回文数

需求：给你一个整数X。如果x是一个回文整数，打印true，否则，返回false。

解释：回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

（例如，121是回文，而123不是。）

import java.util.Scanner;

public class Test17 {
    public static void main(String[] args) {
        /*需求：给你一个整数X。如果x是一个回文整数，打印true，否则，返回false。
         解释：回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
         （例如，121是回文，而123不是。）
         */
        
        //键盘录入
        System.out.println("请输入一个整数");
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        int temp = x;
        int num = 0;
        while(x != 0){//当x不为0时，结束循环
            int ge = x % 10;//取个位数
            x = x / 10;//x由n位数变为n-1位数，用于进入下一个循环
            num = num * 10 + ge;//求倒序后的数
        }
        System.out.println(temp == num);//X==0,temp==num
    }
}

案例3：求商和余数

需求：给定两个整数，被除数和除数（都是正数，且不超过int的范围 ）。

将两数相除，要求不使用乘法、除法和%运算符。

得到商和余数。

import java.util.Scanner;

public class Test18 {
    public static void main(String[] args) {
        /*需求：给定两个整数，被除数和除数（都是正数，且不超过int的范围 ）。
        将两数相除，要求不使用乘法、除法和%运算符。
        得到商和余数。
         */
        //分析：
        //被除数 / 除数 = 商 ... 余数
        //1.键盘录入
        System.out.println("请输入被除数");
        Scanner sc = new Scanner(System.in);
        int dividend = sc.nextInt();
        System.out.println("请输入除数");
        int divisor = sc.nextInt();
        //2.定义一个变量用来统计相减了多杀次
        int count = 0;
        //3.循环 while
        //在循环中，不断的用被除数 - 除数
        //只要被除数是大于等于除数的，那么就一直循环
        while(dividend >= divisor){
            dividend -= divisor;
            count++;//减一次，统计变量自增一次
        }
        //当循环结束之后count变量记录的就是商
        System.out.println("商为：" + count);
        //当循环结束之后dividend变量记录的就是余数
        System.out.println("余数为：" + dividend);
    }
}

do...while循环

格式：
初始化语句;
do{
    循环体语句;
    条件控制语句;
}while(条件判断语句);
特点：

先执行后判断

相關文章