java第四讲(逻辑控制)

文章目录

• Java 程序逻辑控制
• • 本讲核心目标
  • 一、概述
  • 二、顺序结构
  • • 核心规则
    • 代码案例
  • 三、分支结构
  • • 3.1 if 语句
    • • 三种语法格式
      • • 格式1：单条件判断
        • 格式2：双条件二选一
        • 格式3：多条件多选一
      • 经典练习案例
      • 注意事项
    • 3.2 switch 语句
    • • 基本语法
      • 执行流程
      • 代码案例：根据数字输出星期
      • 重要注意事项
      • 补充要点
  • 四、循环结构
  • • 4.1 while 循环
    • • 基本语法
      • 核心规则：先判断，后执行；循环条件为false时直接结束。
      • 代码案例
      • 注意事项
    • 4.2 循环关键字：break
    • • 核心功能：**强制终止整个循环**，直接跳出循环体，后续循环语句不再执行。
      • 代码案例：找到100-200中第一个3的倍数
    • 4.3 循环关键字：continue
    • • 核心功能：**跳过本次循环**，立即进入下一次循环的条件判断，不执行本次循环后续语句。
      • 代码案例
    • 4.4 for 循环
    • • 基本语法（最常用，循环变量初始化、判断、更新一体化）
      • 执行流程：① → ② → ④ → ③ → ② → ④ → ③ → … → ②为false，循环结束。
      • 代码案例
      • 注意事项
    • 4.5 do while 循环（选学，使用频率极低）
    • • 基本语法
      • 核心规则：**先执行，后判断**；无论条件是否为true，循环体至少执行1次。
      • 代码案例：打印1-10的数字
      • 注意事项
    • 4.6 循环结构补充要点
  • 五、输入与输出
  • • 5.1 输出到控制台
    • • 常用格式化转换符（无需死记，按需查询）
    • 5.2 从键盘输入（Scanner类）
    • • 核心步骤
      • 常用读取方法
      • 代码案例1：读取基本信息（姓名/年龄/工资）
      • 代码案例2：循环读取多个数字，求平均值
      • 代码案例3：计算 1 到 n 的阶乘之和
      • 注意：循环输入结束方式
    • 5.3 输入输出补充要点
  • 六、经典案例：猜数字游戏
  • • 游戏规则
    • 完整代码实现
    • 关键说明
  • 七、经典例题补充
  • • 1. 数字9出现的次数
    • 2. 打印 n*n 乘法表
  • 八、IDEA 调试技巧
  • 九、课后练习（重点巩固，必须独立实现）
  • • 题目：
    • 部分解答
    • 总结

Java 程序逻辑控制

本讲核心目标

一、概述

程序的执行逻辑与人生相似，包含顺序执行、分支选择、循环重复三种核心逻辑，组合使用实现复杂的程序功能。

二、顺序结构

核心规则

按照代码书写的先后顺序一行一行执行，调整书写顺序则执行顺序同步改变，是程序最基础的执行结构。

代码案例

// 执行结果：aaa → bbb → ccc
System.out.println("aaa");
System.out.println("bbb");
System.out.println("ccc");

// 调整顺序后执行结果：aaa → ccc → bbb
System.out.println("aaa");
System.out.println("ccc");
System.out.println("bbb");

三、分支结构

用于根据条件判断执行不同的代码块，分为if语句和switch语句两类。

3.1 if 语句

三种语法格式

格式1：单条件判断

// 语法
if(布尔表达式){
// 布尔表达式为true时执行
}

// 案例：考试≥90分奖励鸡腿
int score = 92;
if(score >= 90){
System.out.println("吃个大鸡腿!!!");
}

格式2：双条件二选一

// 语法
if(布尔表达式){
// 布尔表达式为true时执行
}else{
// 布尔表达式为false时执行
}

// 案例：≥90分吃鸡腿，否则挨批评
int score = 88;
if(score >= 90){
System.out.println("吃个大鸡腿!!!");
}else{
System.out.println("挨大嘴巴子!!!");
}

格式3：多条件多选一

// 语法
if(布尔表达式1){
// 表达式1为true时执行
}else if(布尔表达式2){
// 表达式2为true时执行
}else{
// 所有表达式都为false时执行
}

// 案例：根据分数评级（优秀/良好/中等/及格/不及格/错误数据）
int score = 75;
if(score >= 90 && score <= 100){
System.out.println("优秀");
}else if(score >= 80 && score < 90){
System.out.println("良好");
}else if(score >= 70 && score < 80){
System.out.println("中等");
}else if(score >= 60 && score < 70){
System.out.println("及格");
}else if(score >= 0 && score < 60){
System.out.println("不及格");
}else{
System.out.println("错误数据");
}

经典练习案例

int num = 10;
if (num % 2 == 0) {
System.out.println("num 是偶数");
} else {
System.out.println("num 是奇数");
}

int num = –5;
if (num > 0) {
System.out.println("正数");
} else if (num < 0) {
System.out.println("负数");
} else {
System.out.println("0");
}

