第二章 运算符与表达式 —— 让数据产生交互

先聊聊基础但又至关重要的内容——运算符和表达式。它们就像是编程世界里的算盘和齿轮，数据如何流转、如何计算，全依赖于它们。不过别小看这些基本操作，里面藏着不少细节陷阱，踩一个就得花大把时间调试。我们按照节奏一个一个来梳理。

算术运算符的细节与陷阱

加减乘除大家都很熟悉，但整数除法有一个“截断”特性——当两边都是整数时，结果会直接砍掉小数部分，不会进行四舍五入。来看这段Java代码：

// Ja va算术运算符
int a = 17;
int b = 5;
System.out.println(a + b); // 22
System.out.println(a - b); // 12
System.out.println(a * b); // 85
System.out.println(a / b); // 3（整数除法，截断小数）
System.out.println(a % b); // 2（取余数）

// 整数除法的陷阱
double result = 17 / 5;  
// 结果是3.0，不是3.4！
// 原因：两边都是整数，先执行整数除法得3，再转double
double correct = 17.0 / 5; // 3.4，浮点数除法
double correct2 = (double)17 / 5; // 显式转换

// 负数取余
System.out.println(-17 % 5); // -2
System.out.println(17 % -5); // 2
// 规则：结果的符号与被除数相同

// 复合赋值运算符
a += 5; // 等价于 a = a + 5
a -= 3; // a = a - 3
a *= 2; // a = a * 2
a /= 4; // a = a / 4
a %= 3; // a = a % 3

这里有一个经典的踩坑点：double result = 17 / 5; 你可能会以为结果是3.4？错了，实际是3.0。因为左右两边都是整数，Java先执行整数除法得到3，然后再转换成double。要避开这个陷阱，要么让其中一边变成浮点数（比如 17.0 / 5），要么显式进行强制转换。另外，负数取余的符号规则也要注意：结果的正负号跟随被除数，例如 -17 % 5 得到 -2，17 % -5 得到 2。复合赋值运算符（+=、-= 等）写起来很简洁，但注意它们隐式包含了类型转换，细节上需要多加留心。

关系运算符与逻辑运算符

关系运算符（<、>、== 等）产生布尔值，逻辑运算符（and、or、not）则把它们串接起来。Python有一个很酷的特性——链式比较，比如 5 < x < 15 直接表示x在5到15之间，不需要写成 5 < x and x < 15。不过要注意 5 < x > 8 这种写法的含义和数学直觉不同，它等价于 5 < x and x > 8，并不是一个连续的区间。

# Python关系运算符
x = 10
y = 20
print(x < y)  # True
print(x <= y) # True
print(x > y)  # False
print(x >= y) # False
print(x == y) # False
print(x != y) # True

# 链式比较（Python特色）
print(5 < x < 15) # True，等价于 5 < x and x < 15
print(5 < x > 8)  # True，注意这不是数学表达式

# 逻辑运算符
a = True
b = False
print(a and b) # False（与）
print(a or b)  # True（或）
print(not a)   # False（非）

# 短路求值（Short-circuit evaluation）
def risky_operation():
    print("This won't be called")
    return 1 / 0

# 不会执行
False and risky_operation()  # 左侧False，短路，右侧不执行
True or risky_operation()    # 左侧True，短路，右侧不执行

# 利用短路实现默认值
name = input("Enter name: ") or "Anonymous"
# 如果输入为空字符串，使用默认值

逻辑运算符的“短路求值”是一个非常实用的技能——比如 False and risky_operation()，因为左边已经是False，整个表达式的结果已经确定，右侧根本不会执行，哪怕 risky_operation() 里面有除零操作也不会触发。反过来 True or risky_operation() 也同样会短路。你可以利用这个特性来实现简洁的默认值逻辑，比如 name = input(...) or "Anonymous"，当用户输入空字符串时，自动使用默认值。

位运算符（底层优化利器）

位运算平时用得不算多，但在性能敏感的场景或者底层开发中，它们可是神兵利器。直接来看C语言的例子（Java、C++等语言也是通用的）：

// C语言位运算（同样适用于Ja va、C++等）
unsigned int a = 0b1100; // 12
unsigned int b = 0b1010; // 10

// 按位与：两个都为1才为1
printf("%d", a & b); // 0b1000 = 8

// 按位或：至少一个为1则为1
printf("%d", a | b); // 0b1110 = 14

// 按位异或：不同为1，相同为0
printf("%d", a ^ b); // 0b0110 = 6

// 按位取反
printf("%u", ~a); // 0b...11110011（高位全变1）

// 左移：乘以2的n次方
printf("%d", a << 1); // 0b11000 = 24
printf("%d", a << 2); // 0b110000 = 48

// 右移：除以2的n次方（整数除法）
printf("%d", a >> 1); // 0b0110 = 6

// 实际应用：权限系统
#define READ  0b100 // 4
#define WRITE 0b010 // 2
#define EXEC  0b001 // 1

