背景

本文是《Java 后端从小白到大神》修仙系列第三篇，正式进入Java后端世界，本篇文章主要聊Java基础。若想详细学习请点击首篇博文，我们开始把。

运算符
流程控制语句
Java 数学相关内容

1. 运算符

1. 算术运算符

运算符	描述	示例	结果（假设a=10,b=3）
`+`	加法	`a + b`	13
`-`	减法	`a - b`	7
`*`	乘法	`a * b`	30
`/`	除法	`a / b`	3（整数除法）
`%`	取模	`a % b`	1
`++`	自增	`a++`（后缀）或 `++a`	11（前缀先增，后缀后增）
`--`	自减	`b--`（后缀）或 `--b`	2（前缀先减，后缀后减）

代码示例：

int a = 10;
int b = 3;
System.out.println(a / b); // 输出 3（整数除法）
System.out.println((double)a / b); // 输出 3.333...

int x = 5;
int y = x++; // y=5, x=6（后缀自增）
int z = ++x; // x=7, z=7（前缀自增）

2. 关系运算符

运算符	描述	示例	结果（假设a=5,b=10）
`==`	等于	`a == b`	false
`!=`	不等于	`a != b`	true
`>`	大于	`a > b`	false
`<`	小于	`a < b`	true
`>=`	大于等于	`a >= 5`	true
`<=`	小于等于	`b <= 10`	true

注意：

不可用于比较对象引用（比较对象内容用 equals()，比较内存地址用 ==）

3. 逻辑运算符

运算符	描述	示例	结果（假设A=true,B=false）
`&&`	短路与	`A && B`	false
`\|\|`	短路或	`A\|\|B`	true
`!`	非	`!B`	true
`&`	非短路与	`A & B`	false
`\|`	非短路或	`A\|B`	true
`^`	异或	`A ^ B`	true（不同则为真）

短路特性：

// && 示例：如果第一个条件为 false，不执行第二个判断
if (obj != null && obj.getValue() > 0) { ... }

// || 示例：如果第一个条件为 true，不执行第二个判断
if (x < 0 || x > 100) { ... }

4. 赋值运算符

运算符	描述	示例	等价于
`=`	基本赋值	`a = 5`	-
`+=`	加后赋值	`a += 3`	`a = a + 3`
`-=`	减后赋值	`b -= 2`	`b = b - 2`
`*=`	乘后赋值	`c *= 4`	`c = c * 4`
`/=`	除后赋值	`d /= 2`	`d = d / 2`
`%=`	取模赋值	`e %= 3`	`e = e % 3`
`<<=`	左移位赋值运算符	`c <<= 2`	`c = c << 2`
`>>=`	右移位赋值运算符	`c >>= 2`	`c = c >> 2`
`&=`	按位与赋值运算符	`c &= 2`	`c = c & 2`
`^=`	按位异或赋值操作符	`c ^= 2`	`c = c ^ 2`
`\|=`	按位或赋值操作符	`c \|= 2`	`c = c \| 2`

注意：

复合赋值运算符会自动进行类型转换

1
2

int num = 5;
num += 3.14; // 合法，等价于 num = (int)(num + 3.14)

5. 三目运算符（条件运算符）

运算符	描述	格式	示例
`?:`	条件运算	`条件 ? 表达式1 : 表达式2`	`int max = (a > b) ? a : b;`

代码示例：

int score = 85;
String result = (score >= 60) ? "及格" : "不及格";
System.out.println(result); // 输出 "及格"

// 嵌套使用
int x = 10, y = 20, z = 15;
int max = (x > y) ? (x > z ? x : z) : (y > z ? y : z); // 输出 20

6. 运算符优先级

以下为常见运算符优先级（从高到低）：

() 括号
++ --（后缀/前缀）
* / %
+ -
> < >= <= == !=
&& ||
?:
= += -= 等赋值运算符

建议：

复杂表达式使用括号明确优先级

`1`	`int result = (a + b) * c / d % e;`

2. 流程控制语句

1. 条件控制

1. if-else

if-else 流程：

开始
  ↓
[条件判断] → true → 执行代码块 → 结束
  ↓ false
[else if 判断] → true → 执行代码块 → 结束
  ↓ false
[else 代码块] → 结束

// 基础结构
int score = 85;
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好"); // 输出此行
} else {
    System.out.println("继续努力");
}

// 嵌套结构（避免超过3层）
if (user != null) {
    if (user.isVIP()) {
        // VIP处理逻辑
    } else {
        // 普通用户处理
    }
}

最佳实践：

始终使用 {} 包裹代码块（即使只有一行代码）
复杂条件判断优先考虑策略模式替代多层嵌套

2. switch（Java 12+ 增强版）

// 传统语法（需要break）
String day = "MON";
switch (day) {
    case "MON":
    case "TUE":
        System.out.println("工作日");
        break;
    case "SAT":
    case "SUN":
        System.out.println("周末");
        break;
    default:
        System.out.println("非法输入");
}

// 现代语法（箭头表达式 + yield）
String result = switch (day) {
    case "MON", "TUE" -> "工作日";
    case "SAT", "SUN" -> {
        System.out.println("检测到周末");
        yield "周末"; // 代码块中使用yield返回值
    }
    default -> throw new IllegalArgumentException();
};

版本对比：

