当前位置：首页 > wzjs >正文

企业网站手机端和pc端一个后台吗芜湖的公司

wzjs 2025/9/8 1:35:35

企业网站手机端和pc端一个后台吗,芜湖的公司,电子商务网站开发的意义,查建设施工资质的网站Java基础系列文章 Java基础(一)：发展史、技术体系与JDK环境配置详解 Java基础(二)：八种基本数据类型详解 Java基础(三)：逻辑运算符详解 Java基础(四)：位运算符详解 Java基础(五)：if/switch与for/while - 深入理解…

Java基础系列文章

Java基础(一)：发展史、技术体系与JDK环境配置详解

Java基础(二)：八种基本数据类型详解

Java基础(三)：逻辑运算符详解

Java基础(四)：位运算符详解

Java基础(五)：if/switch与for/while - 深入理解流程控制

引言
一、分支结构
- 1、if语句
- 2、if-else语句
- 3、if-else-if阶梯
- 4、switch语句 (传统与现代)
- - 4.1、传统语法 (Java 7 及之前，注意break)
  - 4.2、现代语法 (Java 12+, 使用->箭头和yield)
  - 4.3、更高级语法 (Java 17+, 模式匹配预览特性)
二、循环结构
- 1、for循环
- 2、while循环
- 3、do-while循环
- 4、增强for循环 (for-each)
三、流程控制的利器：break和continue
- 1、break语句
- 2、continue语句
- 3、带标签的break和continue(谨慎使用)
四、无限循环与空语句
- 1、无限循环
- 2、空语句
总结

引言

流程控制是编程语言的基石，它决定了代码执行的顺序和路径。Java提供了强大而灵活的流程控制语句，使你能够根据条件执行代码、重复执行任务以及跳出循环。掌握这些结构是写出高效、逻辑清晰程序的关键。

一、分支结构

1、if语句

语法:

if (condition) {// 当 condition 为 true 时执行的代码块
}

执行流程:
1. 计算 condition (必须是一个布尔表达式：true 或 false)
2. 如果结果为 true，则执行代码块内的语句
3. 如果结果为 false，则跳过代码块，继续执行后面的代码

示例:

int age = 18;
if (age >= 18) {System.out.println("你已成年。");
}
// 无论 age 是否 >=18, 这行都会执行
System.out.println("年龄检查完毕。");

2、if-else语句

语法:

if (condition) {// 当 condition 为 true 时执行的代码块
} else {// 当 condition 为 false 时执行的代码块
}

执行流程:
1. 计算 condition
2. 如果 true，执行 if 代码块
3. 如果 false，执行 else 代码块
4. 两个代码块必选其一执行，且只执行其一

示例:

int score = 75;
if (score >= 60) {System.out.println("及格！");
} else {System.out.println("不及格！");
}

3、if-else-if阶梯

语法:

if (condition1) {// condition1 为 true 时执行
} else if (condition2) {// condition1 为 false 且 condition2 为 true 时执行
} else if (condition3) {// 前面条件都为 false 且 condition3 为 true 时执行
} else {// 所有条件都为 false 时执行 (可选)
}

执行流程:
1. 按顺序检查每个 condition
2. 遇到第一个为 true 的 condition，则执行其对应的代码块，然后跳过整个 if-else-if 结构剩余部分
3. 如果所有 condition 都为 false，则执行 else 块（如果存在）；如果不存在 else，则整个结构不执行任何操作

示例:

int grade = 85;
if (grade >= 90) {System.out.println("优秀 (A)");
} else if (grade >= 80) { // 隐含 grade < 90System.out.println("良好 (B)");
} else if (grade >= 70) { // 隐含 grade < 80System.out.println("中等 (C)");
} else if (grade >= 60) { // 隐含 grade < 70System.out.println("及格 (D)");
} else {System.out.println("不及格 (F)");
}

4、switch语句 (传统与现代)