int permission = READ | WRITE; // 0b110 = 6
if (permission & READ) {
    printf("Can read"); // 执行
}
if (permission & EXEC) {
    printf("Can exec"); // 不执行
}

// 应用：快速判断奇偶
int isOdd = (x & 1); // 最后一位为1则是奇数

// 应用：交换两个数（不借助临时变量）
int x = 5, y = 7;
x = x ^ y;
y = x ^ y;
x = x ^ y; // 现在 x=7, y=5

位运算最经典的应用场景就是权限系统：用不同的二进制位代表不同的权限（读取、写入、执行），通过按位与和按位或来组合和判断。另外，判断奇偶数可以使用 x & 1，这种方式比取模运算更快。而通过三次异或来交换两个数的值，不需要临时变量，这在面试题中经常出现。

运算符优先级（复杂表达式的求值顺序）

运算符优先级是另一个容易出问题的地方。记不住优先级没关系，有一条铁律：拿不准就加括号。下面这张优先级表（从高到低）值得你收藏：

// 运算符优先级表（从高到低）
// 1. 括号()
// 2. 后缀 ++ --
// 3. 一元 ++ -- + - ! ~
// 4. 乘除 * / %
// 5. 加减 + -
// 6. 移位 << >> >>>
// 7. 关系 < <= > >= instanceof
// 8. 相等 == !=
// 9. 逻辑与 &
// 10. 逻辑异或 ^
// 11. 逻辑或 |
// 12. 条件与 &&
// 13. 条件或 ||
// 14. 三元 ?:
// 15. 赋值 = += -= *= ...

// 易错示例
int result = 5 + 3 * 2;   // 11，不是16
int result2 = (5 + 3) * 2; // 16

boolean flag = true || false && false; // true
// 原因：&&优先级高于||，等价于 true || (false && false)

// 赋值运算符从右向左结合
int a, b, c;
a = b = c = 10; // 等价于 a = (b = (c = 10))

// 建议：复杂表达式使用括号增加可读性
int result3 = ((a + b) * (c - d)) / (e + f);

举个例子：5 + 3 * 2 的结果是11，因为乘法的优先级高于加法。而 true || false && false 的结果是true，因为 && 的优先级高于 ||，实际计算的是 true || (false && false)。赋值运算符是从右向左结合的，a = b = c = 10 相当于先把10赋给c，再把c的值赋给b，最后赋给a。在复杂的表达式里，多使用括号，既能避免歧义，也方便日后维护代码的人阅读。

第三章 控制流程 —— 程序的决策与循环

学完运算符，下一步就是让程序“活”起来的控制流程。条件分支和循环，是编程语言中最核心的两块拼图。

条件分支的精髓

if-else 家族的完整形态，来看Java的例子：

// Ja va条件语句完整示例
int score = 85;
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 70) {
    System.out.println("中等");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

// 嵌套if
boolean hasTicket = true;
boolean isVip = false;
if (hasTicket) {
    if (isVip) {
        System.out.println("VIP通道");
    } else {
        System.out.println("普通通道");
    }
} else {
    System.out.println("请先购票");
}

// if-else 的代码块注意事项
int x = 10;
if (x > 5)
    System.out.println("大于5");
    System.out.println("这行永远执行"); // 缩进误导！实际不属于if
// 正确写法：始终使用大括号
if (x > 5) {
    System.out.println("大于5");
    System.out.println("属于if块");
}

写if-else时，最怕遇到“悬空else”以及省略大括号导致的逻辑错误。建议无论分支下有多少条语句，都加上大括号，养成好习惯。嵌套if也不要太深，能够拆成 else if 的就不要层层嵌套，这样可读性会好很多。

再来看看switch语句的进化史。传统的switch只支持int、char、String、enum，而且容易因为漏写break而导致“穿透”现象：

// Ja va传统switch（支持int, char, String, enum）
int day = 3;
String dayName;
switch (day) {
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    default:
        dayName = "Unknown";
}

// 穿透现象（如果没有break）
switch (day) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        System.out.println("工作日");
        break; // 所有1-5都执行这里
    case 6:
    case 7:
        System.out.println("周末");
        break;
}

// Ja va 14+ 增强switch（表达式形式）
String result = switch (day) {
    case 1, 2, 3, 4, 5 -> "工作日";
    case 6, 7 -> "周末";
    default -> "无效";
};

// 带yield的复杂逻辑
String grade = "A";
int points = switch (grade) {
    case "A" -> {
        System.out.println("优秀");
        yield 95; // 产生返回值
    }
    case "B" -> {
        System.out.println("良好");
        yield 85;
    }
    default -> 0;
};

利用穿透特性可以简洁地合并多个case。Java 14之后的新switch支持箭头语法和 yield 返回值，写起来更加清爽，还能直接赋值给变量。如果你还在使用旧版本，记得每条case末尾加上break，否则会一路穿透下去。

