feat: 新增20260720课堂笔记及授课代码——面向对象基础：类与对象、成员变量与成员方法、创建对象与使用成员

README.md

@@ -27,6 +27,7 @@
 | 2026-07-15 | [switch分支、循环结构、嵌套循环与数组](./课堂笔记/01-JavaSE基础-笔记/20260715-笔记.md) |
 | 2026-07-16 | [多维数组、forEach、Arrays工具类、三种排序算法（冒泡/选择/插入）与 Scanner 键盘输入](./课堂笔记/01-JavaSE基础-笔记/20260716-笔记.md) |
 | 2026-07-17 | [Java方法4种声明方式（无参无返回值/有参无返回值/有参有返回值/无参有返回值）、方法中调用方法、数组作为方法参数、Random随机数类、Random+方法综合练习、三种排序算法复习、Scanner 学生信息采集系统](./课堂笔记/01-JavaSE基础-笔记/20260717-笔记.md) |
+| 2026-07-20 | [面向对象基础：类与对象、成员变量与成员方法、创建对象与使用成员](./课堂笔记/01-JavaSE基础-笔记/20260720-笔记.md) |
 
 ## 二、授课代码
 
@@ -40,4 +41,5 @@
 | 2026-07-15 | switch分支、循环结构与数组 | `c260715` | [默认包](./授课代码/c260715/src/) |
 | 2026-07-16 | 多维数组、forEach、Arrays工具类、三种排序算法（冒泡/选择/插入）与 Scanner 键盘输入 | `c260716` | [默认包](./授课代码/c260716/src/) |
 | 2026-07-17 | Java方法4种声明方式、数组作为方法参数、Random随机数类、在线OJ编码模板、三种排序算法复习、Scanner学生信息采集系统（BMI计算） | `c260717` | [默认包](./授课代码/c260717/src/) |
+| 2026-07-20 | 面向对象基础：类与对象、成员变量与成员方法、创建对象与使用成员、对象地址输出 | `c260720` | [默认包](./授课代码/c260720/src/) |
 

授课代码/c260720/src/Demo01.java

@@ -0,0 +1,66 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description 面向对象基础-类和对象
+ * @create 2026/7/20
+ */
+public class Demo01 {
+    /*
+        Java中 一切皆为对象
+
+        Java属于面向对象的语言
+            面向对象的语言，是一种以对象为中心的编程思想，通过指挥对象实现具体的操作。
+        C属于面向过程的语言
+            面向过程的语言，是一种以过程为中心的编程思想，实现功能的每一个都是自己的实现的。
+
+
+
+        类 和 对象 的 关系
+        其实就是 设计图纸 和 成品 的关系
+
+        1套设计图纸可以做出来多个成品
+        我们也可以根据1个类，创建多个对象。
+        类是模版、是蓝图、是设计图纸、是图稿、是规则、是要求、是描述一个对象的所有属性和操作
+        Java中 定义类的格式：
+
+        修饰符 class 类名{
+            数据类型 属性名;
+
+            修饰符 返回值类型 方法名(){
+
+            }
+        }
+        一个类中具有一些成员：
+            属性---变量
+            操作---方法
+
+        比如：盖伦
+
+        public class 盖伦{
+            int hp; //属性--血量
+            int mp; //属性--蓝量
+
+            //移动的方法
+            public void move(){
+                盖伦移动.....
+            }
+        }
+        猫、狗、兔子、鸟  创建各种类
+
+        什么是类？
+        类是现实生活中一类具有相同属性和行为的事物的抽象。
+        什么是对象？
+            是能够看得到摸得着的真实存在的实体。
+
+        类是由属性和行为两部分组成：
+            属性：在类中属性通过成员变量来体现（成员变量就是类中方法外的变量）
+            行为：是在类中通过方法来体现，（和我们之前用的方法基本一样，只是少了static关键字）
+     */
+    /*
+        案例：
+            定义一个学生类，
+            包含属性：姓名、年龄
+            包含行为：学习
+     */
+}

授课代码/c260720/src/Demo02.java

