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

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

Author: magicgopher

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

@@ -24,7 +24,7 @@ Java抽象类是一种使用 abstract 关键字修饰的特殊类，它不能被
 
 示例：
 
-```jaav
+```java
 public abstract void show();
 ```
 
@@ -599,7 +599,7 @@ public class MultiTool implements Printer, Logger, Debugger {
 ```
 
 ```java [测试代码]
-public class Main {
+public class TestMain {
     public static void main(String[] args) {
         MultiTool tool = new MultiTool();
         tool.test();
@@ -647,7 +647,7 @@ public class C extends D implements A {
 ```
 
 ```java [测试代码]
-public class Test {
+public class TestMain {
     public static void main(String[] args) {
         C c = new C();
         c.methodA();
@@ -708,7 +708,7 @@ public class Duck implements Amphibious {
 }
 
 // 测试类
-public class Main {
+public class TestMain {
     public static void main(String[] args) {
         Duck duck = new Duck();
         duck.fly();   // 输出: 鸭子在飞翔
@@ -742,6 +742,211 @@ Java多态是指同一个方法在不同对象上可以有不同的行为，即
 变量名.方法名();
 ```
 
+> 父类类型：指的是子类继承的父类类型，或者实现的父接口类型。
+
+示例：
+
+```java
+Animal animal = new Cat();
+animal.run();
+```
+
+当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后的方法。
+
+示例：
+
+::: code-group
+```java [定义父类]
+// 抽象类
+public abstract class Animal {
+    public abstract void eat();
+}
+```
+
+```java [定义子类]
+public class Cat extends Animal {
+
+    @Override
+    public void eat() {
+        System.out.println("吃鱼");
+    }
+}
+```
+
+```java [定义子类]
+public class Dog extends Animal {
+
+    @Override
+    public void eat() {
+        System.out.println("吃骨头");
+    }
+}
+```
+
+```java [测试类]
+public class TestMain {
+    public static void main(String[] args) {
+        // 多态的形式创建对象
+        Animal a1 = new Cat();
+        // 调用的是 Cat 的 eat() 方法
+        a1.eat();  // 输出：吃鱼
+
+        // 多态的形式创建对象
+        Animal a2 = new Dog();
+        // 调用的是 Dog 的 eat() 方法
+        a2.eat();  // 输出：吃骨头
+    }
+}
+```
+:::
+
+### 多态的好处
+
+实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。
+
+示例：
+
+::: code-group
+```java [定义父类]
+public abstract class Animal {
+    // 抽象方法
+    public abstract void eat();
+}
+```
+
+```java [定义子类]
+public class Cat extends Animal {
+
+    // 重写父类的抽象方法
+    @Override
+    public void eat() {
+        System.out.println("吃鱼");
+    }
+}
+```
+
+```java [定义子类]
+public class Dog extends Animal {
+
+    // 重写父类的抽象方法
+    @Override
+    public void eat() {
+        System.out.println("吃骨头");
+    }
+}
+```
+
+```java [测试类]
+public class TestMain {
+    public static void main(String[] args) {
+        // 创建对象
+        Cat cat = new Cat();
+        Dog dog = new Dog();
+
+        // 调用showCatEat
+        showCatEat(cat);
+        // 调用showDogEat
+        showDogEat(dog);
+        
+        /**
+         * 以上两个方法，均可以被showAnimalEat(Animal a)方法所替代
+         * 而且执行效果一致
+         */
+        showAnimalEat(cat);
+        showAnimalEat(dog);
+    }
+
+    public static void showCatEat(Cat c) {
+        c.eat();
+    }
+
+    public static void showDogEat(Dog d) {
+        d.eat();
+    }
+
+    public static void showAnimalEat(Animal a) {
+        a.eat();
+    }
+}
+```
+:::
+
+示例说明：
+
+- 由于多态特性的支持 `showAnimalEat()` 方法的Animal类型，是 `Cat` 和 `Dog` 的父类类型，父类类型接收子类对象，当然可以把 `Cat` 对象和 `Dog` 对象，传递给方法。
+- 当 `eat()` 方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与 `showCatEat()`、`showDogEat()` 方法一致，所以 `showAnimalEat()` 完全可以替代以上两方法。
+- 不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写 `showXxxEat()` 方法了，直接使用 `showAnimalEat()` 都可以完成。
+
+### 多态的两种形式
+
+| 形式 | 说明 | 示例 |
+| :-- | :-- | :-- |
+| 编译时多态（静态多态） | 方法重载（Overloading） | `add(int a, int b)` 和 `add(double a, double b)` |
+| 运行时多态（动态多态） | 方法重写（Overriding） + 继承 + 向上转型 | 父类引用调用子类重写的方法 |
+
+> Java 中真正意义的多态指的是运行时多态（基于方法重写）。
+
+### 运行时多态的三个必要条件
+
+要实现运行时多态，必须同时满足以下三个条件：
+
+1. 继承关系：子类继承父类（或者实现接口）
+2. 方法重写：子类重写父类的方法（@Override）
+3. 向上转型：父类引用指向子类对象
+
+示例：
+
+```java
+class Animal {
+    public void makeSound() {
+        System.out.println("动物叫声");
+    }
+}
+
+class Dog extends Animal {
+    @Override
+    public void makeSound() {
+        System.out.println("汪汪！");
+    }
+}
+
+class Cat extends Animal {
+    @Override
+    public void makeSound() {
+        System.out.println("喵喵！");
+    }
+}
+
+// 使用多态
+public class Test {
+    public static void main(String[] args) {
+        Animal a1 = new Dog();  // 向上转型
+        Animal a2 = new Cat();
+
+        a1.makeSound();  // 输出：汪汪！
+        a2.makeSound();  // 输出：喵喵！
+    }
+}
+```
+
+### 向上转型
+
+向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。
+
+当父类引用指向一个子类对象时，便是向上转型。
+
+语法格式：
+
+```java
+父类类型 变量名 = new 子类类型();
+```
+
+示例：
+
+```java
+Animal animal = new Cat();
+```
+
 ::: tip 提示
 文档正在更新中...
 :::