在线 -
搜索 AIGC编程网
← 返回题目列表

Python 的可调用对象是什么？__call__ 有什么用？

高频 中等 第 5 / 21 题 更新于 2026/07/31
Python__call__callable可调用对象

简化版

在 Python 里，「可调用对象（callable）」是指「能像函数一样用 () 调用」的对象——不只是函数，还包括类、方法、以及任何定义了 __call__ 方法的实例。判断一个对象能不能调用用内置函数 callable(obj)。哪些是可调用的：① 普通函数、lambda；② 内置函数、方法；③ 类本身（MyClass() 是调用类、触发 __new__ + __init__）；④ 定义了 __call__ 的类的实例——obj() 会触发 obj.__call__()。__call__ 的价值：让「实例能像函数一样被调用」，从而做「有状态的函数」——实例可以保存状态（计数器、缓存、配置），每次调用时用/更新这些状态，比闭包更清晰、比普通函数能带更多状态。例子：class Counter: def __call__(self): self.n += 1; return self.n——c = Counter(); c(); c() 依次返回 1, 2。典型用途：装饰器类、带配置的函数对象、策略对象、缓存器、神经网络层（PyTorch 的 nn.Module）。核心记忆：可调用对象 = 能用 () 调用的（函数/类/定义 __call__ 的实例），callable() 判断；__call__ 让实例像函数一样调用、可带状态。

详细版

可调用对象与 call：

对象调用时发生什么
函数 ff() 执行函数体
类 CC() 触发 __new__ + __init__，返回实例
定义 __call__ 的实例 objobj() 触发 obj.__call__()
callable(x)判断 x 能否用 () 调用
# 判断是否可调用
print(callable(print))          # True（函数）
print(callable(int))            # True（类）
print(callable(len))            # True（内置函数）
print(callable(42))             # False（整数不可调用）
print(callable(lambda: 1))      # True

# 定义 __call__ 让实例可调用
class Multiplier:
    def __init__(self, factor):
        self.factor = factor    # 保存状态（配置）
    def __call__(self, x):      # 实例被调用时触发
        return x * self.factor

double = Multiplier(2)          # 创建实例
print(double(5))                # 10（触发 __call__）
print(callable(double))         # True（有 __call__）
triple = Multiplier(3)
print(triple(5))                # 15

# 有状态的函数（比闭包/全局变量清晰）
class Counter:
    def __init__(self):
        self.count = 0
    def __call__(self):
        self.count += 1
        return self.count

c = Counter()
print(c(), c(), c())            # 1 2 3（状态在实例里）

# 缓存器（记忆化）
class Memoize:
    def __init__(self, func):
        self.func = func
        self.cache = {}
    def __call__(self, *args):
        if args not in self.cache:
            self.cache[args] = self.func(*args)
        return self.cache[args]

@Memoize                        # 类装饰器
def slow(n): return n * n

# 类本身也是可调用的（调用类 = 实例化）
class Point:
    def __init__(self, x, y): self.x, self.y = x, y
p = Point(1, 2)                 # 调用 Point，触发 __init__

⚠️ 核心认知：Python 里「调用」obj() 这个操作是统一的——不管 obj 是函数、类、还是普通对象，obj() 都会去找 obj 的 __call__；函数的 __call__ 执行函数体、类的 __call__（其实是元类的）触发实例化、你自定义类的实例只要实现了 __call__ 就也能被 () 调用。所以「可调用」不是函数的专利，而是「实现了 __call__ 协议」的对象都有的能力，用 callable(obj) 判断。__call__ 最有价值的地方是做「有状态的可调用对象」——普通函数每次调用是无状态的（除非用全局变量或闭包），而一个实现了 __call__ 的类实例，可以把状态（计数、缓存、配置、模型参数）存在 self 里，每次调用时读写这些状态，既能「像函数一样简洁地调用」又能「像对象一样携带丰富状态和其他方法」。这就是为什么很多框架用它：装饰器类（@Memoize）、PyTorch 的 nn.Module（model(x) 触发 forward）、可配置的策略对象、函数式接口的实现。它和「闭包」是两种做「有状态函数」的方式——__call__ 更适合状态复杂、需要多个方法、需要可读性时。

完整版教学

一、什么是可调用对象

先理解「可调用」的含义：

可调用对象（callable）：能用 () 调用的对象
  obj() 这个语法能作用的对象

