# JavaSE 基础 — Day02 笔记

> **日期**：2026-07-14  
> **项目**：`c260714`  
> **作者**：WanJL

---

## 一、流程控制（if-else）

### 1. 程序的结构

程序的结构分为三种：

| 结构 | 说明 |
|------|------|
| **顺序结构** | 代码从左到右、从上到下依次执行 |
| **分支结构** | 为代码设定条件，满足条件执行 A，不满足执行 B |
| **循环结构** | 重复执行某段代码（后续课程讲解） |

### 2. if-else 分支结构

**核心思想**：告诉程序在什么情况下做什么事。

> 如果下雨，要打伞；否则就不打伞。

**语法格式**：

```java
if (布尔表达式) {
    // 条件为 true 时执行的代码
} else {
    // 条件为 false 时执行的代码
}
```

> **布尔表达式**：运算结果为 `boolean` 类型值（`true` 或 `false`）的表达式。

**示例**：判断一个整数是正数还是负数

```java
int a = 15;
if (a > 0) {
    System.out.println("正数");
} else {
    System.out.println("负数");
}
```

**完整代码 —— Demo01.java**

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo01
 * @description 流程控制
 * @create 2026/7/14
 */
public class Demo01 {
    public static void main(String[] args) {
        /*
            逻辑
            流程控制就是告诉程序，要在什么情况下做什么事 的逻辑
            如果 下雨 要打伞 否则就不打伞

            程序的结构分为三种：
                1、 顺序结构  代码从左到右从上到下依次执行
                2、 分支结构 为代码设定条件，如果满足条件，就执行A，不满足就执行B
                        如果 (是否下雨){
                            要打伞
                        }否则{
                            不打伞
                        }
                        if(下雨==true){       括号里的 必须是布尔表达式（布尔表达式就是运算的结果是布尔类型值 true 或 false）
                            要打伞
                        }else{
                            不打伞
                        }
                 比如判断： 15 是 正数 还是负数
         */
        System.out.println("前面有n多代码...............");
        int a = 15;   // 定义一个整数类型的变量
        if (a > 0) {   // 判断 变量值是否大于0   运行结果是boolean类型值
            System.out.println("正数");
        } else {
            System.out.println("负数");
        }
        System.out.println("后面有n多代码...............");
        /*
            1、判断年龄age 是否大于30岁
            2、判断年龄 age2 是否成年
            3、判断分数 score 是否优秀 大于90分
         */
    }
}
```

### 3. 随堂练习（if 分支）

1. 判断年龄 `age` 是否大于 30 岁
2. 判断年龄 `age2` 是否成年（≥ 18 岁）
3. 判断分数 `score` 是否优秀（大于 90 分）

---

## 二、Java 运算符

### 1. 运算符的分类

#### 按操作数的数量分类

| 类型 | 说明 | 示例 |
|------|------|------|
| **一元运算符** | 只有一个操作数参与运算 | `++`、`--` |
| **二元运算符** | 有两个操作数参与运算 | `+`、`-`、`*`、`/` |
| **三元运算符** | 有三个操作数参与运算 | `? :`（后面课程讲解） |

#### 按功能分类

| 类别 | 说明 |
|------|------|
| **算术运算符** | ✅ 本次课程重点 |
| **赋值运算符** | ✅ 本次课程重点 |
| **比较运算符** | ✅ 本次课程重点 |
| **逻辑运算符** | ✅ 本次课程重点 |
| **位运算符** | ✅ 本次课程重点 |
| **三目运算符** | ✅ 本次课程重点 |
| **运算符优先级** | ✅ 本次课程重点 |

---

### 2. 算术运算符

| 运算符 | 名称 | 示例 | 结果 |
|--------|------|------|------|
| `+` | 加号 | `5 + 5` | `10` |
| `-` | 减号 | `5 - 3` | `2` |
| `*` | 乘号 | `5 * 3` | `15` |
| `/` | 除号 | `5 / 3` | `1`（不是 1.666...） |
| `%` | 取余/取模 | `5 % 3` | `2`（5 / 3 = 1 余 2） |
| `++` | 自增 | `++i` / `i++` | 一元运算符 |
| `--` | 自减 | `--i` / `i--` | 一元运算符 |

#### 基本运算示例

```java
int a = 10, b = 3;
System.out.println("10+3=" + (a + b));   // 13
System.out.println("10-3=" + (a - b));   // 7
System.out.println("10*3=" + (a * b));   // 30
System.out.println("10/3=" + (a / b));   // 3
System.out.println("10%3=" + (a % b));   // 1
```

#### 常见问题

##### ① 整数除法截断

两个整数相除，结果为整数，会**直接截断小数部分**，只保留整数。

```java
System.out.println(10 / 3);     // 3（截断小数）
System.out.println(10 / 3.0);   // 3.3333333333333335（有小数参与，结果为小数）
System.out.println(10.0 / 3);   // 3.3333333333333335
```

##### ② 0 不能做除数

整数除法中，除数为 0 会抛出异常：

```java
// System.out.println(3 / 0);    // ArithmeticException（算术异常，程序停止）
```

但浮点数除法中，除数为 0 有特殊结果：

```java
System.out.println(3 / 0.0);     // Infinity（无穷大）
System.out.println(3 / -0.0);    // -Infinity（负无穷大）
System.out.println(0.0 / 0.0);   // NaN（Not a Number，非数字）
```

##### ③ 取模运算 `%`

```java
System.out.println(10 % 3);    // 1
System.out.println(-10 % 3);   // -1（结果的符号与被除数相同）
```

> **取模规则**：`a % b` 的结果符号与 `a`（被除数）的符号一致。

##### ④ 自增 `++` 与自减 `--`

- `++` 表示这个数增加 1，`--` 表示这个数减少 1
- **符号在前**（`++i`）：先进行自增运算，再进行其他操作（如赋值）
- **符号在后**（`i++`）：先进行其他操作，再进行自增运算

```java
int i = 10;
int j = ++i;   // i 先自增变为 11，再将 11 赋值给 j
int k = i++;   // 先将 i（当前 11）赋值给 k，i 再自增变为 12