基于一个表达式的值，从多个可能的执行路径中选择一个。适用于多分支选择，尤其当分支基于单个变量或表达式的离散值（整数、字符、字符串 String、枚举 enum）时，通常比 if-else-if 更清晰。

4.1、传统语法 (Java 7 及之前，注意break)

switch (expression) {case value1:// expression 等于 value1 时执行的语句break; // 跳出 switch 块case value2:// expression 等于 value2 时执行的语句break;... // 可以有任意多个 casedefault:// 如果 expression 不匹配任何 case 值时执行的语句 (可选)
}

expression：可以是 byte, short, int, char (Java 7之前)，以及 String (Java 7+), enum
case valueN：valueN 必须是常量表达式，且类型必须与 expression 兼容。每个 case 代表一个可能匹配的值
break：至关重要！它终止当前 case 的执行并跳出整个 switch 块。如果省略 break，程序会继续执行下一个 case 中的语句（无论其值是否匹配），这称为“case穿透(fall-through)”。除非有意设计穿透，否则必须写 break
default：可选的。当没有 case 匹配时执行。可以放在任何位置（开头、中间、结尾），但通常放结尾。不需要 break（如果它是最后一个）

示例 (传统带break):

int dayOfWeek = 3;
switch (dayOfWeek) {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;default:System.out.println("周末或无效日期");
} // 输出: 星期三

示例 (故意 Case 穿透):

char grade = 'B';
switch (grade) {case 'A':case 'B': // A 或 B 都执行下面的代码System.out.println("成绩优良");break;case 'C':System.out.println("成绩中等");break;case 'D':case 'F': // D 或 F 都执行下面的代码System.out.println("需要努力");break;default:System.out.println("无效成绩");
} // 输出: 成绩优良

4.2、现代语法 (Java 12+, 使用->箭头和yield)

Java 12 引入了更简洁、更安全（避免意外穿透）的 switch 表达式和语句形式：：

箭头标签 (case L ->)：使用 -> 代替 :。如果标签匹配，则只执行 -> 右侧的表达式或语句块
多值匹配 (case L1, L2 ->)：一个 case 可以匹配多个值，用逗号分隔
switch 表达式 (返回值)：整个 switch 可以作为一个表达式，使用 yield 返回一个值。必须覆盖所有可能情况（或 default）

示例 (现代 switch 语句，无穿透):

int dayOfWeek = 3;
switch (dayOfWeek) {case 1 -> System.out.println("星期一"); // 单条语句可直接写case 2 -> System.out.println("星期二");case 3 -> {// 多条语句用代码块 {}System.out.println("星期三");System.out.println("一周的中点！");}case 4, 5 -> System.out.println("临近周末"); // 匹配 4 或 5default -> System.out.println("周末或无效日期");
} // 输出: 星期三 \n 一周的中点！

示例 (switch 表达式，使用 yield 返回值，类似于return):