判断：callable(obj) → True/False

哪些是可调用的：
  ① 函数：def 定义的、lambda
     f()、(lambda: 1)()
  ② 内置函数、方法：
     len()、str.upper()、obj.method()
  ③ 类：
     MyClass()  # 调用类 = 实例化（触发 __new__ + __init__）
     int("5")、list()、dict()
  ④ 定义了 __call__ 的实例：
     obj()  # 触发 obj.__call__()
  ⑤ 其他：内置类型的构造、functools.partial 对象等

哪些不可调用：
  普通数据：42()、"abc"()、[1,2]() → TypeError
  callable(42) → False

统一的调用协议：
  obj() 等价于 type(obj).__call__(obj)
  → 任何对象只要它的类型有 __call__，就可调用
  → 函数、类、自定义实例都是通过 __call__ 统一实现"调用"

为什么"类"可调用：
  类的实例化 C() 本质是"调用类"
  → 由元类（type）的 __call__ 处理（触发 __new__ 和 __init__）

所以可调用对象=能用()调用的(函数/类/定义__call__的实例),callable()判断

可调用对象（callable）：能用 () 调用的对象（obj() 这个语法能作用的对象），用 callable(obj) 判断。哪些是可调用的：① 函数（def 定义的、lambda）、② 内置函数/方法（len、str.upper）、③ 类（MyClass() 调用类 = 实例化、触发 __new__ + __init__）、④ 定义了 __call__ 的实例（obj() 触发 obj.__call__()）、⑤ 其他（functools.partial 对象等）。哪些不可调用：普通数据（42()、"abc"() → TypeError、callable(42) 为 False）。统一的调用协议：obj() 等价于 type(obj).__call__(obj)——任何对象只要它的类型有 __call__ 就可调用（函数、类、自定义实例都通过 __call__ 统一实现调用）。为什么「类」可调用：类的实例化 C() 本质是「调用类」（由元类 type 的 __call__ 处理、触发 __new__ 和 __init__）。理解「可调用对象=能用()调用(函数/类/定义__call__的实例),callable()判断;统一协议 obj()=type(obj).call(obj);类可调用因实例化是调用类(元类的__call__)」，就理解了可调用对象。

二、call 让实例可调用

理解 call 的作用：

__call__：定义在类里，让实例能像函数一样被调用

  class Adder:
      def __init__(self, n):
          self.n = n
      def __call__(self, x):    # 实例被 () 调用时触发
          return x + self.n

  add5 = Adder(5)      # 创建实例（触发 __init__）
  add5(10)             # 调用实例（触发 __call__）→ 15
  → add5(10) 等价 add5.__call__(10)

实例化 vs 调用（区分两个 ()）：
  Adder(5)     # 调用"类" → 创建实例（__init__）
  add5(10)     # 调用"实例" → 触发 __call__
  → 一个是 Adder()、一个是 add5()，别混

__call__ 的签名：
  def __call__(self, *args, **kwargs):
  → 可以接受任意参数，像普通函数一样

有 __call__ 的实例是可调用的：
  callable(add5) → True（因为有 __call__）
  callable(Adder(3)) → True

对比普通函数：
  普通函数：无状态（除非闭包/全局）
  __call__ 实例：有状态（存在 self 里）+ 可调用
  → "既是对象又是函数"

所以__call__让实例像函数一样被()调用(触发__call__),可带状态(存 self)

__call__：定义在类里、让实例能像函数一样被调用——class Adder: def __init__(self, n): ...; def __call__(self, x): return x + self.n，add5 = Adder(5)（触发 __init__）、add5(10)（触发 __call__）→ 15（add5(10) 等价 add5.__call__(10)）。实例化 vs 调用（区分两个 ()）：Adder(5) 调用「类」→ 创建实例（__init__）、add5(10) 调用「实例」→ 触发 __call__（别混）。__call__ 的签名：def __call__(self, *args, **kwargs)（可接受任意参数、像普通函数）。有 __call__ 的实例是可调用的：callable(add5) → True。对比普通函数：普通函数无状态（除非闭包/全局）、__call__ 实例有状态（存 self）+ 可调用（既是对象又是函数）。理解「call__让实例像函数一样被()调用(add5(10)触发__call);区分 Adder(5)调用类实例化 vs add5(10)调用实例;签名可任意参数;实例有 call 则 callable 为真;既是对象又是函数、可带状态」，就掌握了 __call__。

