【JAVA BASICS】Day04 Scanner接收用户输入的数据、分支结构：switch…case、循环、循环三要素、循环结构：while、do…while、for、break、continue

最新推荐文章于 2024-08-12 15:45:48 发布

张禹垚

最新推荐文章于 2024-08-12 15:45:48 发布

阅读量703

点赞数 26

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

本文链接：https://blog.csdn.net/HLJ_Student/article/details/140894174

版权

Java Basics 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

Day04目标：

掌握使用Scanner接受用户输入的数据；
掌握分支结构switch...case的使用；
了解什么是循环、掌握循环的三个要素；
掌握break和continue关键字；
预计代码量：课上110行、作业220行

Scanner接受用户输入数据

Scanner简介

Scanner是Java提供的小零件，拿来使用即可；
接受用户输入的数据只是它众多功能的一个小功能

Scanner使用步骤

一共三步：（先记住，到面向对象第四天才能理解）
第一步：在package下面

import java.util.Scanner; // 导入扫描仪组件

第二步：在main中

Scanner scan = new Scanner(System.in); // 创建一个扫描仪，命名为scan

第三步：在第二步下面

int age = scan.nextInt(); // 扫描一个整数，并赋值给age

举个实例：

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // 第二步：新建一个扫描仪，叫scanner
        System.out.println("请输入您的年龄（输入纯整数）");
        int age = scanner.nextInt(); // 第三步：扫描一个整数并赋值给age
        // 等价于：int age = 18; // 但是如这样写代码被写死，如上用户可控制age的值
        System.out.println("您输入的年龄为：" + age);

        System.out.println("请输入商品价格：");
        double price = scanner.nextDouble();
        System.out.println("您输入的商品价格为：" + price);

        // 练习：在Day04包里创建类CommandBySwitch，接受用户的命令command(int类型)，并输出
        /*
        package day04;

        import java.util.Scanner;

        public class CommandBySwitch {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in); // 创建扫描仪scanner
            System.out.print("请输入command(int类型)：");
            int command = scanner.nextInt();
            System.out.print("您输入的command为：" + command);
            }
        }
         */
    }

分支结构switch…case

switch…case应用场景

switch...case结构：常常用于实现多条路
- 优点：效率高、结构清晰
- 缺点：目前只能对整数、String和枚举，只能判断相等
- 应用场景：若业务时，是对整数判断相等，则为首选

switch…case结构