特性	传统switch	增强switch（Java12+）
语法	`case:` + `break`	`case ->` 表达式
返回值	不支持	支持通过`yield`返回值
多值匹配	需要多个`case`	`case "A", "B" ->`
穿透风险	存在（需手动break）	无

2. 循环控制

1. for循环

for 循环流程：

初始化 → 条件检查 → true → 执行循环体 → 更新表达式
                   ↓ false
                   结束

// 基础for循环
for (int i = 0; i < 10; i++) {
    System.out.print(i + " "); // 0-9
}

// 增强for循环（遍历数组/集合）
int[] nums = {1, 2, 3};
for (int num : nums) {
    System.out.print(num + " "); // 1 2 3
}

// 无限循环（慎用）
for (;;) {
    // 需要明确的退出条件
    if (condition) break;
}

2. while循环

// 先判断后执行
int count = 0;
while (count < 5) {
    System.out.print(count + " "); // 0-4
    count++;
}

// 无限循环标准写法
while (true) {
    // 必须包含break条件
    if (shouldExit) break;
}

3. do-while循环

// 先执行后判断（至少执行一次）
int x = 5;
do {
    System.out.print(x + " "); // 输出5
    x++;
} while (x < 3);

3. 跳转控制

1. break

// 基础用法（跳出当前循环）
for (int i = 0; i < 10; i++) {
    if (i == 5) break;
    System.out.print(i + " "); // 0-4
}

// 带标签的break（跳出多层循环）
outerLoop: 
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) break outerLoop;
        System.out.println(i + "-" + j);
    }
}
// 输出：
// 0-0
// 0-1
// 0-2
// 1-0

2. continue

// 跳过当前迭代
for (int i = 0; i < 5; i++) {
    if (i % 2 == 0) continue;
    System.out.print(i + " "); // 1 3
}

// 带标签的continue
outer: 
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (j == 1) continue outer;
        System.out.println(i + "-" + j);
    }
}
// 输出：
// 0-0
// 1-0
// 2-0

4. 流程控制最佳实践

1. 循环优化

避免在循环内创建对象（如 new ArrayList()）
复杂条件判断提到循环外部

2. 嵌套控制

循环嵌套不超过3层（否则应考虑重构）
优先使用 break 替代循环控制变量

3. 现代语法优先

// 使用增强switch替代传统写法
String type = switch (code) {
    case 200 -> "成功";
    case 404 -> "未找到";
    default -> "未知状态";
};

4. 防御式编程

// 循环必须有安全退出机制
int retry = 0;
while (retry < MAX_RETRY) {
    if (operation()) break;
    retry++;
}

3. Java 数学相关内容

1. 二进制字面量

java 二进制前缀 0b/0B

1
2

int binaryNum = 0b1010; // 二进制前缀 0b/0B
System.out.println(binaryNum); // 输出十进制 10

2. 位运算

运算符	描述	示例（a=60=0b0011 1100, b=13=0b0000 1101）	结果（二进制）
`&`	按位与（对应的两个二进制位均为1时，结果才为1）	`a & b`	得到12，即0000 1100
`\|`	按位或（对应的两个二进制位有一个为1，结果就为1）	`a \| b`	得到61，即 0011 1101
`^`	按位异或（如果相对应位值相同，则结果为0，否则为1）	`a ^ b`	得到49，即 0011 0001
`~`	按位非（如果位为0，结果是1，如果位为1，结果是0）	`~a`	得到-61，即1100 0011
`<<`	左移（按位左移运算符，左操作数按位左移右操作数指定的位数）	`a << 2`	得到240，即 1111 0000
`>>`	带符号右移（按位右移运算符，左操作数按位右移右操作数指定的位数）	`a >> 1`	得到15即 1111
`>>>`	无符号右移（按位右移补零操作符，左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充）	`a >>> 1`	得到15即0000 1111

3. 进制转换

1. 二进制转其他进制

Integer.toOctalString(0b1011); // 二进制转八进制输出
Integer.toHexString(0b1011); // 二进制转十六进制输出
Integer.toBinaryString(11); // 十进制转二进制输出
Integer.toHexString(11); // 十进制转十六进制输出

2. 其他进制转二进制

1
2
3

Integer.toBinaryString(013);// 八进制转二进制输出
Integer.toBinaryString(11);// 十进制转二进制输出
Integer.toBinaryString(0xb);// 十六进制转二进制输出

3. 其他进制转十进制

1
2
3

System.out.println(013);// 八进制转十进制输出
System.out.println(0b1011);// 二进制转十进制输出
System.out.println(0xb);// 十六进制转十进制输出

4. 其他进制转八进制

1
2
3

Integer.toOctalString(0b1011);// 二进制转八进制输出
Integer.toOctalString(11);// 十进制转八进制输出
Integer.toOctalString(0xb);// 十六进制转八进制输出

5. 其他进制转十六进制

1
2
3

Integer.toHexString(013);// 八进制转十六进制输出
Integer.toHexString(11);// 十进制转十六进制输出
Integer.toHexString(0b1011);// 二进制转十六进制输出

6. 数值处理陷阱

浮点数精度问题（避免用 == 比较 double）
整数溢出（如 Integer.MAX_VALUE + 1 变负数）
位移运算优先级（a << 2 + 1 实际是 a << (2+1)）

总结

Java基础，需要熟练掌握。