# JavaSE 基础 — Day06 笔记

> **日期**：2026-07-20  
> **项目**：`c260720`  
> **作者**：WanJL

---

## 一、面向对象基础（Object-Oriented Programming）

### 1. 面向对象思想概述

| 对比维度 | 面向对象（Java） | 面向过程（C） |
|---------|----------------|-------------|
| **思想核心** | 以对象为中心，通过指挥对象实现操作 | 以过程为中心，功能都由自己实现 |
| **特点** | 更符合人类思维习惯，易于维护和扩展 | 按步骤一步步执行，代码直接 |
| **关键词** | 类、对象、封装、继承、多态 | 函数、过程、步骤 |

> **Java 中一切皆为对象**，是一种以对象为中心的编程思想。

### 2. 类（Class）与对象（Object）的关系

**类比**：设计图纸（类）与成品（对象）的关系。

- **1 套设计图纸** → 可以做出 **多个成品**
- **1 个类** → 可以创建 **多个对象**
- **类** 是模板、蓝图、设计图纸、规则、要求，描述一个对象的所有属性和操作
- **对象** 是能够看得到摸得着的真实存在的实体

> **类的定义**：
> 类是现实生活中一类具有相同属性和行为的事物的抽象。

### 3. 类的定义格式

```java
修饰符 class 类名 {
    数据类型 属性名;          // 成员变量（属性）

    修饰符 返回值类型 方法名(){  // 成员方法（行为）

    }
}
```

**类的成员组成**：

| 成员 | 对应概念 | 表现形式 |
|-----|---------|---------|
| 属性（Property） | 事物特征 | 成员变量（类中方法外的变量） |
| 行为（Behavior） | 事物操作 | 成员方法（去掉 `static` 关键字的方法） |

### 4. 创建对象与使用成员

**创建对象格式**：

```java
类名 对象名 = new 类名();
```

**调用成员格式**：

```java
对象名.成员变量;     // 访问属性
对象名.成员方法();   // 调用方法
```

### 5. 成员变量（Member Variable）与局部变量（Local Variable）区别

**文件**：`Demo03.java`

| 对比维度 | 成员变量 | 局部变量 |
|---------|---------|---------|
| **类中位置** | 定义在【类内部，方法外部】 | 定义在【方法内部】（方法的参数也属于局部变量） |
| **内存位置** | 堆内存（Heap）中 | 栈内存（Stack）中 |
| **生命周期** | 随着对象的存在而存在，随着对象的消失而消失 | 随着方法的调用而存在，随着方法的调用结束而消失 |
| **初始化值** | 有默认初始化值（整数→0，引用类型→`null`） | 没有默认初始化值，必须先定义赋值才能使用 |

```java
public class Student {
    String name;  // 成员变量 —— 在类内部、方法外部
    int age;      // 成员变量

    public void study() {
        String msg = "学习中";  // 局部变量 —— 在方法内部
        System.out.println(msg);
    }
}
```

---

### 6. 对象引用与内存共享

**文件**：`Demo03.java`

当多个引用变量指向 **同一个内存地址** 时，它们操作的是同一块内存空间。任何一个引用修改了数据，其他引用获取到的都是修改后的数据。

```java
public class Demo03 {
    public static void main(String[] args) {
        Teacher t1 = new Teacher();  // t1 引用指向 0x1024
        t1.name = "张三";
        t1.sleep();                  // 输出：张三在休息....

        Teacher t2 = t1;             // t2 也指向 0x1024（与 t1 同一对象）
        t2.name = "李四";
        t2.id = "1001";
        t1.sleep();                  // 输出：1001李四在休息....（已被 t2 修改）
    }
}
```

> **图解**：`t1` 和 `t2` 是两个不同的引用变量，但存储的是同一个对象的地址 `0x1024`。通过 `t2.name = "李四"` 修改后，`t1.name` 也变成"李四"，因为它们是同一块内存。

---

### 7. 对象数组（Object Array）

**文件**：`Test01.java`, `Test02.java`

对象数组的数组元素类型是**类名**，存储的是对象的**引用地址**（而非对象本身）。

```java
// 定义一个可以存储 10 个 BaiLu 对象引用的数组
BaiLu[] bailus = new BaiLu[10];
// 定义一个可以存储 10 个 Bike 对象引用的数组
Bike[] bikes = new Bike[10];
```

**创建对象并存入数组的标准操作**：

```java
// 1. 先创建对象
BaiLu b = new BaiLu();
// 2. 调用对象方法
b.up("青天");
// 3. 将对象引用（地址值）存入数组
bailus[i] = b;
```

> **对比基本类型数组**：`int[] arr = new int[10]` 存的是数值；对象数组存的是引用（地址）。