int dayOfWeek = 3;
String dayType = switch (dayOfWeek) {case 1, 2, 3, 4, 5 -> "工作日";case 6, 7 -> {// 代码块中使用 yield 返回值System.out.println("放假了...");yield "周末"; // yield 提供 switch 表达式的返回值}default -> {// 代码块中使用 yield 返回值System.out.println("无效输入: " + dayOfWeek);yield "未知"; // yield 提供 switch 表达式的返回值}
}; // 注意：作为表达式，末尾有分号 ';'
System.out.println(dayOfWeek + " 是 " + dayType); // 输出: 3 是 工作日

4.3、更高级语法 (Java 17+, 模式匹配预览特性)

Java 17 开始引入对 switch 语句的新特性模式匹配，作为预览功能提供。这种特性允许在 switch 的 case 分支中直接进行类型判断和绑定变量，从而让代码更简洁、更安全。

static String test(Object obj) {return switch (obj) {case String s -> "字符串: " + s;case Integer i -> "整数: " + i;case null -> "空值";default -> "其他类型";};
}

case String s -> …：如果 obj 是一个字符串，就匹配并将其绑定到变量 s
case Integer i -> …：同理，匹配整数
case null -> …：甚至可以对 null 值进行单独处理
default -> …：兜底处理其他类型

注意⚠️：这是预览功能：意味着它还不是 Java 标准的一部分，将来可能会改动，从 Java 21 开始，这一功能有望正式成为标准

二、循环结构

1、for循环

用途：当循环次数已知或在循环前就知道初始化、条件和迭代步骤时特别适用。结构清晰
传统语法:
```
for (initialization; condition; iteration) {// 循环体：当 condition 为 true 时重复执行的代码
}
```
- initialization (初始化)：在循环开始前执行一次。通常用于声明和初始化循环控制变量 (如：int i = 0;)
- condition (条件)：每次循环迭代前检查的布尔表达式。如果 true，执行循环体；如果 false，终止循环
- iteration (迭代/步进)：每次循环体执行后执行。通常用于更新循环控制变量 (如：i++, i = i + 2)
执行流程:
1. 执行 initialization (仅一次)
2. 计算 condition
3. 如果 condition 为 true：
  - 执行循环体
  - 执行 iteration
  - 回到步骤 2 (再次检查 condition)
4. 如果 condition 为 false，循环终止

示例:

// 打印 0 到 9
for (int i = 0; i < 10; i++) {System.out.println(i);
}
// 计算 1 到 100 的和
int sum = 0;
for (int num = 1; num <= 100; num++) {sum += num;
}
System.out.println("Sum: " + sum);

格式的多样性（多变量控制、省略部分语句）

// 省略部分语句（但必须保留分号）
int i = 0;
for ( ; i < 5; i++) {System.out.println(i);
}// 多个变量用逗号隔开
for (int i = 0, j = 10; i < j; i++, j--) {System.out.println("i = " + i + ", j = " + j);
}

2、while循环

用途：当循环次数未知，但在循环开始前有一个明确的继续条件时适用。先判断条件，再决定是否执行循环体

语法:

while (condition) {// 循环体：当 condition 为 true 时重复执行的代码
}

执行流程:
1. 计算 condition
2. 如果 condition 为 true：
  - 执行循环体
  - 回到步骤 1 (再次检查 condition)
3. 如果 condition 为 false，循环终止
特点：循环体可能一次都不执行（如果初始条件就是 false）

示例:

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

3、do-while循环

用途：当循环体至少需要执行一次，然后再根据条件决定是否继续时适用。先执行一次循环体，再判断条件

语法:

do {// 循环体：至少执行一次
} while (condition); // 注意结尾的分号

执行流程:
1. 执行循环体
2. 计算 condition
3. 如果 condition 为 true，回到步骤 1
4. 如果 condition 为 false，循环终止
特点：循环体至少执行一次

示例:

// 1.基本用法
int i = 0;
do {System.out.println(i);i++;
} while (i < 5);// 2.条件为假也执行一次
int i = 10;
do {System.out.println("i = " + i);  // 会执行一次i++;
} while (i < 5);

4、增强for循环 (for-each)

用途：专门用于遍历数组 和实现了 Iterable 接口的集合 (如 List, Set, Queue)。语法简洁，避免了显式索引操作
语法:
```
for (ElementType element : collectionOrArray) {// 使用 element 执行操作
}
```
- ElementType：集合或数组中元素的类型
- element：循环变量，在每次迭代中依次被赋值为集合或数组中的当前元素
- collectionOrArray：要遍历的数组或集合对象
执行流程：自动依次从数组或集合中取出每个元素，赋值给 element，并执行循环体。遍历完所有元素后结束
优点：简洁、安全（无需管理索引）、不易出错（避免索引越界）
缺点：不能直接访问当前元素的索引；不能修改集合结构（如删除元素，否则可能引发 ConcurrentModificationException）；只能单向顺序遍历

示例:

// 1.遍历数组
int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {System.out.print(num + " ");
} // 输出: 1 2 3 4 5// 2.遍历 List 集合
List<String> fruits = Arrays.asList("Apple", "Banana", "Orange");
for (String fruit : fruits) {System.out.println(fruit);
} // 输出: Apple \n Banana \n Orange

三、流程控制的利器：break和continue

1、break语句

用途：
- 在循环中 (for, while, do-while)：立即终止其所在的最内层循环，跳出循环体，继续执行循环之后的代码
- 在 switch 中：终止 case 的执行并跳出整个 switch 块（防止穿透）

示例 (跳出循环):

// 查找数组中第一个负数
int[] nums = {5, 8, -2, 10, 3};
boolean found = false;
for (int num : nums) {if (num < 0) {System.out.println("找到负数: " + num);found = true;break; // 找到第一个负数后立即跳出循环}
}
if (!found) {System.out.println("没有找到负数");
}

2、continue语句

用途：仅用于循环中。跳过当前迭代中循环体内 continue 语句之后的所有代码，立即进入下一次迭代（检查循环条件并执行步进语句）

示例:

// 打印 1 到 10 的奇数
for (int i = 1; i <= 10; i++) {if (i % 2 == 0) { // 如果是偶数continue; // 跳过本次循环剩余部分，直接 i++ 然后检查 i<=10}System.out.println(i); // 只有奇数会执行到这里
}
// 输出: 1 \n 3 \n 5 \n 7 \n 9

3、带标签的break和continue(谨慎使用)

用途：用于跳出多层嵌套的循环或语句块
语法：在目标循环或语句块前放置一个标签 (label:), 然后在 break 或 continue 后指定该标签名 (break label; / continue label;)
break label;：立即终止标签所标记的整个循环或语句块
continue label;：立即跳转到标签所标记的循环的下一次迭代开始处（跳过标记循环当前迭代的剩余部分）

示例 (跳出外层循环):

outerLoop: // 标签定义在外层 for 循环前
for (int i = 0; i < 5; i++) {innerLoop: // 标签定义在内层 for 循环前for (int j = 0; j < 5; j++) {System.out.println("i=" + i + ", j=" + j);if (i == 2 && j == 2) {break outerLoop; // 跳出整个 outerLoop (两层循环都终止)}}
}
// 当 i=2, j=2 时输出终止，后续 i=3,4 都不再执行

注意：带标签的break/continue会破坏代码结构，使逻辑不易追踪。优先考虑重构代码（如将内层循环提取为方法）来避免使用它们。仅在逻辑清晰且必要时使用。

四、无限循环与空语句

1、无限循环

定义：循环条件始终为 true 的循环，理论上会一直执行下去

常见形式：

// while 形式
while (true) {// ... 需要某种 break 条件跳出 ...
}
// for 形式
for (;;) { // 初始化、条件、迭代都省略// ... 需要某种 break 条件跳出 ...
}

用途：服务器监听、游戏主循环、需要用户主动退出的程序等。必须在循环体内提供跳出机制（如 break, return, System.exit()）
风险：如果缺少跳出机制，程序将永远挂起，消耗CPU资源

2、空语句

定义：一个单独的分号 ; 表示一条不执行任何操作的语句

在流程控制中的潜在陷阱：

// 意图：i<10 时才打印 i
int i = 0;
while (i < 10); // 注意这里错误地多了一个分号！这是一个空语句循环体。
{System.out.println(i); // 这行代码在 while 循环块之外！i++;
}
// 结果：while (i < 10); 是一个无限循环（如果 i<10），因为循环体是空语句 `;`。
//       { ... } 只是一个普通的代码块，在无限循环之后（永远执行不到）。

警示：在 if, for, while 的条件后切勿随意加分号 ;，除非你明确需要一个空循环体。这通常是逻辑错误

总结

Java的流程控制语句（分支：if, switch；循环：for, while, do-while, for-each；跳转：break, continue）为你提供了构建程序逻辑的完整工具箱。理解每种结构的语法、执行流程、适用场景和潜在陷阱，并结合清晰编码的最佳实践，是编写健壮、高效、易于维护的Java程序的基础。