docs(java): 更新Java基础笔记。

更新面向对象编程笔记内容。

Author: magicgopher

docs/zh/后端/02-Java/01-Java基础/05-面向对象编程.md

@@ -8,6 +8,318 @@ editLink: false
 
 # 面向对象编程
 
+## 概述
+
+Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。
+
+举例：洗衣服
+
+- 面向过程：把衣服脱下来 -> 找一个盆 -> 放点洗衣粉 -> 加点水 -> 浸泡10分钟 -> 开始清洗衣服 -> 拧干衣服 -> 晾起来
+- 面向过程：把衣服脱下来 -> 丢进全自动洗衣机 -> 等待洗衣 -> 晾起来
+
+区别：
+
+- 面向过程：强调步骤。
+- 面向对象：强调对象，这里的对象就是全自动洗衣机。
+
+## 三大基本特征
+
+面向对象的三大基本特征：封装、继承、多态。
+
+| 特征 | 说明 |
+| --- | --- |
+| 封装 | 将对象的“属性”和“行为”抽象出来包装到类中，通过访问控制符隐藏内部实现细节，只暴露必要的接口。 |
+| 继承 | 将具有相同”属性“和“行为”的对象抽象出来并包装成一个父类，子类继承父类的非私有属性和方法，实现代码复用。支持单继承（一个类只能继承一个直接父类） |
+| 多态 | 多种形态，相同的“属性”和“行为”却有不同的表现方式，同一接口（方法名）在不同对象上有不同实现。<br/> 主要分为：<br/>1. 编译时多态（方法重载）<br/>2. 运行时多态（方法重写 + 父类引用子类对象） |
+
+## 类和对象
+
+**类**：是一组相关属性和行为的集合。可以看成是一类事物的模版，使用事物的属性特征和行为特征来描述该类事物。
+
+**对象**：是一类事物的具体体现，对象是类的一个实例，必然具备该类事物的属性和行为。
+
+类和对象的关系：
+
+- 类是对一类事物的描述，是抽象的。
+- 对象是一类事物的实例，是具体的。
+- 类是对象的模版，对象是类的实体。
+
+### 类的定义
+
+类的定义语法格式如下：
+
+```java
+访问修饰符 class 类名 [extends 父类] [implements 接口列表] {
+    // 成员变量
+    // 构造器
+    // 方法
+    // [代码块]
+    // [内部类]
+}
+```
+
+示例：
+
+```java
+public class Student {
+    // 成员变量
+    String name;
+    int age;
+
+    // 方法
+    // 学习
+    public void study() {
+        System.out.println("学习中...");
+    }
+
+    // 吃饭
+    public void eat() {
+        System.out.println("吃饭中...");
+    }
+}
+```
+
+### 对象创建和使用
+
+对象创建的语法格式如下：
+
+```text
+类名 对象名 = new 类名();
+```
+
+使用对象访问类中的成员变量和方法。
+
+```text
+对象名.成员变量名;
+对象名.方法名(); 
+```
+
+示例：
+
+```java
+public class Test01Student {
+    public static void main(String[] args) {
+        // 创建对象格式：类名 对象名 = new 类名()
+        Student s = new Student();
+        System.out.println("s：" + s);
+
+        // 直接输出成员变量值
+        System.out.println("姓名：" + s.name);
+        System.out.println("年龄：" + s.age);
+        System.out.println("================");
+
+        // 给成员变量赋上新的值
+        s.name = "MagicGopher";
+        s.age = 18;
+
+        // 再次输出成员变量的值
+        System.out.println("姓名：" + s.name); // MagicGopher
+        System.out.println("年龄：" + s.age); // 18
+        System.out.println("================");
+
+        // 调用成员方法
+        s.study(); // 学习中...
+        s.eat(); // 吃饭中...
+    }
+}
+```
+
+### 成员变量的默认值
+
+|  | 数据类型 | 默认值 |
+| --- | --- | --- |
+| 基本类型 | 整数（byte, short, int, long） | 0 |
+|  | 浮点数（float, double） | 0.0 |
+|  | 字符（char） | '\u0000' |
+|  | 布尔值（boolean） | false |
+| 引用类型 | 数组（Array）, 类（Class）, 接口（interface） | null |
+
+### 成员变量和局部变量
+
+成员变量和局部变量的区别，以下示例所示：
+
+```java
+public class Car {
+    // 成员变量
+    String color;
+    public void drive() {
+        int speed = 100; // 局部变量
+        System.out.println("速度：" + speed);
+    }
+} 
+```
+
+- 在类的位置不同
+  - 成员变量：类中，方法外
+  - 局部变量：方法中或者方法声明上（形式参数）
+- 作用范围不一样
+  - 成员变量：类中
+  - 局部变量：方法中
+- 初始化值的不同
+  - 成员变量：有默认值
+  - 局部变量：没有默认值，必须先定义，赋值，最后使用。
+- 在内存的位置不同
+  - 成员变量：堆内存
+  - 局部变量：栈内存
+- 生命周期不同
+  - 成员变量：随着对象的创建而诞生，随着对象的销毁而消失。
+  - 局部变量：随着方法的调用而诞生，随着方法的调用结束而消失。
+
+## 封装
+
+封装是面向对象编程中的一个重要概念，它的目的是将对象的属性（成员变量）隐藏起来，若需要访问某个属性，则需要通过提供的公共方法进行访问。
+
+1. 使用 `private` 关键字来修饰成员变量，达到将对象的属性（成员变量）隐藏起来的目的。
+2. 对需要访问的对象属性（成员变量），提供公共的访问方法（`getXxx()`方法、`setXxx()`方法）
+
+### private 关键字
+
+*private* 关键字的含义
+
+1. *private* 关键字是一个权限修饰符，代表最小权限。
+2. 可以修饰成员变量和成员方法。
+3. 被 *private* 修饰的成员变量和成员方法，只能在当前类中访问。
+
+*private* 关键字的使用格式，如下：
+
+```java
+private 数据类型 变量名称;
+```
+
+示例：
+
+Student.java
+
+```java
+public class Student {
+    private String name;
+    private int age;
+
+    public void setName(String n) {
+        // 将传入的参数n赋值给成员变量name
+        name = n;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setAge(int a) {
+        // 将传入的参数a赋值给成员变量age
+        age = a;
+    }
+
+    public int getAge() {
+        return age;
+    }
+}
+```
+
+TestStudent.java
+
+```java
+public class TestStudent {
+    public static void main(String[] args) {
+        // 创建Student对象
+        Student s1 = new Student();
+        System.out.println("设置成员变量之前");
+        // 获取name、age属性（成员变量）
+        System.out.println(s1.getName());
+        System.out.println(s1.getAge());
+        System.out.println("================");
+
+        // 通过setXxx()方法设置成员变量
+        s1.setName("MagicGopher");
+        s1.setAge(19);
+        System.out.println("设置成员变量之后");
+        // 获取name、age属性（成员变量）
+        System.out.println(s1.getName());
+        System.out.println(s1.getAge());
+        System.out.println("================");
+    }
+}
+```
+
+控制台输出结果：
+
+```text
+设置成员变量之前
+null
+0
+================
+设置成员变量之后
+MagicGopher
+19
+================
+```
+
+### this 关键字
+
+在上述案例中的 `setName()` 方法和 `setAge()` 方法中传入的形式参数的名字并不符合规范（见名知意），那么将参数改成和成员变量名一致，是否就见名知意了呢？代码如下：
+
+```java
+public class Student {
+    private String name;
+    private int age;
+
+    public void setName(String name) {
+        // 将传入的参数n赋值给成员变量name
+        name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setAge(int age) {
+        // 将传入的参数a赋值给成员变量age
+        age = age;
+    }
+
+    public int getAge() {
+        return age;
+    }
+}
+```
+
+TestStudent.java
+
+```java
+public class TestStudent {
+    public static void main(String[] args) {
+        // 创建Student对象
+        Student s1 = new Student();
+        System.out.println("设置成员变量之前");
+        // 获取name、age属性（成员变量）
+        System.out.println(s1.getName());
+        System.out.println(s1.getAge());
+        System.out.println("================");
+
+        // 通过setXxx()方法设置成员变量
+        s1.setName("MagicGopher");
+        s1.setAge(19);
+        System.out.println("设置成员变量之后");
+        // 获取name、age属性（成员变量）
+        System.out.println(s1.getName());
+        System.out.println(s1.getAge());
+        System.out.println("================");
+    }
+}
+```
+
+控制台输出结果：
+
+```text
+设置成员变量之前
+null
+0
+================
+设置成员变量之后
+null
+0
+================
+```
+
 ::: tip 提示
 文档正在更新中...
 :::