三、有状态的可调用对象

理解 call 做有状态函数的价值：

__call__ 的核心价值：有状态的可调用对象
  实例把状态存在 self 里，每次调用读写状态
  → 既像函数一样调用，又能携带丰富状态

例子1：计数器
  class Counter:
      def __init__(self): self.n = 0
      def __call__(self):
          self.n += 1
          return self.n
  c = Counter()
  c(), c(), c()   # 1, 2, 3（状态在 self.n）

例子2：带配置的函数
  class Scaler:
      def __init__(self, factor, offset):
          self.factor, self.offset = factor, offset
      def __call__(self, x):
          return x * self.factor + self.offset
  transform = Scaler(2, 10)   # 配置好
  transform(5)   # 20（用配置）

例子3：缓存器（记忆化）
  class Memoize:
      def __init__(self, func):
          self.func = func; self.cache = {}
      def __call__(self, *args):
          if args not in self.cache:
              self.cache[args] = self.func(*args)
          return self.cache[args]

例子4：累积统计
  class RunningMean:
      def __init__(self): self.total = 0; self.count = 0
      def __call__(self, x):
          self.total += x; self.count += 1
          return self.total / self.count

vs 全局变量：
  用全局变量存状态 → 污染全局、不可复用
  __call__ 实例：状态封装在实例、可创建多个独立实例

vs 闭包：
  闭包也能有状态（存在闭包变量）
  __call__ 更适合：状态多、需要多个方法、需要可读/可继承

所以__call__做有状态函数:计数器/配置/缓存/统计,状态存 self,比全局/闭包清晰

__call__ 的核心价值：有状态的可调用对象——实例把状态存在 self 里、每次调用读写状态（既像函数一样调用、又能携带丰富状态）。例子1：计数器（self.n += 1、c(), c(), c() → 1,2,3）；例子2：带配置的函数（Scaler(2, 10) 配置好、transform(5) 用配置）；例子3：缓存器（记忆化）（self.cache 存结果）；例子4：累积统计（RunningMean 存 total/count）。vs 全局变量：全局变量污染全局、不可复用、__call__ 实例状态封装在实例、可创建多个独立实例。vs 闭包：闭包也能有状态、__call__ 更适合状态多/需要多个方法/需要可读可继承。理解「__call__做有状态函数:计数器/配置/缓存/累积统计,状态存 self;比全局变量(污染/不可复用)清晰、比闭包适合状态多/多方法/可读可继承」，就掌握了有状态的价值。

四、call vs 闭包

理解两种做有状态函数的方式：

__call__ 实例 vs 闭包（都能做"有状态函数"）：

闭包：
  def make_counter():
      n = 0
      def counter():
          nonlocal n
          n += 1
          return n
      return counter
  c = make_counter()
  c(), c()   # 1, 2（状态在闭包变量 n）

__call__ 实例：
  class Counter:
      def __init__(self): self.n = 0
      def __call__(self):
          self.n += 1; return self.n
  c = Counter()
  c(), c()   # 1, 2（状态在 self.n）

对比：
  维度            闭包           __call__ 实例
  状态位置        闭包变量        self 属性
  访问状态        难（nonlocal）  易（self.n 可读可改）
  多个方法        难（只一个函数） 易（可加多个方法）
  可读/可继承      较隐晦         清晰、可继承
  轻量            更轻            略重（一个类）

选择：
  简单一次性、状态少 → 闭包（轻量）
  状态多/需要暴露状态/多个操作/可继承 → __call__ 实例
  需要重置计数、查询状态 → __call__（c.reset()、c.n）

__call__ 的额外好处：
  ① 状态可直接访问/修改（c.n）
  ② 可以加辅助方法（c.reset()）
  ③ 可继承、可测试（比闭包好测）
  ④ 可 pickle（闭包不能 pickle）

所以__call__ vs 闭包:闭包轻量、__call__适合状态多/多方法/可访问状态/可继承

