• Java从入门到精通-流程控制（二）

    习题讲解：


    上次我们给大家留了一些流程控制的问题，这次给大家分析讲解一下：

    条件语句练习：

    1.编写Java程序，用于接受用户输入的数字，然后判断它是偶数还是奇数，并输出相应的消息。

    1. import java.util.Scanner;
    2.  
    3. public class OddEvenCheck {
    4.     public static void main(String[] args) {
    5.         // 创建一个Scanner对象来接受用户输入
    6.         Scanner scanner = new Scanner(System.in);
    7.         
    8.         // 提示用户输入一个整数
    9.         System.out.print("请输入一个整数: ");
    10.         
    11.         // 从用户输入中读取整数
    12.         int number = scanner.nextInt();
    13.         
    14.         // 使用条件语句判断数字是偶数还是奇数
    15.         if (number % 2 == 0) {
    16.             System.out.println(number + " 是偶数。");
    17.         } else {
    18.             System.out.println(number + " 是奇数。");
    19.         }
    20.         
    21.         // 关闭Scanner对象
    22.         scanner.close();
    23.     }
    24. }

    分析讲解：

    1. 我们首先导入java.util.Scanner类，以便能够从用户输入中读取数据。

    2. 创建一个Scanner对象，这将帮助我们接受用户的输入。

    3. 使用System.out.print语句提示用户输入一个整数。

    4. 使用scanner.nextInt()从用户的输入中读取整数并将其存储在number变量中。

    5. 使用条件语句if来检查number是否是偶数。如果number除以2的余数等于0，那么它是偶数，否则是奇数。

    6. 根据判断结果，程序将输出相应的消息，告诉用户输入的数字是偶数还是奇数。

    7. 最后，我们使用scanner.close()来关闭Scanner对象，以释放资源。

    例题总结：

    这个程序演示了如何使用条件语句来判断用户输入的数字是偶数还是奇数。它首先接受用户输入，然后使用条件表达式检查输入的数字是否可以被2整除。如果可以，它被认为是偶数，否则被认为是奇数，并输出相应的消息。这个示例强调了Java中的条件语句的使用，是编程中的基础之一。

    2.创建一个简单的登陆系统，要求用户输入用户名和密码。如果用户名是 “admin” 并且密码是 “password”，则显示欢迎消息，否则显示错误消息。

    1. import java.util.Scanner;
    2.  
    3. public class SimpleLoginSystem {
    4.     public static void main(String[] args) {
    5.         // 创建一个Scanner对象来接受用户输入
    6.         Scanner scanner = new Scanner(System.in);
    7.  
    8.         // 提示用户输入用户名
    9.         System.out.print("请输入用户名: ");
    10.         String username = scanner.nextLine();
    11.  
    12.         // 提示用户输入密码
    13.         System.out.print("请输入密码: ");
    14.         String password = scanner.nextLine();
    15.  
    16.         // 验证用户名和密码
    17.         if (username.equals("admin") && password.equals("password")) {
    18.             System.out.println("欢迎 " + username + " 进入系统！");
    19.         } else {
    20.             System.out.println("用户名或密码错误，请重试。");
    21.         }
    22.  
    23.         // 关闭Scanner对象
    24.         scanner.close();
    25.     }
    26. }

    分析讲解：

    1. 我们首先导入java.util.Scanner类，以便能够从用户输入中读取数据。

    2. 创建一个Scanner对象，这将帮助我们接受用户的输入。

    3. 使用System.out.print语句提示用户输入用户名。

    4. 使用scanner.nextLine()从用户的输入中读取用户名并将其存储在username变量中。

    5. 提示用户输入密码。

    6. 使用scanner.nextLine()从用户的输入中读取密码并将其存储在password变量中。

    7. 使用条件语句if来验证用户名和密码是否匹配。如果用户名是"admin"且密码是"password"，则显示欢迎消息；否则，显示错误消息。

    8. 最后，我们使用scanner.close()来关闭Scanner对象，以释放资源。

    例题总结：

    这个程序演示了如何创建一个简单的登录系统，要求用户输入用户名和密码，并验证这些信息。它使用条件语句来检查用户名和密码是否匹配，如果匹配则显示欢迎消息，否则显示错误消息。这个示例强调了Java中的条件语句和用户输入的处理。在实际应用中，安全性需要更复杂的处理，但这个示例提供了一个基本的框架。

    3.编写一个程序，接受用户输入的年份，然后判断该年份是否为闰年，并输出相应的消息。闰年条件：能被4整除但不能被100整除，或者能被400整除。

    1. import java.util.Scanner;
    2.  
    3. public class LeapYearCheck {
    4.     public static void main(String[] args) {
    5.         // 创建一个Scanner对象来接受用户输入
    6.         Scanner scanner = new Scanner(System.in);
    7.  
    8.         // 提示用户输入一个年份
    9.         System.out.print("请输入一个年份: ");
    10.         int year = scanner.nextInt();
    11.  
    12.         // 使用条件语句判断是否为闰年
    13.         if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
    14.             System.out.println(year + " 是闰年。");
    15.         } else {
    16.             System.out.println(year + " 不是闰年。");
    17.         }
    18.  
    19.         // 关闭Scanner对象
    20.         scanner.close();
    21.     }
    22. }

    分析讲解：

    1. 我们首先导入java.util.Scanner类，以便能够从用户输入中读取数据。

    2. 创建一个Scanner对象，这将帮助我们接受用户的输入。

    3. 使用System.out.print语句提示用户输入一个年份。

    4. 使用scanner.nextInt()从用户的输入中读取年份并将其存储在year变量中。

    5. 使用条件语句if来判断年份是否为闰年。根据闰年的条件，我们检查两个条件：年份能够被4整除但不能被100整除，或者能够被400整除。如果两个条件中的任何一个满足，就认为是闰年。

    6. 根据判断结果，程序将输出相应的消息，告诉用户输入的年份是闰年还是不是闰年。

    7. 最后，我们使用scanner.close()来关闭Scanner对象，以释放资源。

    例题总结：

    这个程序演示了如何接受用户输入的年份，并使用条件语句来判断是否为闰年。它根据闰年的定义，检查了两个条件，以确定年份的闰年状态，并输出相应的消息。这个示例强调了Java中的条件语句的使用，是编程中的基础之一。

    循环语句练习：

    4.使用 for 循环打印出1到100的所有奇数。

    1. public class PrintOddNumbers {
    2.     public static void main(String[] args) {
    3.         // 使用for循环遍历1到100的所有数字
    4.         for (int i = 1; i <= 100; i++) {
    5.             // 检查是否是奇数
    6.             if (i % 2 != 0) {
    7.                 // 如果是奇数，就打印出来
    8.                 System.out.println(i);
    9.             }
    10.         }
    11.     }
    12. }

    分析讲解：

    1. 我们使用 for 循环来遍历从1到100的所有数字，将 i 初始化为1，然后在每次迭代后增加1。

    2. 在循环的每一次迭代中，我们使用条件语句 if 来检查当前的数字 i 是否是奇数。

    3. 如果 i 不能被2整除（即 i % 2 != 0 为真），则它是奇数。

    4. 如果 i 是奇数，我们就使用 System.out.println(i); 打印出它。

    例题总结：

    这个程序将循环遍历1到100的数字，并只打印出奇数，即不被2整除的数字。这是一种常见的用法，用于筛选和处理特定类型的数字。

    5.使用 while 循环找出一个正整数的所有因子

    1. import java.util.Scanner;
    2.  
    3. public class FactorsOfNumber {
    4.     public static void main(String[] args) {
    5.         // 创建一个Scanner对象来接受用户输入
    6.         Scanner scanner = new Scanner(System.in);
    7.         
    8.         // 提示用户输入一个正整数
    9.         System.out.print("请输入一个正整数: ");
    10.         int number = scanner.nextInt();
    11.         
    12.         // 初始化一个除数
    13.         int divisor = 1;
    14.         
    15.         // 使用while循环找出所有因子
    16.         System.out.print(number + " 的因子包括: ");
    17.         while (divisor <= number) {
    18.             if (number % divisor == 0) {
    19.                 System.out.print(divisor + " ");
    20.             }
    21.             divisor++;
    22.         }
    23.         
    24.         // 关闭Scanner对象
    25.         scanner.close();
    26.     }
    27. }

    分析讲解：

    1. 我们首先导入java.util.Scanner类，以便能够从用户输入中读取数据。

    2. 创建一个Scanner对象，这将帮助我们接受用户的输入。

    3. 使用System.out.print语句提示用户输入一个正整数。

    4. 使用scanner.nextInt()从用户的输入中读取正整数并将其存储在number变量中。

    5. 初始化一个除数 divisor，开始为1。

    6. 使用 while 循环来查找 number 的因子。在每次迭代中，我们检查是否 number 能够被 divisor 整除。如果能够整除，就说明 divisor 是一个因子，并将其打印出来。

    7. 在每次迭代后，我们增加 divisor 的值，继续查找下一个因子。

    8. 最后，我们使用scanner.close()来关闭Scanner对象，以释放资源。

    例题总结：

    这个程序将找出用户输入的正整数的所有因子，并将它们打印出来。这是一种查找因子的常见方法，可以用于数学和算法问题中。

    6.使用 do...while 循环实现一个猜数字游戏，程序随机生成一个数字，然后提示用户猜数字，直到用户猜中为止

    1. import java.util.Scanner;
    2. import java.util.Random;
    3.  
    4. public class GuessNumberGame {
    5.     public static void main(String[] args) {
    6.         // 创建一个Scanner对象来接受用户输入
    7.         Scanner scanner = new Scanner(System.in);
    8.         // 创建一个Random对象来生成随机数字
    9.         Random random = new Random();
    10.         
    11.         // 生成随机数字（1到100之间）
    12.         int target = random.nextInt(100) + 1;
    13.         int attempts = 0; // 记录尝试次数
    14.         int guess; // 用户猜的数字
    15.  
    16.         do {
    17.             System.out.print("猜一个1到100之间的数字: ");
    18.             guess = scanner.nextInt();
    19.             attempts++;
    20.  
    21.             if (guess < target) {
    22.                 System.out.println("太小了，请再试一次。");
    23.             } else if (guess > target) {
    24.                 System.out.println("太大了，请再试一次。");
    25.             }
    26.         } while (guess != target);
    27.  
    28.         System.out.println("恭喜，你猜对了！总共尝试了 " + attempts + " 次。");
    29.  
    30.         // 关闭Scanner对象
    31.         scanner.close();
    32.     }
    33. }

    分析讲解：

    1. 我们首先导入java.util.Scanner类和java.util.Random类，以便能够从用户输入中读取数据和生成随机数字。

    2. 创建一个Scanner对象，这将帮助我们接受用户的输入。

    3. 创建一个Random对象，用于生成随机的目标数字（在1到100之间）。

    4. 使用 do...while 循环来实现猜数字游戏，游戏会一直进行，直到用户猜中为止。

    5. 在每轮循环中，程序会提示用户输入猜测的数字，并将其存储在guess变量中。同时，attempts变量记录了用户的尝试次数。

    6. 程序会检查用户的猜测是否正确。如果猜测小于目标数字，就显示"太小了，请再试一次。“；如果猜测大于目标数字，就显示"太大了，请再试一次。”。

    7. 当用户猜中数字（guess == target）时，循环结束，并输出恭喜消息，显示用户猜中了，并告诉他们尝试的次数。

    8. 最后，我们使用scanner.close()来关闭Scanner对象，以释放资源。

    例题总结：

    这个程序实现了一个简单的猜数字游戏，用户可以尝试多次猜测，直到猜中目标数字为止。这种游戏可以用来练习do...while循环和条件语句的使用。

    循环控制语句练习：

    7.使用 break 语句改进上面的猜数字游戏，如果用户连续猜错5次，就自动结束游戏。

    1. import java.util.Scanner;
    2. import java.util.Random;
    3.  
    4. public class ImprovedGuessNumberGame {
    5.     public static void main(String[] args) {
    6.         // 创建一个Scanner对象来接受用户输入
    7.         Scanner scanner = new Scanner(System.in);
    8.         // 创建一个Random对象来生成随机数字
    9.         Random random = new Random();
    10.  
    11.         // 生成随机数字（1到100之间）
    12.         int target = random.nextInt(100) + 1;
    13.         int attempts = 0; // 记录尝试次数
    14.         int guess; // 用户猜的数字
    15.  
    16.         while (true) {
    17.             System.out.print("猜一个1到100之间的数字: ");
    18.             guess = scanner.nextInt();
    19.             attempts++;
    20.  
    21.             if (guess < target) {
    22.                 System.out.println("太小了，请再试一次。");
    23.             } else if (guess > target) {
    24.                 System.out.println("太大了，请再试一次。");
    25.             } else {
    26.                 System.out.println("恭喜，你猜对了！总共尝试了 " + attempts + " 次。");
    27.                 break; // 用户猜对，结束游戏
    28.             }
    29.  
    30.             if (attempts >= 5) {
    31.                 System.out.println("你已经尝试了5次，游戏结束。");
    32.                 break; // 用户连续猜错5次，结束游戏
    33.             }
    34.         }
    35.  
    36.         // 关闭Scanner对象
    37.         scanner.close();
    38.     }
    39. }

    分析讲解：

    1. 这个程序与前一个猜数字游戏程序类似，但是使用了一个 while (true) 循环，以便在用户连续猜错5次后自动结束游戏。

    2. 在每轮循环中，程序会检查用户的猜测是否正确。如果猜测小于目标数字，就显示"太小了，请再试一次。“；如果猜测大于目标数字，就显示"太大了，请再试一次。”。

    3. 如果用户猜中数字（guess == target），程序会输出恭喜消息，并显示用户尝试的次数，然后使用 break 语句结束游戏循环。

    4. 如果用户连续猜错5次（attempts >= 5），程序会输出消息并使用 break 语句结束游戏循环，结束游戏。

    例题总结：

    这个程序允许用户猜数字，并在用户连续猜错5次后自动结束游戏。这种改进可以增加游戏的交互性和挑战性。

    8.使用 continue 语句编写一个程序，打印出1到100的所有数字，但跳过所有包含数字 7 的数字，例如，跳过 7, 17, 27…

    1. public class PrintNumbersSkipSeven {
    2.     public static void main(String[] args) {
    3.         // 使用for循环遍历1到100的所有数字
    4.         for (int i = 1; i <= 100; i++) {
    5.             // 检查是否包含数字7
    6.             if (containsSeven(i)) {
    7.                 continue; // 跳过包含数字7的数字
    8.             }
    9.             // 打印当前数字
    10.             System.out.println(i);
    11.         }
    12.     }
    13.  
    14.     // 辅助函数：检查一个数字是否包含数字7
    15.     private static boolean containsSeven(int number) {
    16.         while (number > 0) {
    17.             int digit = number % 10;
    18.             if (digit == 7) {
    19.                 return true; // 包含数字7
    20.             }
    21.             number /= 10;
    22.         }
    23.         return false; // 不包含数字7
    24.     }
    25. }

    分析讲解：

    1. 这个程序使用 for 循环来遍历1到100的所有数字，将 i 初始化为1，然后在每次迭代后增加1。

    2. 在每轮循环中，程序使用 containsSeven(i) 函数来检查当前的数字 i 是否包含数字7。

    3. containsSeven 函数用于检查一个数字是否包含数字7。它通过反复取数字的个位数，然后将数字除以10来检查每一位是否为7。

    4. 如果 containsSeven(i) 返回 true，则使用 continue 语句跳过包含数字7的数字，继续下一个数字。

    5. 如果不包含数字7，就使用 System.out.println(i); 打印当前数字。

    例题总结：

    这个程序将打印出1到100的所有数字，但会跳过包含数字7的数字。这是一种在特定条件下跳过某些迭代的常见做法。

    9.创建一个简单的菜单程序，让用户选择不同的选项（例如，1. 添加新项目，2. 查看项目，3. 退出程序）。使用 switch 语句处理用户的选择

    1. import java.util.Scanner;
    2.  
    3. public class SimpleMenu {
    4.     public static void main(String[] args) {
    5.         // 创建一个Scanner对象来接受用户输入
    6.         Scanner scanner = new Scanner(System.in);
    7.         int choice;
    8.  
    9.         do {
    10.             // 显示菜单选项
    11.             System.out.println("菜单：");
    12.             System.out.println("1. 添加新项目");
    13.             System.out.println("2. 查看项目");
    14.             System.out.println("3. 退出程序");
    15.             System.out.print("请选择选项（1/2/3）: ");
    16.             
    17.             // 读取用户选择
    18.             choice = scanner.nextInt();
    19.  
    20.             // 使用switch语句处理用户选择
    21.             switch (choice) {
    22.                 case 1:
    23.                     System.out.println("选项1：添加新项目");
    24.                     // 在这里添加处理添加新项目的代码
    25.                     break;
    26.                 case 2:
    27.                     System.out.println("选项2：查看项目");
    28.                     // 在这里添加处理查看项目的代码
    29.                     break;
    30.                 case 3:
    31.                     System.out.println("选项3：退出程序");
    32.                     break;
    33.                 default:
    34.                     System.out.println("无效的选项，请重新选择。");
    35.             }
    36.         } while (choice != 3); // 当用户选择退出时结束循环
    37.  
    38.         // 关闭Scanner对象
    39.         scanner.close();
    40.     }
    41. }

    分析讲解：

    1. 我们首先导入java.util.Scanner类，以便能够从用户输入中读取数据。

    2. 创建一个Scanner对象，这将帮助我们接受用户的输入。

    3. 使用 do...while 循环来实现菜单程序，循环将一直运行，直到用户选择退出。

    4. 在每轮循环中，程序显示菜单选项，提示用户选择。

    5. 使用scanner.nextInt()读取用户的选择并存储在choice变量中。

    6. 使用switch语句处理用户的选择。根据不同的选项，你可以在相应的case分支中添加处理代码。

    7. 如果用户选择退出（choice == 3），循环结束，程序退出。

    例题总结：

    这个程序演示了如何创建一个简单的菜单系统，允许用户选择不同的选项，并使用`switch`语句来处理这些选项。你可以根据需要扩展每个选项的功能。

  • 相关阅读:
    使用Nginx后如何在web应用中获取用户ip及原理解释
    Item 36: Specify std::launch::async if asynchronicity is essential.
    Tomcat 架构
    DSPE-PEG-NH2,DSPE-PEG-amine,474922-26-4,磷脂-聚乙二醇-氨基科研试剂
    poi导出excel设置对应格式
    springboot+vue.js+Elementui在线课程管理系统
    【网络安全】web渗透漏洞靶场收集
    废液收集系统物联网远程监控解决方案
    【C++】迭代器失效问题：
    hive 3.1.4部署
  • 原文地址：https://blog.csdn.net/m0_53918860/article/details/132741560