System.out.println(j);   // 11
System.out.println(k);   // 11
System.out.println(i);   // 12
```

---

### 3. 赋值运算符

| 运算符 | 名称 | 含义 | 等价于 |
|--------|------|------|--------|
| `=` | 赋值 | 把右边的值赋给左边 | — |
| `+=` | 加后赋值 | `a = a + b` | `a += b` |
| `-=` | 减后赋值 | `a = a - b` | `a -= b` |
| `*=` | 乘后赋值 | `a = a * b` | `a *= b` |
| `/=` | 除后赋值 | `a = a / b` | `a /= b` |
| `%=` | 取余后赋值 | `a = a % b` | `a %= b` |

#### 示例

```java
int x = 10;
x += 5;            // x = x + 5 → 15
System.out.println(x);

x *= 3;            // x = x * 3 → 45
System.out.println(x);
```

#### 复合运算符隐含强制类型转换

```java
byte a = 15;
// a = a + 6;      // ❌ 编译错误：a + 6 结果被提升为 int，赋值给 byte 需强制转换
a += 6;             // ✅ 复合赋值运算符隐含强制类型转换
```

> **重要**：复合赋值运算符（`+=`、`-=` 等）内部隐含了强制类型转换，不需要手动强转。

**完整代码 —— Demo03.java**

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo03
 * @description 赋值运算符
 * @create 2026/7/14
 */
public class Demo03 {
    public static void main(String[] args) {
        /*
            赋值运算符
            把=右边的值赋值给等号左边，比如 a=10
                =       赋值          a=b         把b的值赋值给a
                +=      加后赋值       a=a+b       把a+b的结果赋值给a
                -=      减后赋值       a=a-b       把a-b的结果赋值给a
                *=      乘后赋值       a=a*b       把a*b的结果赋值给a
                /=      除后赋值       a=a/b       把a/b的结果赋值给a
                %=      取余后赋值     a=a%b       把a%b的结果赋值给a
         */
        int x = 10;
        x += 5;
        System.out.println(x);   // 15
        x *= 3;
        System.out.println(x);   // 45  (x = x * 3)

        // 复合运算符隐含强制类型转换
        byte a = 15;
        // a = a + 6;  // 因为a+6的结果被提升为int类型，再赋值给byte类型的a需要强制类型转换
        a += 6;   // 复合赋值运算符 隐含就帮我们做了强制类型转换。
    }
}
```

---

### 4. 比较运算符

| 运算符 | 名称 | 示例 | 结果 |
|--------|------|------|------|
| `>` | 大于 | `5 > 3` | `true` |
| `<` | 小于 | `5 < 3` | `false` |
| `==` | 等于 | `5 == 3` | `false` |
| `>=` | 大于等于 | `5 >= 3` | `true` |
| `<=` | 小于等于 | `5 <= 3` | `false` |
| `!=` | 不等于 | `5 != 3` | `true` |

> **注意**：比较运算符的结果都是 `boolean` 类型（`true` 或 `false`）。
> 判断相等使用 `==`（双等号），**不能**写成 `=`（单等号是赋值）。

#### 浮点数精度陷阱

使用 `==` 比较浮点数时要特别小心，因为浮点数存在**精度误差**：

```java
double b1 = 0.1 + 0.2;
double b2 = 0.3;
System.out.println(b1 == b2);   // false！浮点数精度误差
System.out.println(b1);         // 0.30000000000000004
System.out.println(b2);         // 0.3
```

> `0.1 + 0.2` 在计算机中无法精确表示为 `0.3`，而是近似值 `0.30000000000000004`，因此 `==` 比较返回 `false`。

**解决方案**：使用 `printf` 格式化输出，或设置误差范围进行比较。

```java
System.out.printf("%.1f", b1);   // 输出 0.3（保留1位小数）
```

**完整代码 —— Demo04.java**

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo04
 * @description 比较运算符
 * @create 2026/7/14
 */