__call__ 实例 vs 闭包（都能做「有状态函数」）：闭包状态在闭包变量（make_counter 里的 n、nonlocal 修改）、__call__ 实例状态在 self 属性。对比：状态位置（闭包变量 vs self 属性）、访问状态（闭包难需 nonlocal、__call__ 易 self.n 可读可改）、多个方法（闭包难只一个函数、__call__ 易可加多个）、可读/可继承（闭包较隐晦、__call__ 清晰可继承）、轻量（闭包更轻、__call__ 略重）。选择：简单一次性/状态少用闭包（轻量）、状态多/需要暴露状态/多个操作/可继承用 __call__ 实例（需要重置计数、查询状态用 __call__）。__call__ 的额外好处：① 状态可直接访问/修改、② 可加辅助方法、③ 可继承可测试、④ 可 pickle（闭包不能 pickle）。理解「call vs 闭包:闭包轻量(状态在闭包变量、nonlocal 改)、call__适合状态多/多方法/可访问状态(self.n)/可继承/可 pickle;简单用闭包、复杂用__call」，就掌握了两者取舍。

五、典型应用

理解 call 的实际应用：

典型应用：

① 类装饰器（带状态的装饰器）：
   class CountCalls:
       def __init__(self, func):
           self.func = func; self.count = 0
       def __call__(self, *args, **kw):
           self.count += 1
           print(f"第 {self.count} 次调用")
           return self.func(*args, **kw)
   @CountCalls
   def hello(): ...
   → 装饰器需要状态时用类（比函数装饰器 + nonlocal 清晰）

② 策略对象/可配置处理器：
   class Validator:
       def __init__(self, rules): self.rules = rules
       def __call__(self, data): ...
   validate = Validator(my_rules)
   validate(data)

③ 框架的核心抽象（PyTorch/Keras）：
   class MyModel(nn.Module):
       def forward(self, x): ...
   model = MyModel()
   model(x)     # 触发 __call__ → 内部调 forward（还做钩子等）
   → "模型像函数一样调用"

④ 缓存器/记忆化：
   Memoize 类（见前）

⑤ 偏函数/柯里化的对象版：
   带配置的可调用对象，比 partial 更灵活

⑥ 计数器、累加器、状态机

什么时候用 __call__：
  ① 一个对象"主要行为"就是被调用（且有状态/配置）
  ② 需要"函数的调用语法" + "对象的状态和方法"
  ③ 装饰器需要状态

什么时候不用：
  纯无状态逻辑 → 普通函数
  简单状态 → 闭包

所以应用:类装饰器/策略对象/框架核心(nn.Module)/缓存器/计数器

典型应用：① 类装饰器（带状态的装饰器）（CountCalls 类存 count、装饰器需要状态时用类比函数装饰器+nonlocal 清晰）；② 策略对象/可配置处理器（Validator(rules) 配置好、validate(data)）；③ 框架的核心抽象（PyTorch/Keras）（model(x) 触发 __call__ → 内部调 forward、还做钩子、模型像函数一样调用）；④ 缓存器/记忆化；⑤ 偏函数/柯里化的对象版；⑥ 计数器、累加器、状态机。什么时候用 __call__：① 对象主要行为就是被调用（且有状态/配置）、② 需要函数调用语法 + 对象状态和方法、③ 装饰器需要状态。什么时候不用：纯无状态逻辑用普通函数、简单状态用闭包。理解「应用:类装饰器(带状态)/策略对象/框架核心 nn.Module(model(x)触发__call__调 forward)/缓存器/计数器;用__call__当对象主要行为是被调用且有状态/装饰器需要状态;无状态用函数、简单状态用闭包」，就掌握了典型应用。

六、总结与实践

总结可调用对象：

可调用对象：
  能用 () 调用的对象
  = 函数 + 类 + 定义 __call__ 的实例
  callable(obj) 判断

统一调用协议：
  obj() = type(obj).__call__(obj)
  → 函数、类、自定义实例都通过 __call__ 实现调用

__call__：
  让实例像函数一样被调用
  区分：C()（调用类=实例化）vs obj()（调用实例=触发__call__）

核心价值——有状态的可调用对象：
  状态存在 self，每次调用读写
  → 既能函数式调用，又能携带丰富状态和方法

vs 闭包：
  闭包轻量（状态少、一次性）
  __call__ 适合：状态多、需暴露状态、多个方法、可继承、可 pickle

典型应用：
  类装饰器、策略对象、框架核心（nn.Module）、缓存器、计数器

选择：
  无状态 → 普通函数
  简单状态 → 闭包
  复杂状态/多方法/框架抽象 → __call__ 实例

