From 0c4c27b0b759a2efe7e5e4f0a865ff6065af1813 Mon Sep 17 00:00:00 2001
From: Aaron <simidaxu@gmail.com>
Date: Fri, 5 Sep 2025 11:10:25 +0800
Subject: [PATCH] =?UTF-8?q?09-05-=E5=91=A8=E4=BA=94=5F11-10-25?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 02.面向对象/04.封装与多态.md | 73 +++++++++++++++++++++++-------------
 1 file changed, 46 insertions(+), 27 deletions(-)

diff --git a/02.面向对象/04.封装与多态.md b/02.面向对象/04.封装与多态.md
index 900c0fe..b32fa8c 100644
--- a/02.面向对象/04.封装与多态.md
+++ b/02.面向对象/04.封装与多态.md
@@ -5,7 +5,10 @@ python面向对象的三大特性：继承，封装，多态。
 1. **封装**: 把很多数据封装到⼀个对象中. 把固定功能的代码封装到⼀个代码块, 函数, 对象, 打包成模块. 这都属于封装的思想. 具体的情况具体分析. 比如. 你写了⼀个很⽜B的函数. 那这个也可以被称为封装. 在⾯向对象思想中. 是把⼀些看似⽆关紧要的内容组合到⼀起统⼀进⾏存储和使⽤. 这就是封装. 
 
 2. **继承**: ⼦类可以⾃动拥有⽗类中除了私有属性外的其他所有内容. 说⽩了, ⼉⼦可以随便⽤爹的东⻄. 但是朋友们, ⼀定要认清楚⼀个事情. 必须先有爹, 后有⼉⼦. 顺序不能乱, 在python中实现继承非常简单. 在声明类的时候, 在类名后⾯添加⼀个⼩括号,就可以完成继承关系. 那么什么情况可以使⽤继承呢? 单纯的从代码层⾯上来看. 两个类具有相同的功能或者特征的时候. 可以采⽤继承的形式. 提取⼀个⽗类, 这个⽗类中编写着两个类相同的部分. 然后两个类分别取继承这个类就可以了. 这样写的好处是我们可以避免写很多重复的功能和代码. 如果从语义中去分析的话. 会简单很多. 如果语境中出现了x是⼀种y. 这时, y是⼀种泛化的概念. x比y更加具体. 那这时x就是y的⼦类. 比如. 猫是⼀种动物. 猫继承动物. 动物能动. 猫也能动. 这时猫在创建的时候就有了动物的"动"这个属性. 再比如, ⽩骨精是⼀个妖怪. 妖怪天⽣就有⼀个比较不好的功能叫"吃⼈", ⽩骨精⼀出⽣就知道如何"吃⼈". 此时 ⽩骨精继承妖精.
-3. **多态**: 同⼀个对象, 多种形态. 这个在python中其实是很不容易说明⽩的. 因为我们⼀直在⽤. 只是没有具体的说. 比如. 我们创建⼀个变量a = 10 , 我们知道此时a是整数类型. 但是我们可以通过程序让a = "hello", 这时, a⼜变成了字符串类型. 这是我们都知道的. 但是, 我要告诉你的是. 这个就是多态性. 同⼀个变量a可以是多种形态。
+
+3. **多态**: Python 中的多态是面向对象编程的核心概念，它允许不同类型的对象对相同的消息（方法调用）做出不同的响应，从而使用统一的接口处理不同的对象
+
+   。这种机制显著提高了代码的灵活性、可扩展性和可维护性。
 
 ## 封装
 
@@ -47,39 +50,55 @@ obj2.detail()
 
 ## 多态
 
-多态，同一个对象，多种形态。python默认支持多态。
+### 通过继承与方法重写实现多态
 
-python中有一句谚语说的好，你看起来像鸭子，那么你就是鸭子。
-对于代码上的解释其实很简答：
+这是实现多态最直接的方式。子类继承父类并重写其方法，从而提供特定的实现。当调用方法时，实际执行的是子类中重写的方法
 
 ```python
-class A:
-    def f1(self):
-        print('in A f1')
-    
-    def f2(self):
-        print('in A f2')
+class Animal:
+    def speak(self):
+        raise NotImplementedError("子类必须实现此方法")  # 父类定义方法接口
 
+class Dog(Animal):
+    def speak(self):  # 子类重写方法
+        return "Woof!"
 
-class B:
-    def f1(self):
-        print('in B f1')
-    
-    def f2(self):
-        print('in B f2')
-        
-obj = A()
-obj.f1()
-obj.f2()
+class Cat(Animal):
+    def speak(self):  # 子类重写方法
+        return "Meow!"
 
-obj2 = B()
-obj2.f1()
-obj2.f2()
-# A 和 B两个类完全没有耦合性，但是在某种意义上他们却统一了一个标准。
-# 对相同的功能设定了相同的名字，这样方便开发，这两个方法就可以互成为鸭子类型。
+# 多态的函数
+def animal_speak(animal):
+    print(animal.speak())  # 统一接口调用
 
-# 这样的例子比比皆是：str  tuple list 都有 index方法，这就是统一了规范。
-# str bytes 等等 这就是互称为鸭子类型。
+dog = Dog()
+cat = Cat()
+
+animal_speak(dog)  # 输出: Woof!
+animal_speak(cat)  # 输出: Meow!
+```
+
+### 通过鸭子类型实现多态
+
+Python 的鸭子类型（Duck Typing）是一种动态类型风格，它不要求对象继承自特定类，只关心对象是否具有所需的方法或属性（“如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子”）
+
+```python
+class Duck:
+    def quack(self):
+        return "Quack!"
+
+class Person:
+    def quack(self):  # 无需继承特定类，只需有 quack 方法
+        return "I'm quacking like a duck!"
+
+def make_it_quack(thing):  # 函数只关心传入对象是否有 quack 方法
+    print(thing.quack())
+
+duck = Duck()
+person = Person()
+
+make_it_quack(duck)    # 输出: Quack!
+make_it_quack(person)  # 输出: I'm quacking like a duck!
 ```
 
 ## 类的约束