循环结构的深度剖析

循环有几种常见形式：while、do-while、for。先看Python的while：

# Python while循环
# 基本形式
count = 0
while count < 5:
    print(f"Count: {count}")
    count += 1

# 无限循环与break
while True:
    user_input = input("输入exit退出: ")
    if user_input == "exit":
        break
    print(f"你输入了: {user_input}")

# continue跳过本次循环
num = 0
while num < 10:
    num += 1
    if num % 2 == 0:
        continue # 跳过偶数
    print(num)  # 打印奇数

# while-else（Python特色）
search = [1, 3, 5, 7, 9]
target = 6
i = 0
while i < len(search):
    if search[i] == target:
        print("找到了！")
        break
    i += 1
else:
    print("没找到")  # 循环正常结束（没有break）时执行

Python的while-else是一个独特的设计：当循环因为条件不满足而正常结束时，会执行else块；如果是因为break跳出，则不执行。这种机制非常适合“查找”场景——找到了就break，没找到就进入else提示。

再看Java的do-while，它至少会执行一次：

// Ja va do-while循环（至少执行一次）
int attempts = 0;
int password = 1234;
int input;
do {
    System.out.print("请输入密码: ");
    input = scanner.nextInt();
    attempts++;
    if (attempts >= 3) {
        System.out.println("超过尝试次数");
        break;
    }
} while (input != password);

do-while特别适合那些“先做一遍再判断”的场景，比如密码输入至少会让你试一次。

for循环的形态更加丰富。先看C语言风格的for：

// 基本形式
for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

// 多个变量
for (int i = 0, j = 10; i < j; i++, j--) {
    System.out.println("i=" + i + ", j=" + j);
}

// 省略部分表达式
int i = 0;
for (; i < 10; ) {
    System.out.println(i);
    i++;
}

// 死循环
for (;;) {
    // 等价于 while(true)
}

三个表达式都可以省略，但分号不能少。写死循环时，for(;;)和while(true)都可以，看个人习惯。

增强for循环（foreach）专为遍历数组和集合而设计：

// 遍历数组
int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    System.out.println(num);
}

// 遍历集合
List names = Arrays.asList("Alice", "Bob", "Charlie");
for (String name : names) {
    System.out.println(name);
}

使用增强for循环时不能修改容器结构（比如删除元素），但遍历读取非常方便。

Python的for循环本质上是一种迭代器风格，配合range和enumerate使用非常灵活：

# 遍历范围
for i in range(5):       # 0,1,2,3,4
    print(i)
for i in range(2, 8):    # 2,3,4,5,6,7
    print(i)
for i in range(1, 10, 2): # 1,3,5,7,9（步长2）
    print(i)

# 反向遍历
for i in range(10, 0, -1): # 10,9,8,...,1
    print(i)

# 遍历列表
fruits = ["apple", "banana", "orange"]
for fruit in fruits:
    print(fruit)

# 同时获取索引和值
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

# 遍历字典
person = {"name": "Alice", "age": 25, "city": "New York"}
for key in person:
    print(f"{key}: {person[key]}")
for key, value in person.items():
    print(f"{key}: {value}")

# 并行遍历多个序列
names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]
for name, score in zip(names, scores):
    print(f"{name} 得分: {score}")

# 列表推导式（简洁的循环）
squares = [x**2 for x in range(10)]  # [0,1,4,9,16,25,36,49,64,81]
evens = [x for x in range(20) if x % 2 == 0]
matrix = [[i*j for j in range(5)] for i in range(5)]  # 二维列表

列表推导式是Python里非常优雅的语法糖，一行就能搞定循环、过滤和映射。例如 [x**2 for x in range(10)] 可以生成0到9的平方列表。在写复杂逻辑时，也可以嵌套循环和条件。

循环控制的高级技巧

Java支持带标签的break和continue，可以直接跳出多层循环：

// 带标签的break和continue（Ja va）
outer:
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) {
            break outer; // 跳出外层循环
        }
        System.out.println("i=" + i + ", j=" + j);
    }
}
// 输出：i=0,j=0 i=0,j=1 i=0,j=2 i=1,j=0

不带标签的break只能跳出当前循环，而带标签的break允许直接跳出指定层。Python没有标签，但可以通过 for...else 或异常来模拟。不过最常用的方式还是把逻辑封装成函数，用return实现类似的效果。

Python的for-else和while-else前面已经介绍过，再看一个查找质数的例子：

# Python的for-else和while-else
# 查找质数的例子
for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(f"{n} = {x} * {n//x}")
            break
    else:
        print(f"{n} 是质数")

在这个例子中，内层循环如果找到了因子就break，否则执行else打印质数。非常直观地展示了else子句的用途。

掌握了这些循环控制技巧，无论是处理数据、实现算法还是编写业务逻辑，你都能游刃有余。记住：循环的目的是重复，但不要忘记留好退出条件，别让程序跑到地老天荒。