public class Demo04 {
    public static void main(String[] args) {
        /*
           >        大于          5>3     true
           <        小于          5<3     false
           ==       等于          5==3    false
           >=       大于等于       5>=3    true
           <=       小于等于       5<=3    false
           !=       不等于         5!=3    true
         */

        // 比较运算符 陷阱（精度陷阱）
        double b1 = 0.1 + 0.2;
        double b2 = 0.3;
        System.out.println(b1 == b2);     // false 浮点数精度误差
        System.out.println(b1);           // 0.30000000000000004
        System.out.println(b2);           // 0.3

        // 输出保留1位小数
        System.out.printf("%.1f", b1);    // 0.3
    }
}
```

---

### 5. 逻辑运算符

逻辑运算符操作的对象要么是**布尔表达式**，要么是**布尔值**。

| 运算符 | 名称 | 示例 | 结果 | 说明 |
|--------|------|------|------|------|
| `&` | 与 | `true & false` | `false` | 两边都为 `true` 结果才为 `true` |
| `\|` | 或 | `true \| false` | `true` | 两边都为 `false` 结果才为 `false` |
| `!` | 非 | `!true` | `false` | 取反（单目运算符） |
| `&&` | 短路与 | `true && false` | `false` | 左边为 `false` 时右边**不执行** |
| `\|\|` | 短路或 | `true \|\| false` | `true` | 左边为 `true` 时右边**不执行** |
| `^` | 异或 | `true ^ false` | `true` | 两边相同返回 `false`，不同返回 `true` |

#### ① `&` 与（AND）

符号左右两侧的布尔表达式结果如果都是 `true`，则运算结果为 `true`，否则为 `false`。

```java
System.out.println(true & true);    // true
System.out.println(true & false);   // false
System.out.println(false & true);   // false
System.out.println(false & false);  // false
```

#### ② `|` 或（OR）

符号左右两侧的布尔表达式结果如果都是 `false`，则运算结果为 `false`，否则为 `true`。

```java
System.out.println(true | true);    // true
System.out.println(true | false);   // true
System.out.println(false | true);   // true
System.out.println(false | false);  // false
```

#### ③ `!` 非（NOT）

取反，单目运算符。符号右侧的布尔表达式结果为 `true` 时运算后为 `false`，反之亦然。

```java
System.out.println(!true);    // false
System.out.println(!false);   // true
```

#### ④ `&&` 短路与（Short-circuit AND）

作用与 `&` 相同，但具有**短路特性**：如果符号左边为 `false`，右边**不再运算**，直接返回 `false`。

```java
System.out.println(true && true);    // true
System.out.println(true && false);   // false
System.out.println(false && true);   // false（右边不执行）
System.out.println(false && false);  // false（右边不执行）
```

#### ⑤ `||` 短路或（Short-circuit OR）

作用与 `|` 相同，但具有**短路特性**：如果符号左边为 `true`，右边**不再运算**，直接返回 `true`。

```java
System.out.println(true || true);    // true（右边不执行）
System.out.println(true || false);   // true（右边不执行）
System.out.println(false || true);   // true
System.out.println(false || false);  // false
```

#### ⑥ `^` 异或（XOR）

符号左右两侧的布尔表达式如果相同，返回 `false`；不同返回 `true`。

```java
System.out.println(true ^ true);    // false
System.out.println(true ^ false);   // true
System.out.println(false ^ true);   // true
System.out.println(false ^ false);  // false
```

**完整代码 —— Demo05.java**

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo05
 * @description 逻辑运算符
 * @create 2026/7/14
 */
public class Demo05 {
    public static void main(String[] args) {
        /*
        逻辑运算符 操作的数 要么是布尔表达式  要么是布尔值。
            &       与           true&false      false
            |       或           true|false      true
            !       非           !true           false
            &&      短路与        true&&false     false
            ||      短路或        true||false     true
            ^       异或          true^false      true
         */
        // & 与：符号左右两侧的布尔表达式结果如果都是true，则运算结果为true，否则就是false
        System.out.println(true & true);   // true
        System.out.println(true & false);  // false
        System.out.println(false & true);  // false
        System.out.println(false & false); // false

        // | 或：符号左右两侧的布尔表达式结果如果都是false，则运算结果为false，否则就是true
        System.out.println(true | true);   // true
        System.out.println(true | false);  // true
        System.out.println(false | true);  // true
        System.out.println(false | false); // false

        // && 短路与，作用和&相同，只不过，符号左边如果是false，右边就不运算了，直接返回false
        System.out.println(true && true);   // true
        System.out.println(true && false);  // false
        System.out.println(false && true);  // false
        System.out.println(false && false); // false

        // || 短路或，作用和|相同，只不过，符号左边如果是true，右边就不运算了，直接返回true
        System.out.println(true || true);   // true
        System.out.println(true || false);  // true
        System.out.println(false || true);  // true
        System.out.println(false || false); // false

        // ! 非 也就是取反，它也是单目运算符，符号右侧的布尔表达式的结果如果是true，运算后就是false
        System.out.println(!true);   // false
        System.out.println(!false);  // true

        // ^ 异或 符号左右两侧的布尔表达式如果相同，就返回false，不同返回true
        System.out.println(true ^ true);    // false
        System.out.println(true ^ false);   // true
        System.out.println(false ^ true);   // true
        System.out.println(false ^ false);  // false
    }
}
```

---

### 6. 位运算符

> 位运算符用来直接操作**整型**（`byte`/`short`/`int`/`long`/`char`）的二进制位，性能极高，在底层编程、权限控制、编码算法中使用较多。

