如何解耦父类BaseClass与子类依赖，同时保留方法重写特性？

1. 用参数对象封装父类依赖 #

把BaseClass构造函数的零散依赖打包成一个独立的配置类，比如BaseClassConfig。父类构造函数只接收这个配置对象，后续新增依赖只需要在配置类里加字段，子类构造函数不需要修改，只需要传递这个配置对象就行，从根源上减少子类的改动量。

示例代码：

# 封装依赖的配置类
class BaseClassConfig:
    def __init__(self, dep1, dep2, dep3):
        self.dep1 = dep1
        self.dep2 = dep2
        self.dep3 = dep3
        # 后续加新依赖直接在这里加属性

# 父类只接收配置对象
class BaseClass:
    def __init__(self, config):
        self.dep1 = config.dep1
        self.dep2 = config.dep2
        self.dep3 = config.dep3

# 子类只需传递配置对象，父类加依赖也不用改子类
class SubClassA(BaseClass):
    def __init__(self, config):
        super().__init__(config)
        # 子类自身的初始化逻辑

2. 用依赖注入框架托管父类依赖 #

如果项目里有依赖注入框架（比如Java的Spring、Python的inject），可以把BaseClass的依赖交给框架自动注入。子类构造函数不需要手动传递父类的依赖，框架会自动把父类需要的依赖填进去。后续父类新增依赖，只需要在框架里配置，子类完全不用动。

示例代码（Python inject）：

import inject

# 定义依赖类
class Dep1: pass
class Dep2: pass

# 配置依赖注入规则
def configure_di(binder):
    binder.bind(Dep1, Dep1())
    binder.bind(Dep2, Dep2())

inject.configure(configure_di)

# 父类通过注入获取依赖，不用子类传参
class BaseClass:
    @inject.autoparams()
    def __init__(self, dep1: Dep1, dep2: Dep2):
        self.dep1 = dep1
        self.dep2 = dep2

# 子类构造函数不用管父类依赖，直接调用父类构造即可
class SubClassA(BaseClass):
    def __init__(self):
        super().__init__()
        # 子类自身逻辑

3. 把可变依赖从构造函数移到方法里 #

如果BaseClass的某些依赖不是初始化必须的，或者是运行时才用到的，可以把这些依赖从构造函数移到具体的业务方法中。这样构造函数只保留稳定的固定依赖，后续新增依赖只需要修改对应方法，子类构造函数不用动。

示例代码：

class BaseClass:
    def __init__(self, fixed_dep):
        # 只保留稳定的固定依赖
        self.fixed_dep = fixed_dep

    def do_business(self, dynamic_dep):
        # 动态依赖在调用方法时传入
        self.fixed_dep.process()
        dynamic_dep.handle()

# 子类重写方法不受影响，构造函数也不用改
class SubClassA(BaseClass):
    def do_business(self, dynamic_dep):
        super().do_business(dynamic_dep)
        # 子类自定义业务逻辑

4. 组合+委托保留继承特性的同时解耦 #

把BaseClass里频繁变动的逻辑抽成一个独立的服务类，BaseClass依赖这个服务类，构造函数只接收服务类实例。后续父类逻辑变更只需要修改服务类，子类构造函数不需要改动。同时子类依然可以继承BaseClass并重写方法，完全保留原有的继承特性。

示例代码：

# 抽离可变逻辑到服务类
class BaseLogicService:
    def __init__(self, dep1, dep2):
        self.dep1 = dep1
        self.dep2 = dep2

    def core_logic(self):
        # 原本BaseClass里频繁变动的逻辑
        pass

# 父类依赖服务类，构造函数参数稳定
class BaseClass:
    def __init__(self, logic_service):
        self.logic_service = logic_service

    def do_work(self):
        self.logic_service.core_logic()

# 子类继承父类，只传服务类实例，重写方法不受影响
class SubClassA(BaseClass):
    def do_work(self):
        super().do_work()
        # 子类自定义逻辑

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