@@ -0,0 +1,66 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description 对象
+ * @create 2026/7/20
+ */
+public class Demo02 {
+    /*
+        创建对象和使用对象
+    格式：
+        类名 对象名=new 类名();
+        Dog dog=new Dog();
+        Student s=new Student();
+    调用成员的格式：
+        对象名.成员变量;
+        对象名.成员方法;
+     */
+    public static void main(String[] args) {
+        //类名 对象名=new 类名();
+        Student s=new Student();
+        //对象名.成员变量;
+        s.name="张三";
+        s.age=25;
+        //对象名.成员方法;
+        s.study();
+
+
+
+        //类名 对象名=new 类名();
+        Student s1=new Student();
+        //对象名.成员变量;
+        s1.name="李四";
+        s1.age=20;
+        //对象名.成员方法;
+        s1.study();
+    }
+
+    /*
+
+        1、创建一个教师类、包含：教工号(id)、姓名(name)、年龄(age)属性，以及 授课、休息 两个方法
+        每个方法中都输出
+         id+name+age 老师在授课
+         id+name+age 老师在休息
+        2、定义一个手机类(Phone)，然后再定义一个手机测试类(PhoneTest)
+        在手机测试类中通过对象完成成员变量和成员方法的使用
+            手机类包含：
+                成员变量：品牌、价格
+                成员方法：打电话、发短信
+        3、创建一个矩形类
+            包含以下属性： 长度、宽度
+            包含如下方法：
+                计算矩形周长()
+                计算矩形面积()
+         4、创建一个圆形类
+            包含以下属性： PI、半径
+            包含如下方法：
+                计算圆形周长()
+                计算圆形面积方法()
+         5、创建一个三角形类
+            包含以下属性： 边A、边B、边C、高
+            包含如下方法：
+                计算圆形周长()
+                计算圆形面积方法()
+     */
+}

授课代码/c260720/src/Dog.java

@@ -0,0 +1,22 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Dog
+ * @description
+ * @create 2026/7/20
+ */
+public class Dog {
+    // 属性   Dog类的属性，其实就是成员变量
+    double weight;  //成员变量 就是全局变量
+    double height;
+
+    //方法
+
+    public static void main(String[] args) {
+        //创建了Dog对象
+        Dog d=new Dog();
+        //通过Dog对象，调用这个对象的属性
+        d.height=15.6;
+        d.weight=3.14;
+    }
+}

授课代码/c260720/src/Student.java

@@ -0,0 +1,36 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Student
+ * @description 学生类
+ * @create 2026/7/20
+ */
+public class Student {
+    String name;
+    int age;
+    // 在类的内部，方法的外部，定义的属性变量就是【成员变量】（相当于全局变量），格式和之前一样，只不过位置变了
+
+    //行为：学习
+    //成员方法:跟之前定义方法的格式一样，只不过去掉static关键字
+    public void study(){
+        System.out.println("姓名："+name+"，年龄："+age+",在学习");
+    }
+
+    public static void main(String[] args) {
+        //类名 对象名=new 类名();
+        Student s=new Student();
+        //对象名.成员变量;
+        s.name="张三";
+        s.age=25;
+        //对象名.成员方法;
+        s.study();
+
+        //类名 对象名=new 类名();
+        Student s1=new Student();
+        //对象名.成员变量;
+        s1.name="李四";
+        s1.age=20;
+        //对象名.成员方法;
+        s1.study();
+    }
+}

授课代码/c260720/src/Teacher.java

@@ -0,0 +1,20 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Teacher
+ * @description 教师类
+ * @create 2026/7/20
+ */
+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+"在休息....");
+    }
+}

授课代码/c260720/src/TeacherTest.java

@@ -0,0 +1,35 @@
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title TeacherTest
+ * @description Teacher测试类
+ * @create 2026/7/20
+ */
+public class TeacherTest {
+    public static void main(String[] args) {
+        //创建Teacher对象
+        Teacher t=new Teacher();
+        //调用teacher的属性和方法
+        t.id="1001";
+        t.name="张三";
+        t.age=25;
+        t.teaching();
+        t.sleep();
+        System.out.println(t.name);
+        System.out.println(t.age);
+        System.out.println(t.id);
+        System.out.println(t);
+        /*
+            我们直接输出t对象，得到的是这个对象在内存中的地址：
+            Teacher@4769b07b
+            Teacher 代表这个对象所属的类型
+            @ 分隔符
+            4769b07b 是在内存中开辟的空间的地址，也就是teacher对象的地址
+         */
+        Teacher t1=new Teacher();
+        System.out.println(t1);
+
+        t=new Teacher();
+        System.out.println(t);
+    }
+}

课堂笔记/01-JavaSE基础-笔记/20260720-笔记.md

@@ -0,0 +1,242 @@
+# 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
+对象名.成员变量;     // 访问属性
+对象名.成员方法();   // 调用方法
+```
+
+---
+
+## 二、代码实战：类与对象完整示例
+
+### 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` |
+
+---
+
+## 五、拓展阅读
+
+1. **堆与栈内存**：对象存储在堆（Heap）中，引用变量存储在栈（Stack）中
+2. **构造方法**：`new 类名()` 实际上是调用类的构造方法，默认有无参构造
+3. **封装性**：使用 `private` 关键字隐藏属性，通过 `getter/setter` 访问
+4. **this 关键字**：当成员变量与局部变量重名时，用 `this` 区分
+5. **匿名对象**：`new Student().study();` —— 没有名字的对象，用后即弃