switch...case是一种特殊的分支结构，可以根据一个整数表达式的不同取值，从不同的入口开始执行

        int num = 2;
        switch (num) {
            case 1: // 相当于if(num == 1)
                System.out.println(111);
            case 2: // 以此为入口
                System.out.println(222);
            case 3: 
                System.out.println(333);
            default: // 所有case都未匹配时执行
                System.out.println(666);

        // 等价于if语句如下：
        if (num == 1) {
            System.out.println(111);
        } else if (num == 2) {
            System.out.println(222);
        } else if (num == 3) {
            System.out.println(333);
        } else {
            System.out.println(666);
        }

注意：上述switch...case语句示例代码有一些小问题，就是冗余过大，应优化如果成功进入某一个case，break跳出分支语句，避免内存占用过大

        int num = 2;
        switch (num) {
            case 1: // 相当于if(num == 1)
                System.out.println(111);
                break;
            case 2: // 以此为入口
                System.out.println(222);
                break;
            case 3:
                System.out.println(333);
                break;
            default: // 所有case都未匹配时执行
                System.out.println(666);

注意：无论default块在什么位置，switch...case语句都会优先检测case块，不建议讲default块移动位置，建议作为最后一个块
所以我们引入标准的switch...case语句的一般语法：

  switch (byte/short/int/char/String/枚举 变量名 = 初始化值) {
    case 1:
      // 语句块1
      break;
    case 2:
      // 语句块2
      break;
    case n:
      // 语句块n
      break;
    default:
  }

案例：银行ATM命令解析程序

package day04;

import java.util.Scanner;
// 命令解析程序
public class CommandBySwitch {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // 创建扫描仪scanner
        System.out.print("请选择功能：1.存款 2.取款 3.查询余额 4.退卡");
        int command = scanner.nextInt();

        switch (command) {
            case 1:
                System.out.println("存款业务......");
                break;
            case 2:
                System.out.println("取款业务......");
                break;
            case 3:
                System.out.println("查询余额业务......");
                break;
            case 4:
                System.out.println("退卡成功");
                break;
            default:
                System.out.println("输入错误");
        }


    }
}

循环

循环的定义及应用（初学者第一个重难点）

任何复杂的程序逻辑，我们都可以通过三种结构来实现：
- 顺序结构：从上往下逐行执行，每句必须走；
- 分支结构：有条件的执行某语句，并非每句都必须执行；（一次）
- 循环结构：有条件的执行某语句，并非每句都必须执行；（多次）
分支结构：

  if (boolean) { // 只判断一次
    // 语句块  // 语句块最多执行一次
  }

循环结构：

whlie (boolean) { // 判断多次
  // 语句块  //语句块可以执行多次
}

循环：有规律的反复多次执行一段相同或相似的代码，例如生活中的：“跑3圈”、“写5遍‘行动是成功的阶梯’”、“‘背九九的乘法表’”等。

循环三要素（新手必须记）

循环三要素：
- 循环变量的初始化；
- 循环的条件（以循环变量为基础）；
- 循环变量的改变
循环变量：在整个循环过程中反复改变的那个数
举个例子：跑3圈 —— 不考虑程序化的情况下：

第0圈 → 够三圈吗？ → 不够 → 跑1圈（+1）

第1圈 → 够三圈吗？ → 不够 → 跑1圈（+1）

第2圈 → 够三圈吗？ → 不够 → 跑1圈（+1）

第3圈 → 够三圈吗？ → 够了

  int count = 0
    count < 3;
    count++;
    // count = 0/1/2/3 时结束

再举一个例子：—— 输出5次“行动是成功的阶梯”

public class WhileDemo {
    public static void main(String[] args) {
        // 循环变量 ———— times
        int times = 0; // 要素1：循环变量的初始化
        while (times < 5) { // 要素2：循环的条件
            System.out.println("行动是成功的阶梯");
            times++; // 要素3：循环变量的改变
        }
    }
}

最后一个例子： —— 输出九的乘法表

public class WhileDemo {
    public static void main(String[] args) {
        // 循环变量 ———— 因数：num
        int num = 0;
        while (num <= 9) {
            num++;
            System.out.println(num + "x9=" + (num * 9));
        }
    }

循环结构的分类

while结构
do...while结构
for结构

while结构

语法规则：

  while (boolean) {
    // 语句块 ——————> 反复执行的代码
  }

例子回看上面的“行动是成功的阶梯”
特殊的循环 —— 死循环（有时候需要用到，一般情况下避免出现）

  // 示例1
  int i = 0;
  while (i < 5) { // 0注定小于5
    System.out.println("死循环......");
  }
  
  // 示例2
  while (true) {
    System.out.println("死循环......");
  }

练习：

package day04;

import java.util.Scanner;

// 猜数字小游戏
/*
1. 程序随机生成并存储一个整数
2. 用户输入后提示“猜大了”或“猜小了”，若没猜对则一直猜，直到用户猜对了结束，输入“恭喜你猜对了”。
 */
public class Guessing {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num = (int)(Math.random() * 1000 + 1);

        /*
            Math.random() —————— 默认创造一个 0.0到0.999999999...之内的随机数
            num = (int)(Math.random() * 1000) ——————— 创造一个0到999之内的随机数
            num = (int)(Math.random() * 1000 + 1) ———————— 创造一个1到1000之内的随机数
            num = Math.random() * 1000 + 1 ———————— 创造一个1.0到1000.0之内的随机数
         */

        System.out.println("猜！(1-1000以内)");
        int guessNum = scanner.nextInt();

        while (guessNum != num) {

            if (guessNum > num) {
                System.out.println("猜大了！继续猜！");
            } else {
                System.out.println("猜小了！继续猜！");
            }
            guessNum = scanner.nextInt();
        }

        System.out.println("猜对啦！");

    }
}

do…while结构

语法规则：

do {
  // 语句块 -> 反复执行的代码
} while (boolean);

先执行do{语句块}里的代码，再进行while里面boolean的真假值，如果真，则回到do{语句块}重新执行，之后再验证真假值，直到为假，结束循环
do{语句块}中的语句至少被执行一次，当三要素中第一要素和第三要素的代码相同时，首选使用do...while循环
练习：

// 猜数字小游戏
/*
1. 程序随机生成并存储一个整数
2. 用户输入后提示“猜大了”或“猜小了”，若没猜对则一直猜，直到用户猜对了结束，输入“恭喜你猜对了”。
3.使用do...while结构实现
 */

package day04;

import java.util.Scanner;

public class DoWhileGuessing {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num = (int) (Math.random() * 1000 + 1); // 1到1000之内
        System.out.println(num); // 作弊

        int guessNum;
        do {
            System.out.println("猜吧！");
            guessNum = scanner.nextInt(); // 1+3
            if (guessNum > num) {
                System.out.println("猜大了！");
            } else if (guessNum < num) {
                System.out.println("猜小了！");
            } else {
                System.out.println("猜对啦！");
            }
        } while (guessNum != num); // 2
    }
}

for结构

for结构的语法及执行过程