| 运算符 | 名称 | 示例 | 说明 |
|--------|------|------|------|
| `&` | 按位与 | `5 & 3` | 对应位同时为 `1` 时结果为 `1`，否则为 `0` |
| `|` | 按位或 | `5 | 3` | 对应位同时为 `0` 时结果为 `0`，否则为 `1` |
| `^` | 按位异或 | `5 ^ 3` | 对应位相同为 `0`，不同为 `1` |
| `~` | 按位取反 | `~5` | 单目运算符，`0` 变 `1`，`1` 变 `0` |
| `<<` | 按位左移 | `5 << 1` | 向左移动指定位数，空位补 `0`，相当于 **×2ⁿ** |
| `>>` | 按位右移 | `5 >> 1` | 向右移动指定位数，空位补**符号位**，相当于 **÷2ⁿ**（向下取整） |
| `>>>` | 无符号右移 | `5 >>> 1` | 向右移动指定位数，空位补 `0`，负数会得到大正数 |

#### ① `&` 按位与

符号左右两边的数的每个二进制位，如果同时为 `1`，则运算结果为 `1`，否则为 `0`，最后把二进制数转换为十进制数。

```
  0101   ← 5
& 0011   ← 3
--------
  0001   → 1
```

```java
System.out.println(5 & 3);   // 1
```

#### ② `|` 按位或

符号左右两边的数的每个二进制位，如果同时为 `0`，则运算结果为 `0`，否则为 `1`，最后把二进制数转换为十进制数。

```
  0101   ← 5
| 0011   ← 3
--------
  0111   → 7
```

```java
System.out.println(5 | 3);   // 7
```

#### ③ `^` 按位异或

符号左右两边的数的每个二进制位，如果相同则为 `0`，不同则为 `1`，最后把二进制数转换为十进制数。

```
  0101   ← 5
^ 0011   ← 3
--------
  0110   → 6
```

```java
System.out.println(5 ^ 3);   // 6
```

#### ④ `~` 按位取反

单目运算符，符号右边的数的二进制位，如果为 `0` 则运算结果为 `1`，如果为 `1` 则运算结果为 `0`。

```
~ 0000 0101   ← 5（8位二进制）
------------
  1111 1010   → -6
```

```java
System.out.println(~5);   // -6
```

> **注意**：`~5` 的结果是 `-6`，因为计算机使用**补码**表示负数。

#### ⑤ `<<` 按位左移

把符号左边的数的二进制位，向左移动符号右边指定的位数，空出来的位置补 `0`。

```
  0101       ← 5
<<   1
--------
  1010       → 10（相当于 5 × 2¹ = 10）
```

```java
System.out.println(5 << 3);   // 40（相当于 5 × 2³ = 40）
```

> **左移规律**：左移 n 位相当于乘以 2ⁿ（在不溢出的前提下）。

#### ⑥ `>>` 按位右移

把符号左边的数的二进制位，向右移动符号右边指定的位数，空出来的位置补**符号位**的值。

> 二进制最左侧为最高位（符号位）：`0` 表示正数，`1` 表示负数。

```
  0101       ← 5
>>   1
--------
  0010       → 2（相当于 5 ÷ 2¹ = 2，向下取整）
```

```java
System.out.println(5 >> 3);   // 0（相当于 5 ÷ 2³ = 0，向下取整）
```

> **右移规律**：右移 n 位相当于除以 2ⁿ（向下取整）。

#### ⑦ `>>>` 无符号右移

把符号左边的数的二进制位，向右移动符号右边指定的位数，空出来的位置补 `0`。对负数操作后会得到大正数。

```
  1111 1011   ← -5（8位表示）
>>>      1
-----------
  0111 1101   → 正数
```

```java
System.out.println(-5 >>> 1);   // 2147483645（大正数）
```

**位运算总结：**

| 运算 | 效果 | 规律 |
|------|------|------|
| 左移 `<<` | 高位丢失，低位补 0 | 相当于 **×2ⁿ** |
| 右移 `>>` | 低位丢失，高位补符号位 | 相当于 **÷2ⁿ**（向下取整） |
| 无符号右移 `>>>`| 低位丢失，高位补 0 | 负数会变为大正数 |

#### 随堂练习：位运算

运行以下代码，查看结果，并验证位运算规律：

```java
System.out.println(15 >> 3);     // ?
System.out.println(66 << 2);     // ?
System.out.println(75 & 86);     // ?
System.out.println(63 | 36);     // ?
System.out.println(-128 >>> 3);  // ?
```

**完整代码 —— Demo06.java**

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo06
 * @description 位运算符
 * @create 2026/7/14
 */