int year = 2000;
if (year % 100 == 0) {
// 世纪闰年：能被400整除
if (year % 400 == 0) {
System.out.println("是闰年");
} else {
System.out.println("不是闰年");
}
} else {
// 普通闰年：能被4整除但不能被100整除
if (year % 4 == 0) {
System.out.println("是闰年");
} else {
System.out.println("不是闰年");
}
}

注意事项

3.2 switch 语句

基本语法

switch(表达式){
case 常量值1:{
语句1;
break; // 跳出switch，避免穿透
}
case 常量值2:{
语句2;
break;
}
default:{ // 所有case不匹配时执行
语句n;
break;
}
}

执行流程

代码案例：根据数字输出星期

int day = 3;
switch(day) {
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;
}

重要注意事项

补充要点

四、循环结构

用于重复执行某段代码，直到满足终止条件，分为while、for、do while三种，核心关键字：break（终止循环）、continue（跳过本次循环）。

4.1 while 循环

基本语法

while(循环条件){ // 循环条件为布尔表达式
循环语句; // 循环条件为true时执行
}

核心规则：先判断，后执行；循环条件为false时直接结束。

代码案例

int num = 1;
while (num <= 10) {
System.out.println(num);
num++; // 循环变量更新，避免死循环
}

int n = 1;
int result = 0;
while (n <= 100) {
result += n;
n++;
}
System.out.println(result); // 输出：5050

int n = 1;
int result = 1;
while (n <= 5) {
result *= n;
n++;
}
System.out.println(result); // 输出：120

int num = 1;
int sum = 0;
// 外层循环：求阶乘的和
while (num <= 5) {
int factorResult = 1;
int tmp = 1;
// 内层循环：求单个数字的阶乘
while (tmp <= num) {
factorResult *= tmp;
tmp++;
}
sum += factorResult;
num++;
}
System.out.println(sum); // 输出：153

注意事项

4.2 循环关键字：break

核心功能：强制终止整个循环，直接跳出循环体，后续循环语句不再执行。

代码案例：找到100-200中第一个3的倍数

int num = 100;
while (num <= 200) {
if (num % 3 == 0) {
System.out.println("找到了 3 的倍数, 为:" + num); // 输出：102
break; // 找到后立即终止循环
}
num++;
}

4.3 循环关键字：continue

核心功能：跳过本次循环，立即进入下一次循环的条件判断，不执行本次循环后续语句。

代码案例

1.找到100-200中所有3的倍数

int num = 100;
while (num <= 200) {
if (num % 3 != 0) {
num++; // 必须更新变量，否则死循环
continue; // 非3的倍数，跳过本次打印
}
System.out.println("找到了 3 的倍数, 为:" + num);
num++;
}

2.输出 1-100 之间所有能被 3 和 5 整除的数字

int i = 1;
while (i <= 100) {
if (i % 15 != 0) {
i++;
continue; // 跳过不符合条件的数
}
System.out.println(i); // 输出符合条件的数
i++;
}

4.4 for 循环

基本语法（最常用，循环变量初始化、判断、更新一体化）

for(表达式①; 布尔表达式②; 表达式③){
表达式④; // 循环体
}
// 表达式①：初始化循环变量（仅执行1次）
// 表达式②：循环条件（true则执行循环体）
// 表达式③：更新循环变量（每次循环体执行完后执行）

执行流程：① → ② → ④ → ③ → ② → ④ → ③ → … → ②为false，循环结束。

代码案例

for (int i = 1; i <= 10; i++) {//快捷键：10.fori
System.out.println(i);//i.sout
}

int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
System.out.println(sum); // 输出：5050

int result = 1;
for (int i = 1; i <= 5; i++) {
result *= i;
}
System.out.println(result); // 输出：120

int sum = 0;
for (int i = 1; i <= 5; i++) {
int tmp = 1;
for (int j = 1; j <= i; j++) {
tmp *= j;
}
sum += tmp;
}
System.out.println(sum); // 输出：153

注意事项

与while循环完全一致：

4.5 do while 循环（选学，使用频率极低）

基本语法

do{
循环语句; // 先执行一次循环体
}while(循环条件); // 再判断条件，true则继续循环

核心规则：先执行，后判断；无论条件是否为true，循环体至少执行1次。

代码案例：打印1-10的数字

int num = 1;
do {
System.out.println(num);
num++;
} while (num <= 10);

注意事项

4.6 循环结构补充要点

五、输入与输出

5.1 输出到控制台

三种输出方式，核心区别：是否换行、是否支持格式化。

常用格式化转换符（无需死记，按需查询）

5.2 从键盘输入（Scanner类）

核心步骤

常用读取方法

• 读取整数：sc.nextInt()
• 读取浮点数：sc.nextFloat()/sc.nextDouble()
• 读取字符串：sc.nextLine()（读取整行，含空格）/sc.next()（读取到空格为止）

代码案例1：读取基本信息（姓名/年龄/工资）

import java.util.Scanner; // 导入包
public class InputTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in); // 创建对象
// 读取数据
System.out.println("请输入你的姓名:");
String name = sc.nextLine();
System.out.println("请输入你的年龄:");
int age = sc.nextInt();
System.out.println("请输入你的工资:");
float salary = sc.nextFloat();
// 输出结果
System.out.println("你的信息如下:");
System.out.println("姓名: "+name+"\\n"+"年龄:"+age+"\\n"+"工资:"+salary);
sc.close(); // 关闭对象
}
}