核心总结：
  可调用对象=能()调用的（函数/类/有__call__的实例）
  __call__ 让实例可调用、带状态
  比闭包适合复杂状态/多方法

所以可调用对象=能()调用的,__call__让实例像函数调用+带状态,复杂状态用它

可调用对象：能用 () 调用的对象（函数 + 类 + 定义 __call__ 的实例）、callable(obj) 判断。统一调用协议：obj() = type(obj).__call__(obj)。__call__：让实例像函数一样被调用（区分 C() 调用类=实例化 vs obj() 调用实例=触发 __call__）。核心价值——有状态的可调用对象：状态存 self、每次调用读写（既能函数式调用又能携带丰富状态和方法）。vs 闭包：闭包轻量（状态少）、__call__ 适合状态多/需暴露状态/多个方法/可继承/可 pickle。典型应用：类装饰器、策略对象、框架核心、缓存器、计数器。理解「可调用对象=能()调用(函数/类/有__call__实例);obj()=type(obj).call(obj);call__让实例可调用+带状态;比闭包适合复杂状态/多方法;无状态用函数、简单状态用闭包、复杂用__call」，就掌握了总结与实践。

记忆钩子：「Python 的『可调用对象(callable)』=能像函数一样用()调用的对象,不只是函数——还包括:①普通函数/lambda②内置函数/方法③★类本身(MyClass()是调用类、触发__new__+__init__返回实例)④★定义了__call__方法的类的实例(obj()会触发 obj.call());用内置 callable(obj)判断能否调用;★统一调用协议:obj()等价于 type(obj).call(obj),任何对象只要它的类型有__call__就可调用;★call__的核心价值:让实例像函数一样被调用,从而做『有状态的函数』——实例把状态(计数/缓存/配置/模型参数)存在 self 里,每次调用读写这些状态,既能像函数一样简洁调用、又能像对象一样携带丰富状态和其他方法(class Counter:def call(self):self.n+=1;return self.n,c();c()返回 1,2);区分两个():Adder(5)是调用『类』做实例化、add5(10)是调用『实例』触发__call;★vs 闭包:两者都能做有状态函数,闭包轻量(状态在闭包变量、nonlocal 改)、__call__适合状态多/需要暴露状态(self.n 可访问)/需要多个方法/可继承/可 pickle(闭包不能 pickle);典型应用:类装饰器(带状态)、策略对象、框架核心(PyTorch 的 nn.Module,model(x)触发__call__调 forward)、缓存器、计数器」。

