【Ruby继承机制深度解析】：掌握5大核心示例，轻松搞定面向对象编程

方法注入层级对比

• include：将模块方法作为实例方法注入
• extend：将模块方法作为单例方法（类方法）添加

3.2 混入模块对继承链的影响

方法解析顺序的变化

class Serializable:
    def serialize(self):
        return f"Serialized {self.__class__.__name__}"

class TimestampMixin:
    def save(self):
        print("Timestamp updated")
        super().save() if hasattr(super(), 'save') else None

class User(TimestampMixin, Serializable):
    def save(self):
        print("User saved")

属性与方法冲突管理

• 命名空间污染风险增加
• 相同方法名需谨慎处理调用链
• 推荐使用前缀或私有方法避免冲突

3.3 实践：通过模块实现共享功能

模块结构设计

package logger

import "fmt"

var LogLevel = "INFO"

func Log(level, msg string) {
    if level >= LogLevel {
        fmt.Printf("[%s] %s\n", level, msg)
    }
}

依赖管理与版本控制

• 高内聚：模块只提供单一职责功能
• 松耦合：通过接口而非具体实现通信
• 可测试：内置单元测试，保障稳定性

第四章：继承中的属性与初始化控制

4.1 子类中安全重写父类初始化方法

调用父类初始化的规范方式

class Parent:
    def __init__(self, name):
        self.name = name
        print("Parent initialized")

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)  # 确保父类初始化
        self.age = age
        print("Child initialized")

常见错误与规避策略

• 遗漏 super().__init__() 导致属性缺失
• 参数传递不完整引发类型错误
• 在多继承中忽略 MRO（方法解析顺序）

4.2 访问控制（public/protected/private）在继承中的表现

继承中的访问权限规则

• public 继承：基类的 public 成员在派生类中仍为 public，protected 成员保持 protected，private 成员不可访问。
• protected 继承：基类的 public 和 protected 成员在派生类中变为 protected。
• private 继承：所有基类的 public 和 protected 成员在派生类中变为 private。

代码示例与分析

class Base {
public:
    int pub = 1;
protected:
    int prot = 2;
private:
    int priv = 3;
};

class Derived : public Base {
public:
    void access() {
        pub = 10;   // 允许：public 成员可被访问
        prot = 20;  // 允许：protected 成员在派生类中可见
        // priv = 30; // 错误：private 成员不可访问
    }
};

4.3 覆盖与重载实例方法的最佳实践

方法覆盖示例

@Override
public void execute() {
    System.out.println("子类执行逻辑");
}

重载规则与建议

• 重载方法必须参数列表不同（类型、数量或顺序）
• 返回类型可不同，但不能仅靠返回类型区分
• 建议避免过多重载，防止调用歧义

4.4 实践：设计高内聚低耦合的继承体系

继承设计原则

• 单一职责：每个类只负责一个明确的功能维度
• 里氏替换：子类可无缝替换父类而不破坏行为
• 依赖倒置：高层模块不应依赖低层实现细节

代码示例：合理使用抽象基类

public abstract class PaymentProcessor {
    public final void process(double amount) {
        validate(amount);
        executePayment(amount);
    }
    protected abstract void executePayment(double amount);
    private void validate(double amount) {
        if (amount <= 0) throw new IllegalArgumentException();
    }
}

第五章：总结与面向对象设计启示

设计原则的实际落地

• 开闭原则指导我们通过接口扩展折扣策略，而非修改原有代码
• 依赖倒置使支付网关切换成本降低，新接入第三方支付仅需实现PaymentGateway接口

代码结构优化示例

// 定义支付网关接口
type PaymentGateway interface {
    Process(amount float64) error
}

// 支付服务依赖抽象
type PaymentService struct {
    gateway PaymentGateway
}

func (s *PaymentService) Charge(amount float64) error {
    return s.gateway.Process(amount) // 运行时注入具体实现
}

常见反模式对比