代码案例2：循环读取多个数字，求平均值

import java.util.Scanner;
public class AvgTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int sum = 0;
int count = 0;
// sc.hasNextInt()：判断是否还有整数输入
while (sc.hasNextInt()) {
int tmp = sc.nextInt();
sum += tmp;
count++;
}
System.out.println("sum = " + sum);
System.out.println("avg = " + (double)sum / count);
sc.close();
}
}

代码案例3：计算 1 到 n 的阶乘之和

import java.util.Scanner;

public class FactorialSum {
public static void main(String[] args) {
// 创建Scanner对象读取控制台输入
Scanner scanner = new Scanner(System.in);
// 读取用户输入的整数n
int n = scanner.nextInt();

// 用于存储阶乘和的变量，初始值为0
int sum = 0;

// 外层循环：遍历1到n的每个数，计算其阶乘并累加
for (int j = 1; j <= n; j++) {
// 用于存储当前数j的阶乘，初始值为1（因为1的阶乘是1，乘法初始值不能为0）
int ret = 1;
// 内层循环：计算j的阶乘
for (int i = 1; i <= j; i++) {
ret *= i;
}
// 将当前数的阶乘累加到总和中
sum += ret;
}

// 输出最终的阶乘和
System.out.println(sum);

// 关闭Scanner，释放资源（可选，但建议添加）
scanner.close();
}
}

注意：循环输入结束方式

• Windows：输入完成后按 Ctrl + Z （cmd）/ Ctrl + D(IDEA)再按回车；
• Linux/Mac：输入完成后按 Ctrl + D 再按回车。

5.3 输入输出补充要点

六、经典案例：猜数字游戏

游戏规则

完整代码实现

import java.util.Random; // 导入随机数包
import java.util.Scanner; // 导入输入包
public class GuessNumber {
public static void main(String[] args) {
// 1. 创建随机数对象，生成1-100的随机数（nextInt(100)生成0-99，+1后1-100）
Random random = new Random();
int toGuess = random.nextInt(100) + 1;
// 2. 创建输入对象
Scanner sc = new Scanner(System.in);
// 3. 循环猜测，直到猜对
while (true) {
System.out.println("请输入要猜测的数字: (1-100)");
int num = sc.nextInt();
if (num < toGuess) {
System.out.println("低了");
} else if (num > toGuess) {
System.out.println("高了");
} else {
System.out.println("猜对了");
break; // 猜对后终止循环
}
}
sc.close(); // 关闭输入流
}
}

关键说明

• Random.nextInt(n)：生成0 ~ n-1的随机整数，因此nextInt(100)+1才是1-100；
• while(true)：无限循环，仅当猜对时通过break终止。

七、经典例题补充

1. 数字9出现的次数

题目：统计 1 到 100 的所有整数中，数字9出现的次数。 思路：遍历每个数，分别检查其十位和个位是否为9。

public static int count9() {
int count = 0;
for (int i = 1; i <= 100; i++) {
if (i / 10 == 9) { // 检查十位
count++;
}
if (i % 10 == 9) { // 检查个位
count++;
}
}
return count; // 结果为 20 次
}

2. 打印 n*n 乘法表

思路：使用两层嵌套循环，外层控制行，内层控制列。

public static void printMultiTable(int n) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + "*" + i + "=" + (i*j) + "\\t");
}
System.out.println();
}
}

八、IDEA 调试技巧

九、课后练习（重点巩固，必须独立实现）

题目：

部分解答

2.

public class Test {
public static void main(String[] args) {
int n = 7; // 要判断的整数
int i = 2; // 从2开始检查因数

// 循环条件：i <= 根号n，因为如果n有大于根号n的因数，必然有一个小于根号n的因数
for (; i <= Math.sqrt(n); i++) {
// 如果n能被i整除，说明i是n的因数，n不是素数
if (n % i == 0) {
break; // 跳出循环，无需继续检查
}
}

// 如果循环结束后，i > 根号n，说明没有找到能整除n的因数，n是素数
if (i > Math.sqrt(n)) {
System.out.println(n + " 是素数！");
}
}
}

7.

public class Test {
public static void main(String[] args) {
// 遍历0到99998的所有整数
for (int i = 0; i < 99999; i++) {
int count = 0; // 记录数字的位数
int tmp = i; // 临时变量，用于计算位数

// 计算数字的位数
while (tmp != 0) {
count++; // 每循环一次，位数+1
tmp /= 10; // 去掉数字的最后一位
}

tmp = i; // 重置临时变量，用于计算各位数字的幂和
int sum = 0; // 存储各位数字的幂和

// 计算各位数字的count次方之和
while (tmp != 0) {
// 取最后一位数字，计算它的count次方，累加到sum
sum += Math.pow(tmp % 10, count);
tmp /= 10; // 去掉数字的最后一位
}

// 如果幂和等于原数字，说明是阿姆斯特朗数
if (sum == i) {
System.out.println(i);
}
}
}
}

总结