---

## 二、代码实战：类与对象完整示例

### 1. Student 学生类

**文件**：`Demo02.java` / `Student.java`

**定义类（Student.java）**：

```java
public class Student {
    String name;   // 成员变量：姓名
    int age;       // 成员变量：年龄

    // 成员方法：学习
    public void study() {
        System.out.println("姓名：" + name + "，年龄：" + age + ",在学习");
    }
}
```

**使用对象（Demo02.java）**：

```java
public class Demo02 {
    public static void main(String[] args) {
        // 创建第一个学生对象
        Student s = new Student();
        s.name = "张三";
        s.age = 25;
        s.study();

        // 创建第二个学生对象
        Student s1 = new Student();
        s1.name = "李四";
        s1.age = 20;
        s1.study();
    }
}
```

> **要点**：同一个 `Student` 类可以创建多个对象，每个对象拥有自己独立的属性值。

---

### 2. Dog 狗类

**文件**：`Dog.java`

```java
public class Dog {
    double weight;  // 成员变量：体重
    double height;  // 成员变量：身高

    public static void main(String[] args) {
        Dog d = new Dog();
        d.height = 15.6;
        d.weight = 3.14;
    }
}
```

---

### 3. Teacher 教师类 + TeacherTest 测试类

**文件**：`Teacher.java` / `TeacherTest.java`

**定义类（Teacher.java）**：

```java
public class Teacher {
    String id;      // 教工号
    String name;    // 姓名
    int age;        // 年龄

    public void teaching() {
        System.out.println(id + name + age + "在授课....");
    }

    public void sleep() {
        System.out.println(id + name + age + "在休息....");
    }
}
```

**测试类（TeacherTest.java）—— 重点：对象地址输出**：

```java
public class TeacherTest {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        t.id = "1001";
        t.name = "张三";
        t.age = 25;
        t.teaching();
        t.sleep();

        // 直接输出对象名 —— 得到内存地址
        System.out.println(t);
        // 输出示例：Teacher@4769b07b
    }
}
```

#### 对象地址输出解析

直接打印对象名时，输出格式为：**类型@哈希码**

| 部分 | 含义 |
|------|------|
| `Teacher` | 对象所属的类型 |
| `@` | 分隔符 |
| `4769b07b` | 对象在内存中的地址（哈希码的十六进制表示） |

---

### 4. 对象数组实战①——黄鹂与白鹭（古诗场景）

**文件**：`HuangLi.java`, `BaiLu.java`, `Test01.java`

**定义类——黄鹂（HuangLi.java）**：

```java
public class HuangLi {
    public void sing(String s) {
        System.out.println("黄鹂鸣" + s);
    }
}
```

**定义类——白鹭（BaiLu.java）**：

```java
public class BaiLu {
    public void up(String s) {
        System.out.println("白鹭上" + s);
    }
}
```

**测试类 —— 使用对象数组**：

```java
public class Test01 {
    public static void main(String[] args) {
        // 黄鹂：创建两个对象，调用方法
        HuangLi h1 = new HuangLi();
        HuangLi h2 = new HuangLi();
        String s1 = "翠柳";
        h1.sing(s1);
        h2.sing(s1);

        // 白鹭：对象数组，循环创建 10 个对象
        String s2 = "青天";
        BaiLu[] bailus = new BaiLu[10];
        // 初始状态：数组元素全为 null
        System.out.println(Arrays.toString(bailus));

        for (int i = 0; i < 10; i++) {
            BaiLu b = new BaiLu();      // 创建白鹭对象
            b.up(s2);                    // 调用方法
            bailus[i] = b;              // 存入数组（存的是地址值）
        }
    }
}
```

> **要点**：对象数组刚刚创建时，所有元素默认为 `null`。需要逐个 `new` 对象并赋值后才能使用。

---

### 5. 对象数组实战②——汽车与自行车（交通场景）

**文件**：`Car.java`, `Bike.java`, `Test02.java`

**定义类——汽车（Car.java）**：

```java
public class Car {
    String brand;   // 品牌
    String color;   // 颜色

    public void drive() {
        System.out.println(brand + "牌的" + color + "汽车行驶.....");
    }
}
```

**定义类——自行车（Bike.java）**：

```java
public class Bike {
    String type;    // 车型

    public void ride() {
        System.out.println("我骑着" + type + "自行车在骑行.....");
    }
}
```

**测试类 —— 单个对象 + 对象数组**：

```java
public class Test02 {
    public static void main(String[] args) {
        // 单个汽车对象
        Car c = new Car();
        c.brand = "奔驰";
        c.color = "白色";
        c.drive();

        // 自行车对象数组
        Bike[] bikes = new Bike[10];
        for (int i = 0; i < 10; i++) {
            Bike b = new Bike();
            b.type = "山地";
            bikes[i] = b;
            bikes[i].ride();
        }
    }
}
```

