如何调用父类方法时使其引用同名子类依赖类？

核心思路是避免在父类中硬编码依赖类（如Obj），而是通过类属性暴露可配置的默认类，子类只需重写该属性即可让父类自动使用自定义子类。

1. 修改父类（src.py），引入可配置类属性 #

将Foo中硬编码的Obj()替换为类属性引用，让父类的初始化逻辑依赖这个可配置的属性：

# src.py
class Obj:
    def __init__(self, a=1, b=1): 
        self.a = a 
        self.b = b

class Foo:
    # 定义默认使用的Obj类，作为可配置的类属性
    default_obj_class = Obj

    def __init__(self, obj=None):
        # 用类属性替代硬编码的Obj
        self.obj = self.default_obj_class() if obj is None else obj
        # 其他原有初始化逻辑...

2. 子类（main.py）重写类属性即可 #

无需重复父类的obj判断逻辑，仅需重写default_obj_class指向自定义的Obj子类：

# main.py
import src

class Obj(src.Obj):
    def __init__(self, z=0, **kwargs):
        self.z = z
        super().__init__(**kwargs)

class Foo(src.Foo):
    # 重写类属性，替换为自定义的Obj子类
    default_obj_class = Obj

    def __init__(self, obj=None):
        super().__init__(obj)
        # 子类专属的初始化逻辑（如果有）...

这样调用super().__init__(obj)时，父类会自动使用子类的default_obj_class创建实例，完全避免重复代码。

扩展到多依赖类场景（你的实际项目） #

针对你提到的Game依赖HouseRules、Card、Player三个类的场景，同样可以用这种模式：

修改src.py中的Game类 #

# src.py
class HouseRules:
    # 原有逻辑...
class Card:
    # 原有逻辑...
class Player:
    # 原有逻辑...

class Game:
    # 定义三个可配置的默认类属性
    default_rules_class = HouseRules
    default_card_class = Card
    default_player_class = Player

    def __init__(self, rules=None, card=None, player=None):
        self.rules = self.default_rules_class() if rules is None else rules
        self.card = self.default_card_class() if card is None else card
        self.player = self.default_player_class() if player is None else player
        # 其他原有逻辑...

在main.py中自定义子类并替换属性 #

# main.py
import src

class CustomHouseRules(src.HouseRules):
    # 新增属性和方法...
class CustomCard(src.Card):
    # 新增属性和方法...
class CustomPlayer(src.Player):
    # 新增属性和方法...

class CustomGame(src.Game):
    # 重写三个类属性，指向自定义子类
    default_rules_class = CustomHouseRules
    default_card_class = CustomCard
    default_player_class = CustomPlayer

    def __init__(self, rules=None, card=None, player=None):
        super().__init__(rules, card, player)
        # 子类专属逻辑...

其他可选方案（如果无法修改父类） #

如果src.py是第三方库无法修改，可以在子类的__init__中先调用父类初始化，再替换实例：

# main.py
class Foo(src.Foo):
    def __init__(self, obj=None):
        if obj is None:
            obj = Obj()
        super().__init__(obj)

但这种方式不如类属性方案优雅，仅作为临时替代。

最佳实践总结 #

• 父类通过类属性暴露依赖类的默认实现，避免硬编码
• 子类仅需重写类属性即可替换依赖，最大化复用父类逻辑
• 多依赖类场景下统一使用该模式，保持代码一致性和可维护性

内容的提问来源于stack exchange，提问作者WeCanDoItGuys