int times = 0; // 1
while (times < 5) { // 2
  System.out.println("行动是成功的阶梯"); // 4
  times++; // 3
}
// while 的执行过程：1 -> 2 -> 4 -> 3 -> 2 -> 4 -> 3 -> 2 ......
        
           // 1       //2        //3    
for (int times = 0; times < 5; times++) {
  System.out.println("行动是成功的阶梯"); // 4
}
// for的执行过程：1 -> 2 -> 4 -> 3 -> 2 -> 4 -> 3 -> 2 ......

语法结构：

for(第一要素; 第二要素; 第三要素) {
  // 语句块/循环体 ——> 反复执行的代码
}

注意：第一要素如果定义变量，变量只在该循环体内可用，循环外将不可用，宏观来讲，就是指循环变量重名的情况只能出现在不同的作用域，若在同一个（重叠的）作用域中，不允许同名情况发生，反之允许同名情况发生。

for的基本案例

package day04;

public class ForDemo {
    public static void main(String[] args) {
        // for中的循环变量num的作用域，仅在当前for中 ———— 特别记忆

        // 1到9对9的乘法表
        for (int num = 1; num <= 9; num++) {
            System.out.println(num + "*9=" + num * 9);
        }

        // System.out.println(num); // 编译错误，超出了变量num的作用域

        // 1/3/5/7/9对9的乘法表
        for (int num = 1; num <= 9; num += 2) {
            System.out.println(num + "*9=" + num * 9);
        }

        // 9到1对9的乘法表
        for (int num = 9; num >= 1; num--) {
            System.out.println(num + "*9=" + num * 9);
        }
        /*
         执行过程:
           num=9  true  输出
           num=8  true  输出
           num=7  true  输出
           num=6  true  输出
           num=5  true  输出
           num=4  true  输出
           num=3  true  输出
           num=2  true  输出
           num=1  true  输出
           num=0  false for循环结束
           输出继续执行...
         */


        // 输出5遍“行动是成功的阶梯”
        for (int times = 0; times < 5; times++) {
            System.out.println("行动是成功的阶梯");
        }
        /*
         执行过程:
           times=0  true  输出
           times=1  true  输出
           times=2  true  输出
           times=3  true  输出
           times=4  true  输出
           times=5  false for循环结束
           输出继续执行...
         */

        System.out.println("继续执行......");
    }
}

练习：累加和

// 计算1到100的累加和：1+2+3+4+...+99+100=?
    int sum = 0; // 存和，不能放进for循环内，否则每次循环sum变量都将变回0
    for (int num = 1; num <= 100; num++) {
        sum += num;
    }
    System.out.println("和为：" + sum); // 5050，同样不能放进循环里，否则每次循环都会输出一个值
    /*
    执行过程：
                    sum = 0
    i = 1    true   sum = 1
    i = 2    true   sum = 1 + 2
    i = 3    true   sum = 1 + 2 + 3
            ......
    i = 99   true   sum = 1 + 2 + 3 + ... + 99
    i = 100  true   sum = 1 + 2 + 3 + ... + 99 + 100
    i = 101  false  for循环结束
     */

循环结构的选择

先看循环是否与次数有关
- 若有关 —— 直接选for
- 若无关 —— 再看第1要素与第3要素的代码是否相同？
  - 若相同 —— 直接选do...while
  - 若不同 —— 直接选while

for结构的特殊形式

第1要素的位置为空：

int num = 1;
for (; num <= 5; num++) {
  System.out.println("我爱Java！");
}

第3要素位置为空：

for (int num = 1; num <= 5; ) {
  System.out.println("我爱Java！");
  num++;
}

3个要素位置都为空（死循环）：

for ( ; ; ; ) {
  Sysout.out.println("我爱Java");
}

第1要素与第3要素位置的逗号表达式：

for (int i = 1, j = 6; i <= 6; i += 2, j -= 2) {
  System.out.println(i + "，" + j);
}

// 执行过程：
/*
  i = 1, j = 6    true
  i = 3, j = 4    true
  i = 5, j = 2    true
  i = 7, j = 0    false
*/

张禹垚

关注

26
点赞
踩
30

收藏

觉得还不错? 一键收藏
0
评论
【JAVA BASICS】Day04 Scanner接收用户输入的数据、分支结构：switch…case、循环、循环三要素、循环结构：while、do…while、for、break、continue

本日课程聚焦Scanner接收用户输入、switch...case分支结构、循环（while、do...while、for）及循环控制（break、continue）。Scanner简化用户输入处理，switch...case实现多路选择逻辑，循环结构解决重复执行问题。循环三要素：初始化、条件判断、迭代更新。课程涵盖多个实战示例，如ATM功能模拟、循环计算加和等，强化实践技能。预计代码量提升，促进深入理解Java编程基础。
复制链接

扫一扫

专栏目录