public class Demo06 {
    /*
        位运算符是用来直接操作 整型（byte/short/int/long/char）的二进制位，
        性能极高，在底层编程、权限控制、编码算法中使用的比较多

        &           按位与         5&3             0101 & 0011  = 0001
        |           按位或         5|3             0101 | 0011  = 0111
        ^           按位异或       5^3             0101 ^ 0011  = 0110
        ~           按位取反       ~5              ~0101 = 1010
        <<          按位左移       5<<1            0101 << 1 = 1010
        >>          按位右移       5>>1            0101 >> 1 = 0010
        >>>         无符号右移     5>>>1           0101 >>> 1 = 0010
     */
    public static void main(String[] args) {
        // 按位与 &：对应位同时为1则结果为1，否则为0
        System.out.println(5 & 3);   // 1

        // 按位或 |：对应位同时为0则结果为0，否则为1
        System.out.println(5 | 3);   // 7

        // 按位异或 ^：对应位相同为0，不同为1
        System.out.println(5 ^ 3);   // 6

        // 按位取反 ~：单目，0变1，1变0
        System.out.println(~5);      // -6

        // 按位左移 <<：向左移动，低位补0，相当于 ×2ⁿ
        System.out.println(5 << 3);  // 40（5 × 2³ = 40）

        // 按位右移 >>：向右移动，高位补符号位，相当于 ÷2ⁿ（向下取整）
        System.out.println(5 >> 3);  // 0

        // 无符号右移 >>>：向右移动，高位补0，负数变为大正数
        System.out.println(-5 >>> 1); // 2147483645

        /*
            左移：高位丢失，低位补0，相当于 ×2
            右移：低位丢失，高位补符号位，相当于 ÷2   并且向下取整
            无符号右移：低位丢失，高位补0，对负数会得到大正数
         */
    }
}
```

---

### 7. 三目运算符（三元运算符）

三目运算符是 Java 中唯一一个需要**三个操作数**的运算符。

**语法格式：**

```java
布尔表达式 ? 表达式1 : 表达式2
```

**执行逻辑：**
- 如果布尔表达式结果为 `true`，执行（返回）**表达式1**
- 如果布尔表达式结果为 `false`，执行（返回）**表达式2**

#### 示例

```java
System.out.println(15 > 8 ? "hello" : "哈哈哈哈");   // hello
System.out.println(15 > 8 ? 6 : "哈哈哈哈");          // 6（返回 int）
```

```java
int x = 10, y = 6;
System.out.println(x > y ? "x>y" : "x<=y");  // x>y
System.out.println(x > y ? "x>y" : y);       // x>y（返回 String）
```

#### 三目运算符 vs if-else 选择原则

| 场景 | 推荐使用 |
|------|---------|
| 简单的二选一赋值 | 三目运算符 |
| 复杂多个分支逻辑 | `if-else` |
| 嵌套超过 2 层 | `if-else`（三目嵌套可读性差） |
| 需要执行某段代码而不是返回一个值 | `if-else` |

**完整代码 —— Demo07.java**

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo07
 * @description 三目运算符 三元运算符
 * @create 2026/7/14
 */
public class Demo07 {
    public static void main(String[] args) {
        /*
            三目运算符
            布尔表达式?表达式1:表达式2
            布尔表达式的结果如果是true，就执行表达式1，否则执行表达式2
         */
        System.out.println(15 > 8 ? "hello" : "哈哈哈哈");
        System.out.println(15 > 8 ? 6 : "哈哈哈哈");
        int x = 10, y = 6;
        System.out.println(x > y ? "x>y" : "x<=y");
        System.out.println(x > y ? "x>y" : y);

        /*
            什么时候使用三元运算符，什么时候使用if...else
            如果是简单的二选一赋值 → 三元运算符
            复杂多个分支逻辑 → if...else
            嵌套超过2层 → if...else
            需要执行某段代码而不是返回一个值 → if...else
         */
    }
}
```

---

### 8. 运算符优先级

运算符优先级决定了表达式中的计算顺序。优先级越高，越先被计算。

| 优先级 | 运算符 | 说明 |
|--------|--------|------|
| 1（最高） | `()` `.` `[]` | 括号、成员访问、数组下标 |
| 2 | `++` `--` `+`（正）`-`（负） | 自增、自减、正负号 |
| 3 | `*` `/` `%` | 乘、除、取余 |
| 4 | `+` `-` | 加、减 |
| 5 | `<<` `>>` `>>>` | 移位运算 |
| 6 | `<` `>` `<=` `>=` | 比较（instanceof） |
| 7 | `==` `!=` | 等于、不等于 |
| 8 | `&` | 按位与 |
| 9 | `^` | 按位异或 |
| 10 | `\|` | 按位或 |
| 11 | `&&` | 短路与 |
| 12 | `\|\|` | 短路或 |
| 13 | `?:` | 三目运算符 |
| 14（最低） | `=` `+=` `-=` `*=` `/=` `%=` | 赋值运算符 |

> **记忆口诀**：括号最高，单目第二，乘除第三，加减第四，移位第五，比较第六，等于第七，位逻辑（`&` `^` `|`）第八到十，短路逻辑（`&&` `||`）十一十二，三目十三，赋值最后。
>
> **最佳实践**：当不确定优先级时，使用 `()` 明确指定计算顺序，提高代码可读性。

**完整代码 —— Demo08.java**

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo08
 * @description 运算符优先级
 * @create 2026/7/14
 */