七、常见误区与追问

  • 误区：只有函数才能用 () 调用。 不是——Python 里「可调用对象」包括函数、lambda、内置函数/方法、类本身（MyClass() 是调用类、做实例化）、以及任何定义了 __call__ 方法的类的实例（obj() 触发 obj.__call__()）；() 调用是一个统一的协议，obj() 本质是 type(obj).__call__(obj)；用 callable(obj) 可以判断一个对象能不能被调用。
  • 误区：C() 和 obj() 是一回事。 不同——C()（C 是类）是「调用类」、也就是实例化，会触发 __new__ 和 __init__、返回一个新实例；obj()（obj 是实例）是「调用实例」，会触发这个实例的 __call__ 方法（前提是它的类定义了 __call__）；比如 add5 = Adder(5) 里 Adder(5) 是实例化、add5(10) 是调用实例；两个 () 作用在不同层级的对象上、触发不同的机制，别混淆。
  • 误区：call 和 init 是一回事。 不同——__init__ 在「实例化时」（Adder(5)）调用一次、负责初始化实例的状态；__call__ 在「实例被当函数调用时」（add5(10)）调用、可以调用任意多次、负责实例被调用时的行为；一个对象生命周期里 __init__ 通常只跑一次、__call__ 可以跑很多次；有状态的可调用对象一般在 __init__ 里初始化状态、在 __call__ 里读写状态。
  • 误区：要做有状态的函数只能用全局变量。 有更好的方式——用全局变量存状态会污染全局命名空间、无法创建多个独立实例、难以复用和测试；更好的是用「闭包」（状态存在闭包变量里）或「__call__ 实例」（状态存在 self 里）；闭包适合简单、一次性、状态少的场景；__call__ 实例适合状态多、需要访问/重置状态、需要多个相关方法、需要可继承或可序列化的场景；两者都能封装状态、创建多个互不干扰的实例。
  • 追问：什么是可调用对象，怎么判断一个对象是否可调用？ 可调用对象是指「能用 () 语法调用」的对象，包括：普通函数和 lambda、内置函数、绑定/未绑定方法、类（调用类做实例化）、以及定义了 __call__ 方法的类的实例；判断用内置函数 callable(obj)，返回 True 表示可以 obj()、False 表示不能（如整数、字符串、列表都不可调用）；底层原理是：obj() 会去找 type(obj).__call__，只要对象的类型（类）定义了 __call__，这个对象就是可调用的——函数、方法、类之所以可调用，都是因为它们的类型实现了 __call__。
  • 追问：call 有什么实际用途，能举几个例子吗？ __call__ 让实例「像函数一样被调用」，核心价值是做「有状态的可调用对象」：① 计数器/累加器——状态（计数、累计值）存在 self 里，每次调用更新并返回（class Counter: def __call__(self): self.n += 1; return self.n）；② 带配置的处理器/策略对象——__init__ 里接收配置、__call__ 里用配置处理数据（Scaler(factor, offset) 然后 scaler(x)）；③ 记忆化缓存器——把函数和缓存字典存在实例里、__call__ 里查缓存或计算；④ 类装饰器——需要状态的装饰器用类实现（@CountCalls 统计调用次数）；⑤ 框架的核心抽象——PyTorch 的 nn.Module、Keras 的层都实现了 __call__，model(x) 触发 __call__（内部再调 forward、并处理钩子等），让「模型像函数一样调用」；这些场景都需要「函数式的调用语法 + 对象的状态和方法」，正是 __call__ 的强项。
  • 追问：用 call 实例和用闭包来实现有状态的函数，怎么选？ 两者都能封装状态、创建多个独立实例，区别在于：闭包更轻量（一个函数、状态藏在闭包变量里），但访问/修改状态要靠 nonlocal、只能有一个「函数入口」、状态对外不可见、不能 pickle、不好继承和测试；__call__ 实例是一个完整的类，状态存在 self 属性里、可以直接读写（c.n）、可以定义多个相关方法（如 c.reset()、c.stats()）、清晰可继承、可测试、可序列化（pickle）；选择标准：如果只是「简单的、一次性的、状态很少」的有状态函数，用闭包（简洁轻量）；如果「状态较多、需要对外暴露或重置状态、需要多个相关操作、需要继承或序列化」，用 __call__ 实例（结构清晰、功能完整）；比如一个简单计数器用闭包就够，一个带缓存+统计+重置功能的处理器就该用 __call__ 类。

八、加强记忆

Python 的「可调用对象（callable）」= 能像函数一样用 () 调用的对象，不只是函数——还包括：① 普通函数/lambda、② 内置函数/方法、③ 类本身（MyClass() 是调用类、触发 __new__ + __init__ 返回实例）、④ 定义了 __call__ 方法的类的实例（obj() 会触发 obj.__call__()）；用内置 callable(obj) 判断能否调用。统一调用协议：obj() 等价于 type(obj).__call__(obj)，任何对象只要它的类型有 __call__ 就可调用。__call__ 的核心价值：让实例像函数一样被调用，从而做「有状态的函数」——实例把状态（计数/缓存/配置/模型参数）存在 self 里、每次调用读写这些状态，既能像函数一样简洁调用、又能像对象一样携带丰富状态和其他方法（class Counter: def __call__(self): self.n += 1; return self.n，c(); c() 返回 1, 2）。区分两个 ()：Adder(5) 是调用「类」做实例化、add5(10) 是调用「实例」触发 __call__。vs 闭包：两者都能做有状态函数，闭包轻量（状态在闭包变量）、__call__ 适合状态多/需要暴露状态/需要多个方法/可继承/可 pickle。典型应用：类装饰器、策略对象、框架核心（PyTorch 的 nn.Module，model(x) 触发 __call__ 调 forward）、缓存器、计数器。一句话「可调用对象=能用()调用的(函数/类/定义__call__的实例),callable()判断,obj()=type(obj).call(obj);__call__让实例像函数一样调用、可带状态(存 self);比闭包适合复杂状态/多方法/可继承;应用类装饰器/策略对象/框架核心/缓存器」。