> **要点**：单个对象与对象数组混合使用，展示了面向对象建模中「1 对 N」关系的代码实现。

---

## 三、随堂练习

> 以下练习在 `Demo02.java` 和 `Demo03.java` 中以注释形式列出，作为课后实现任务。

### 练习 1：教师类完整定义

创建 `Teacher` 类，包含：
- **属性**：教工号(`id`)、姓名(`name`)、年龄(`age`)
- **方法**：授课(`teaching`)——输出 `id+name+age老师在授课`、休息(`sleep`)——输出 `id+name+age老师在休息`

### 练习 2：手机类（Phone）

创建 `Phone` 类和 `PhoneTest` 测试类：
- **属性**：品牌(`brand`)、价格(`price`)
- **方法**：打电话(`call`)、发短信(`sendMessage`)

### 练习 3：矩形类（Rectangle）

创建矩形类，包含：
- **属性**：长度(`length`)、宽度(`width`)
- **方法**：计算矩形周长、计算矩形面积

### 练习 4：圆形类（Circle）

创建圆形类，包含：
- **属性**：PI（圆周率）、半径(`radius`)
- **方法**：计算圆形周长、计算圆形面积

### 练习 5：三角形类（Triangle）

创建三角形类，包含：
- **属性**：边A、边B、边C、高
- **方法**：计算三角形周长、计算三角形面积

---

### 练习 6：古诗场景建模（Demo03 练习）

分析诗句「两只黄鹂鸣翠柳，一行白鹭上青天」，创建对应类和测试类：
- 黄鹂类（`HuangLi`）：`sing(String s)` 方法
- 白鹭类（`BaiLu`）：`up(String s)` 方法
- 测试类：创建 2 只黄鹂对象 + 10 只白鹭对象数组

### 练习 7：交通场景建模（Demo03 练习）

分析描述「一辆汽车在路上行驶，一队自行车并排骑行」，创建对应类和测试类：
- 汽车类（`Car`）：品牌、颜色属性 + `drive()` 方法
- 自行车类（`Bike`）：车型属性 + `ride()` 方法
- 测试类：1 个汽车对象 + 10 辆自行车对象数组

---

## 四、知识点总结

| 序号 | 知识点 | 说明 | 对应文件 |
|------|--------|------|---------|
| 1 | 面向对象思想 | Java 以对象为中心，区别于 C 的面向过程 | `Demo01.java` |
| 2 | 类的定义 | `class` 关键字定义类，包含属性和行为 | `Demo01.java` |
| 3 | 成员变量 | 类中方法外的变量，描述属性 | `Student.java`, `Dog.java`, `Teacher.java` |
| 4 | 成员方法 | 类中定义方法（无 `static`），描述行为 | `Student.java`, `Teacher.java` |
| 5 | 创建对象 | `类名 对象名 = new 类名();` | `Demo02.java`, `TeacherTest.java` |
| 6 | 调用成员 | `对象名.成员变量` / `对象名.成员方法()` | `Demo02.java`, `TeacherTest.java` |
| 7 | 多对象创建 | 一个类可创建多个独立对象 | `Demo02.java` |
| 8 | 对象地址 | 直接输出对象得到 `类型@哈希码` | `TeacherTest.java` |
| 9 | 成员变量 vs 局部变量 | 四维对比：位置、内存、生命周期、初始化值 | `Demo03.java` |
| 10 | 对象引用与内存共享 | 多个引用指向同一内存地址，修改互相影响 | `Demo03.java` |
| 11 | 对象数组 | 数组元素类型为类名，存储对象引用地址 | `Test01.java`, `Test02.java` |
| 12 | 循环创建对象并存入数组 | for 循环中 `new` 对象，赋值给数组元素 | `Test01.java`, `Test02.java` |
| 13 | 多个类协同建模 | 将现实场景（古诗/交通）抽象为多个类 | `HuangLi.java`, `BaiLu.java`, `Car.java`, `Bike.java` |

---

## 五、拓展阅读

1. **构造方法**：`new 类名()` 实际上是调用类的构造方法，默认有无参构造
2. **封装性**：使用 `private` 关键字隐藏属性，通过 `getter/setter` 访问
3. **this 关键字**：当成员变量与局部变量重名时，用 `this` 区分
4. **匿名对象**：`new Student().study();` —— 没有名字的对象，用后即弃
5. **null 与 NullPointerException**：引用变量可以不指向任何对象（`null`），调用该引用的成员会报空指针异常