# 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` 也变成"李四"，因为它们是同一块内存。

---



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

### 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` | 对象在内存中的地址（哈希码的十六进制表示） |

---

## 三、随堂练习

> 以下练习在 `Demo02.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、高
- **方法**：计算三角形周长、计算三角形面积

---

## 四、知识点总结

| 序号 | 知识点 | 说明 | 对应文件 |
|------|--------|------|---------|
| 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` |

---

## 五、拓展阅读

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