docs/zh/后端/02-Java/index.md

@@ -18,14 +18,15 @@ editLink: false
 | 4 | [方法](./01-Java基础/04-方法.md) | 方法的定义、调用、重载 | ✅ |
 | 4 | [面向对象编程](./01-Java基础/05-面向对象编程.md) | 类、对象、封装、继承、多态、接口 | ✅ |
 | 5 | [字符串处理]() | String、StringBuilder、StringBuffer操作 |  |
-| 6 | [集合]() | List、Set等集合框架使用 |  |
-| 7 | [Map]() | Map接口及其实现类的使用 |  |
-| 8 | [泛型]() | 泛型类、方法与类型安全的实现 |  |
-| 9 | [异常处理]() | try-catch、自定义异常与处理机制 |  |
-| 10 | [IO流]() | 字节流、字符流、缓冲流与文件操作 |  |
-| 11 | [注解]() | 注解的定义、使用与自定义注解 |  |
-| 12 | [多线程]() | 线程创建、管理、同步与通信 |  |
-| 13 | [网络编程]() | 网络通信、Socket与客户端/服务器模型 |  |
+| 6 | [常用类]() | 常用类的使用 |  |
+| 7 | [集合]() | List、Set等集合框架使用 |  |
+| 8 | [Map]() | Map接口及其实现类的使用 |  |
+| 9 | [泛型]() | 泛型类、方法与类型安全的实现 |  |
+| 10 | [异常处理]() | try-catch、自定义异常与处理机制 |  |
+| 11 | [IO流]() | 字节流、字符流、缓冲流与文件操作 |  |
+| 12 | [注解]() | 注解的定义、使用与自定义注解 |  |
+| 13 | [多线程]() | 线程创建、管理、同步与通信 |  |
+| 14 | [网络编程]() | 网络通信、Socket与客户端/服务器模型 |  |
 
 ## 🎯 Java 基础进阶