public class Demo08 {
    public static void main(String[] args) {
        /*
            运算符优先级决定了表达式中的计算顺序
            最高优先级：() .  []
            2   ++  --  +正数 -负数
            3   *   /   %
            4   +   -
            5   <<  >>  >>>
            6   <   >   <=  >=
            7   ==  !=
            8   &
            9   ^
            10  |
            11  &&
            12  ||
            13  ?:  三元运算符
            14  各种赋值 =  +=  -=
         */
    }
}
```

结合 if-else 分支结构与算术运算符，完成以下练习：

### 练习 1：判断奇偶数

```java
int i1 = 7;
if (i1 % 2 == 0) {
    System.out.println("偶数");
} else {
    System.out.println("奇数");
}
```

> **思路**：奇数不能被 2 整除（`% 2 == 1`），偶数能被 2 整除（`% 2 == 0`）。

### 练习 2：判断倍数关系

```java
int a1 = 10, b1 = 5;
if (a1 % b1 == 0) {
    System.out.println("是倍数");
} else {
    System.out.println("不是倍数");
}
```

> **思路**：`a1 % b1 == 0` 说明 `a1` 能被 `b1` 整除，即 `a1` 是 `b1` 的倍数。

### 练习 3：判断正数、负数还是 0

```java
int i2 = 10;
if (i2 > 0) {
    System.out.println("正数");
} else if (i2 < 0) {
    System.out.println("负数");
} else {
    System.out.println("0");
}
```

> **思路**：使用 `if - else if - else` 进行多分支判断。

### 练习 4：分钟数转换

将总分钟数（如 130 分钟）转换为几小时几分钟，并判断是否超过 1 小时。

```java
int time = 130;
int h = time / 60;     // 整除获取小时数
int m = time % 60;     // 取余获取剩余分钟数
System.out.println(h + "小时" + m + "分钟");
if (h > 1) {
    System.out.println("超过1小时");
} else {
    System.out.println("不超过1小时");
}
```

> **思路**：`小时 = 总分钟 / 60`（整除），`剩余分钟 = 总分钟 % 60`（取余）。

### 练习 5：成绩等级判定

定义一个成绩变量 `score`，使用 `if - else if - else` 结合逻辑运算符 `&&` 实现多级判断：

| 分数范围 | 等级 |
|---------|------|
| 90 ≤ score ≤ 100 | 优秀 |
| 80 ≤ score < 90 | 良好 |
| 70 ≤ score < 80 | 中等 |
| 60 ≤ score < 70 | 及格 |
| 0 ≤ score < 60 | 不及格 |
| 其他 | 分数错误 |

```java
double score = 85.3;
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("成绩错误");
}
```

> **知识点**：综合运用 `if-else` 语句 + 比较运算符 + 逻辑运算符 `&&`。

---

## 四、完整代码汇总

### Demo01.java — 流程控制

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo01
 * @description 流程控制
 * @create 2026/7/14
 */
public class Demo01 {
    public static void main(String[] args) {
        System.out.println("前面有n多代码...............");
        int a = 15;
        if (a > 0) {
            System.out.println("正数");
        } else {
            System.out.println("负数");
        }
        System.out.println("后面有n多代码...............");
    }
}
```

### Demo02.java — 算术运算符 + 综合练习

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo02
 * @description Java运算符
 * @create 2026/7/14
 */
public class Demo02 {
    public static void main(String[] args) {
        // 1. 算术运算符
        int a = 10, b = 3;
        System.out.println("10+3=" + (a + b));
        System.out.println("10-3=" + (a - b));
        System.out.println("10*3=" + (a * b));
        System.out.println("10/3=" + (a / b));
        System.out.println("10%3=" + (a % b));

        // 整数除法截断
        System.out.println(10 / 3);     // 3
        System.out.println(10 / 3.0);   // 3.3333...

        // 0 不能做除数
        System.out.println(3 / 0.0);    // Infinity
        System.out.println(3 / -0.0);   // -Infinity
        System.out.println(0.0 / 0.0);  // NaN

        // 取模运算
        System.out.println(10 % 3);     // 1
        System.out.println(-10 % 3);    // -1

        // 自增自减
        int i = 10;
        int j = ++i;   // 11
        int k = i++;   // 11（赋值后再自增）
        System.out.println(j);
        System.out.println(k);
        System.out.println(i);   // 12

        // 练习1：判断奇偶数
        int i1 = 7;
        if (i1 % 2 == 0) {
            System.out.println("偶数");
        } else {
            System.out.println("奇数");
        }

        // 练习2：判断倍数
        int a1 = 10, b1 = 5;
        if (a1 % b1 == 0) {
            System.out.println("是倍数");
        } else {
            System.out.println("不是倍数");
        }

        // 练习3：判断正数/负数/0
        int i2 = 10;
        if (i2 > 0) {
            System.out.println("正数");
        } else if (i2 < 0) {
            System.out.println("负数");
        } else {
            System.out.println("0");
        }

        // 练习4：分钟转换
        int time = 130;
        int h = time / 60;
        int m = time % 60;
        System.out.println(h + "小时" + m + "分钟");
        if (h > 1) {
            System.out.println("超过1小时");
        } else {
            System.out.println("不超过1小时");
        }
    }
}
```

### Demo03.java — 赋值运算符

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo03
 * @description 赋值运算符
 * @create 2026/7/14
 */
public class Demo03 {
    public static void main(String[] args) {
        int x = 10;
        x += 5;
        System.out.println(x);   // 15
        x *= 3;
        System.out.println(x);   // 45

        // 复合运算符隐含强制类型转换
        byte a = 15;
        a += 6;   // 隐含强制类型转换
    }
}
```

### Demo04.java — 比较运算符 + 浮点数精度陷阱

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo04
 * @description 比较运算符
 * @create 2026/7/14
 */
