# 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`）。
> 判断相等使用 `==`（双等号），**不能**写成 `=`（单等号是赋值）。

**完整代码 —— 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
         */
    }
}
```

---

## 三、综合练习（Demo02）

结合 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`（取余）。

---

## 四、完整代码汇总

### 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
         */
    }
}
```

---

## 五、随堂练习要点

1. **if-else 分支结构**：`if (布尔表达式) { ... } else { ... }`
2. **算术运算符**：`+`、`-`、`*`、`/`、`%`、`++`、`--`
3. **整数除法截断**：两个整数相除结果直接截断小数，不会四舍五入
4. **0 不能做除数**：整数除 0 会抛异常，浮点数除 0 得 `Infinity` / `NaN`
5. **取模运算**：`%` 获取余数，结果符号与被除数相同
6. **自增 `++` / 自减 `--`**：符号在前先运算，符号在后先赋值
7. **赋值运算符**：`=`、`+=`、`-=`、`*=`、`/=`、`%=`
8. **复合赋值运算符隐含强制类型转换**
9. **比较运算符**：`>`、`<`、`==`、`>=`、`<=`、`!=`，结果都是 `boolean` 类型
10. **条件判断中比较相等使用 `==`**，不要写成 `=`
11. 掌握 `if - else if - else` 多分支结构
12. 学会利用 `%` 取模运算判断奇偶、倍数关系
13. 学会利用 `/` 整除和 `%` 取余进行单位换算（分钟 → 小时 + 分钟）

---

## 六、拓展阅读

| 概念 | 说明 |
|------|------|
| **布尔表达式** | 运算结果为 `true` 或 `false` 的表达式 |
| **算术异常** | `ArithmeticException`，整数除以 0 时抛出 |
| **`Infinity`** | 浮点数除 0 的结果，表示无穷大 |
| **`NaN`** | Not a Number，`0.0 / 0.0` 的结果 |
| **复合赋值运算符** | 如 `+=`、`-=` 等，自带隐式强制类型转换 |