实例方法与静态方法多态本质区别

本文通过代码实证揭示：实例方法支持真正的运行时多态（基于对象类型动态绑定），而静态方法虽可“重写”，但其调用不依赖 `self`，无法参与继承链上的动态分发；只有当静态方法被实例方法间接调用时，才可能表现出类级别的多态行为。

在面向对象编程中，多态性（Polymorphism）的核心在于“同一接口，不同实现，且由运行时对象的实际类型决定具体执行哪个版本”。这一特性在 Python 的实例方法中天然成立，但在静态方法中并不成立——尽管二者语法上均可被子类“重定义”，其底层绑定机制与行为语义却有根本区别。

✅ 实例方法：真正的运行时多态

实例方法通过 self 隐式接收调用者对象，Python 在调用时会根据 self 的实际运行时类型（而非声明类型）查找并执行对应的方法。这是动态绑定（dynamic dispatch）的典型体现：

class BaseClass:
    def greet(self):
        return f"Hello from {self.__class__.__name__}"

class DerivedClass(BaseClass):
    def greet(self):
        return f"Hi there! I'm {self.__class__.__name__}"

obj = DerivedClass()
print(obj.greet())  # 输出: "Hi there! I'm DerivedClass"

即使将 obj 赋值给一个 BaseClass 类型的变量（Python 中无显式类型声明，但逻辑上可视为基类引用），只要实际对象是 DerivedClass 实例，greet() 就始终调用子类版本——这正是多态的实质。

❌ 静态方法：无动态绑定，仅是名称覆盖（Shadowing）

静态方法使用 @staticmethod 装饰，不接收 self 或 cls，与任何实例或类状态无关。它本质上是“寄居”在类命名空间中的普通函数。子类中同名静态方法不会覆盖父类行为，而是独立存在、按调用点显式解析：

class BaseClass:
    @staticmethod
    def say():
        return "Base says hi"

class DerivedClass(BaseClass):
    @staticmethod
    def say():
        return "Derived says hello"

# 显式通过类名调用 → 各自返回自己的实现
print(BaseClass.say())      # "Base says hi"
print(DerivedClass.say())   # "Derived says hello"

# 通过实例调用 → 实际仍由类名隐式决定（非 `self` 类型）
b = BaseClass()
d = DerivedClass()
print(b.say())  # "Base says hi" —— 解析为 BaseClass.say
print(d.say())  # "Derived says hello" —— 解析为 DerivedClass.say

⚠️ 注意：d.say() 看似“多态”，实则是 Python 在实例上调用静态方法时，自动回溯 d.__class__ 获取所属类，再查找该类下的 say。这不是基于继承链的虚函数调用，而是编译期/解析期就确定的静态绑定。你无法通过 BaseClass().say() 调用到 DerivedClass.say()，哪怕传入的是子类实例——因为 BaseClass() 的 __class__ 就是 BaseClass。

? 关键验证：让多态“暴露”在间接调用中

要真正凸显两者的差异，需构造一个父类中定义、但内部调用子类重定义成员的场景。此时，实例方法会因 self 的动态性而触发多态；静态方法则不会——除非你显式用 self.__class__.static_method() 手动触发类查找：

class BaseClass:
    def instance_method(self):
        return "Base instance"

    @staticmethod
    def static_method():
        return "Base static"

    # 关键对比：此方法在 Base 中定义，但内部调用其他方法
    def template_pattern(self):
        return f"[Instance] {self.instance_method()} | [Static] {self.static_method()}"

class DerivedClass(BaseClass):
    def instance_method(self):
        return "Derived instance"

    @staticmethod
    def static_method():
        return "Derived static"

base = BaseClass()
derived = DerivedClass()

print(base.template_pattern())
# 输出: [Instance] Base instance | [Static] Base static

print(derived.template_pattern())
# 输出: [Instance] Derived instance | [Static] Base static ← 注意！static_method 仍是 Base 版本

✅ self.instance_method() 正确调用了 DerivedClass.instance_method（多态生效）
❌ self.static_method() 仍调用 BaseClass.static_method（静态方法未多态）

? 原因：self.static_method() 等价于 BaseClass.static_method()，因为 template_pattern 定义在 BaseClass 中，其内部对 static_method 的引用在定义时已静态解析为 BaseClass.static_method。Python 不会在运行时根据 self 类型重新解析静态方法名。

若想让静态方法也“参与多态”，必须显式使用类动态查找：

def template_pattern(self):
    # 强制按 self 的实际类查找静态方法
    return f"[Instance] {self.instance_method()} | [Static] {self.__class__.static_method()}"

此时 derived.template_pattern() 将输出 "Derived static"——但这已不是语言原生多态，而是手动模拟。

✅ 总结：一句话区分

因此，判断一个方法是否真正具备多态性，不要看它能否被重写，而要看：当通过父类定义的方法间接调用它时，行为是否随实际对象类型自动改变。实例方法可以，静态方法不可以——这才是多态的本质检验标准。