public class Demo04 {
    public static void main(String[] args) {
        /*
           >        大于          5>3     true
           <        小于          5<3     false
           ==       等于          5==3    false
           >=       大于等于       5>=3    true
           <=       小于等于       5<=3    false
           !=       不等于         5!=3    true
         */

        // 比较运算符 陷阱（精度陷阱）
        double b1 = 0.1 + 0.2;
        double b2 = 0.3;
        System.out.println(b1 == b2);     // false 浮点数精度误差
        System.out.println(b1);           // 0.30000000000000004
        System.out.println(b2);           // 0.3

        // 输出保留1位小数
        System.out.printf("%.1f", b1);    // 0.3
    }
}
```

### Demo05.java — 逻辑运算符 + 成绩等级练习

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo05
 * @description 逻辑运算符
 * @create 2026/7/14
 */
public class Demo05 {
    public static void main(String[] args) {
        /*
        逻辑运算符 操作的数 要么是布尔表达式  要么是布尔值。
            &       与           true&false      false
            |       或           true|false      true
            !       非           !true           false
            &&      短路与        true&&false     false
            ||      短路或        true||false     true
            ^       异或          true^false      true
         */
        // & 与
        System.out.println(true & true);   // true
        System.out.println(true & false);  // false
        System.out.println(false & true);  // false
        System.out.println(false & false); // false

        // | 或
        System.out.println(true | true);   // true
        System.out.println(true | false);  // true
        System.out.println(false | true);  // true
        System.out.println(false | false); // false

        // && 短路与（左边为false时右边不执行）
        System.out.println(true && true);   // true
        System.out.println(true && false);  // false
        System.out.println(false && true);  // false
        System.out.println(false && false); // false

        // || 短路或（左边为true时右边不执行）
        System.out.println(true || true);   // true
        System.out.println(true || false);  // true
        System.out.println(false || true);  // true
        System.out.println(false || false); // false

        // ! 非（取反）
        System.out.println(!true);   // false
        System.out.println(!false);  // true

        // ^ 异或（相同为false，不同为true）
        System.out.println(true ^ true);    // false
        System.out.println(true ^ false);   // true
        System.out.println(false ^ true);   // true
        System.out.println(false ^ false);  // false

        /*
            课堂练习题：
                定义一个成绩变量 score，判断：
                如果score大于等于90并且小于等于100，就输出优秀
                如果score大于等于80并且小于90，就输出良好
                如果score大于等于70并且小于80，就输出中等
                如果score大于等于60并且小于70，就输出及格
                如果score大于等于0并且小于60，就输出不及格
                在此范围外的任何值，都输出 分数错误。
         */
        double score = 85.3;
        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("成绩错误");
        }
    }
}
```

### Demo06.java — 位运算符

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo06
 * @description 位运算符
 * @create 2026/7/14
 */
public class Demo06 {
    /*
        位运算符是用来直接操作 整型（byte/short/int/long/char）的二进制位，
        性能极高，在底层编程、权限控制、编码算法中使用的比较多

        &           按位与         5&3             0101 & 0011  = 0001
        |           按位或         5|3             0101 | 0011  = 0111
        ^           按位异或       5^3             0101 ^ 0011  = 0110
        ~           按位取反       ~5              ~0101 = 1010
        <<          按位左移       5<<1            0101 << 1 = 1010
        >>          按位右移       5>>1            0101 >> 1 = 0010
        >>>         无符号右移     5>>>1           0101 >>> 1 = 0010
     */
    public static void main(String[] args) {
        // 按位与 &：对应位同时为1则结果为1，否则为0
        System.out.println(5 & 3);   // 1

        // 按位或 |：对应位同时为0则结果为0，否则为1
        System.out.println(5 | 3);   // 7

        // 按位异或 ^：对应位相同为0，不同为1
        System.out.println(5 ^ 3);   // 6

        // 按位取反 ~：单目，0变1，1变0
        System.out.println(~5);      // -6

        // 按位左移 <<：向左移动，低位补0，相当于 ×2ⁿ
        System.out.println(5 << 3);  // 40

        // 按位右移 >>：向右移动，高位补符号位，相当于 ÷2ⁿ（向下取整）
        System.out.println(5 >> 3);  // 0

        // 无符号右移 >>>：向右移动，高位补0，负数变为大正数
        System.out.println(-5 >>> 1); // 2147483645

        /*
            左移：高位丢失，低位补0，相当于 ×2
            右移：低位丢失，高位补符号位，相当于 ÷2   并且向下取整
            无符号右移：低位丢失，高位补0，对负数会得到大正数
         */
        /*
            编程运行，查看结果
            15>>3
            66<<2
            75&86
            63|36
            -128>>>3
         */
    }
}
```

### Demo07.java — 三目运算符

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo07
 * @description 三目运算符 三元运算符
 * @create 2026/7/14
 */
public class Demo07 {
    public static void main(String[] args) {
        /*
            三目运算符
            布尔表达式?表达式1:表达式2
            布尔表达式的结果如果是true，就执行表达式1，否则执行表达式2
         */
        System.out.println(15 > 8 ? "hello" : "哈哈哈哈");
        System.out.println(15 > 8 ? 6 : "哈哈哈哈");
        int x = 10, y = 6;
        System.out.println(x > y ? "x>y" : "x<=y");
        System.out.println(x > y ? "x>y" : y);

        /*
            什么时候使用三元运算符，什么时候使用if...else
            如果是简单的二选一赋值 → 三元运算符
            复杂多个分支逻辑 → if...else
            嵌套超过2层 → if...else
            需要执行某段代码而不是返回一个值 → if...else
         */
    }
}
```

### Demo08.java — 运算符优先级

```java
/**
 * @author WanJl
 * @version 1.0
 * @title Demo08
 * @description 运算符优先级
 * @create 2026/7/14
 */
public class Demo08 {
    public static void main(String[] args) {
        /*
            运算符优先级决定了表达式中的计算顺序
            最高优先级：() .  []
            2   ++  --  +正数 -负数
            3   *   /   %
            4   +   -
            5   <<  >>  >>>
            6   <   >   <=  >=
            7   ==  !=
            8   &
            9   ^
            10  |
            11  &&
            12  ||
            13  ?:  三元运算符
            14  各种赋值 =  +=  -=
         */
    }
}
```

---

## 五、随堂练习要点

1. **if-else 分支结构**：`if (布尔表达式) { ... } else { ... }`
2. **算术运算符**：`+`、`-`、`*`、`/`、`%`、`++`、`--`
3. **整数除法截断**：两个整数相除结果直接截断小数，不会四舍五入
4. **0 不能做除数**：整数除 0 会抛异常，浮点数除 0 得 `Infinity` / `NaN`
5. **取模运算**：`%` 获取余数，结果符号与被除数相同
6. **自增 `++` / 自减 `--`**：符号在前先运算，符号在后先赋值
7. **赋值运算符**：`=`、`+=`、`-=`、`*=`、`/=`、`%=`
8. **复合赋值运算符隐含强制类型转换**
9. **比较运算符**：`>`、`<`、`==`、`>=`、`<=`、`!=`，结果都是 `boolean` 类型
10. **条件判断中比较相等使用 `==`**，不要写成 `=`
11. **浮点数精度陷阱**：`0.1 + 0.2 == 0.3` 为 `false`，浮点数不能直接用 `==` 比较
12. **解决方案**：使用 `printf` 格式化输出，或设置误差范围
13. 掌握 `if - else if - else` 多分支结构
14. 学会利用 `%` 取模运算判断奇偶、倍数关系
15. 学会利用 `/` 整除和 `%` 取余进行单位换算（分钟 → 小时 + 分钟）
16. **逻辑运算符**：`&`（与）、`|`（或）、`!`（非）、`&&`（短路与）、`||`（短路或）、`^`（异或）
17. **`&` vs `&&`**：`&` 两边都要计算，`&&` 左边为 `false` 时右边不执行（短路）
18. **`|` vs `||`**：`|` 两边都要计算，`||` 左边为 `true` 时右边不执行（短路）
19. **`^` 异或**：两边相同为 `false`，不同为 `true`
20. **`!` 非**：单目运算符，取反操作
21. **位运算符**：`&`（按位与）、`|`（按位或）、`^`（按位异或）、`~`（按位取反）、`<<`（左移）、`>>`（右移）、`>>>`（无符号右移）
22. **左移 `<<`**：高位丢失，低位补 0，相当于 **×2ⁿ**
23. **右移 `>>`**：低位丢失，高位补符号位，相当于 **÷2ⁿ**（向下取整）
24. **无符号右移 `>>>`**：低位丢失，高位补 0，负数会变为大正数
25. **成绩等级练习**：综合运用 `if-else if-else` + 比较运算符 + 逻辑运算符 `&&` 实现多范围判断
26. **位运算随堂练习**：计算 `15>>3`、`66<<2`、`75&86`、`63|36`、`-128>>>3` 的运行结果
27. **三目运算符**：`布尔表达式 ? 表达式1 : 表达式2`，简化二选一赋值
28. **三目 vs if-else**：简单二选一赋值用三目，复杂多分支用 `if-else`
29. **运算符优先级**：牢记 `()` 最高、赋值最低，不确定时用 `()` 明确顺序

---

## 六、拓展阅读

| 概念 | 说明 |
|------|------|
| **布尔表达式** | 运算结果为 `true` 或 `false` 的表达式 |
| **算术异常** | `ArithmeticException`，整数除以 0 时抛出 |
| **`Infinity`** | 浮点数除 0 的结果，表示无穷大 |
| **`NaN`** | Not a Number，`0.0 / 0.0` 的结果 |
| **复合赋值运算符** | 如 `+=`、`-=` 等，自带隐式强制类型转换 |
| **短路特性** | `&&` 左边为 `false` 或 `||` 左边为 `true` 时，右边不再运算 |
| **浮点数精度** | 浮点数在计算机中采用 IEEE 754 标准存储，存在精度误差，避免直接用 `==` 比较 |
| **补码** | 计算机使用补码表示负数，正数的补码 = 原码，负数的补码 = 原码取反 + 1 |
| **按位与 `&` vs 逻辑与 `&`** | 按位与操作整型的二进制位，逻辑与操作布尔值 |
| **位运算性能** | 位运算直接操作二进制位，比算术运算性能更高，常用于底层编程 |
| **三目运算符** | 唯一的三元运算符，格式 `? :`，适合简单的二选一赋值 |
| **运算符优先级** | 优先级高的运算符先执行，建议用 `()` 明确计算顺序 |
| **短路逻辑 vs 非短路逻辑** | `&&`/`||` 有短路效果，`&`/`|` 无短路效果，性能上短路更优 |
