Swift 继承（一文讲透）

Swift 继承：从零开始理解面向对象的“血缘关系”

在 Swift 编程中，继承是构建代码复用和层级结构的核心机制之一。如果你把类比作一个家族，那么“继承”就是家族成员之间传递姓氏、基因和家训的过程。Swift 继承允许我们创建一个类（子类），从另一个类（父类）那里“继承”属性、方法和下标等特性，同时还能在子类中扩展或重写这些功能。

这就像你继承了父亲的身高基因，但通过锻炼又长高了一些——既保留了原有特性，又加入了自己独特的成长痕迹。

Swift 继承不是魔法，而是一种有明确规则的代码组织方式。它帮助我们在开发中避免重复编写相同的逻辑，让代码更清晰、更易维护。今天我们就来深入理解 Swift 继承的方方面面，从基础语法到实际应用，一步步带你掌握这一核心概念。

什么是 Swift 继承？它解决了什么问题？

在没有继承之前，如果你要写多个相似的类，比如“汽车”、“自行车”、“电动车”，它们都有“启动”、“停止”、“速度”这样的共同行为，你会怎么做？最原始的做法是为每个类分别写一遍相同的代码。

但这样会导致一个问题：一旦“启动”逻辑需要修改（比如增加安全检测），你必须在所有类中逐一修改。这不仅效率低，还容易出错。

而 Swift 继承的出现，就是为了解决这类“重复代码”的问题。通过定义一个通用的父类（比如 Vehicle），让所有交通工具都继承它，这样就能共享通用行为，只在需要时覆盖特殊逻辑。

// 定义一个父类：Vehicle（交通工具）
class Vehicle {
    // 公共属性：速度
    var speed: Double = 0.0
    
    // 公共方法：启动车辆
    func start() {
        print("车辆已启动")
    }
    
    // 公共方法：停止车辆
    func stop() {
        print("车辆已停止")
    }
}

这里我们定义了一个 Vehicle 类，它有速度属性和启动、停止两个方法。接下来，我们让其他类来“继承”它。

如何声明继承关系？

在 Swift 中，使用冒号 : 来表示继承关系。语法格式为：

class 子类名: 父类名 {
    // 子类的属性和方法
}

实际案例：创建一个汽车类

// 定义一个子类 Car，继承自 Vehicle
class Car: Vehicle {
    // 新增属性：燃油量
    var fuelLevel: Double = 100.0
    
    // 重写父类的 start 方法，增加燃油检查逻辑
    override func start() {
        if fuelLevel > 0 {
            print("汽车启动中，燃油充足")
        } else {
            print("燃油不足，无法启动")
        }
    }
    
    // 新增方法：加油
    func refuel(amount: Double) {
        fuelLevel += amount
        print("已加油 \(amount) 升，当前燃油量：\(fuelLevel) 升")
    }
}

🔍 重点说明：

• Car: Vehicle 表示 Car 类继承自 Vehicle 类。
• override 关键字用于标记重写父类方法。这是强制要求，防止误写。
• fuelLevel 是子类独有的属性，父类中没有。
• refuel 方法是子类新增的功能，父类没有。

验证继承效果

let myCar = Car()
myCar.start()       // 输出：汽车启动中，燃油充足
myCar.fuelLevel = 0
myCar.start()       // 输出：燃油不足，无法启动
myCar.refuel(amount: 50)
// 输出：已加油 50.0 升，当前燃油量：50.0 升

通过这个例子可以看到，Car 类不仅继承了 speed 属性和 stop() 方法，还通过 override 改写了 start() 方法，实现了更智能的行为。

继承中的重写（Override）与调用父类方法

当你在子类中重写一个方法时，有时你并不想完全覆盖父类的逻辑，而是想在原有基础上扩展。这时候就可以使用 super 关键字调用父类的方法。

比如：在启动时先执行父类逻辑，再加新功能

class ElectricCar: Vehicle {
    var batteryLevel: Double = 80.0
    
    // 重写 start 方法
    override func start() {
        // 先调用父类的 start 方法
        super.start()
        
        // 再执行子类特有的逻辑
        if batteryLevel > 20 {
            print("电动马达已激活")
        } else {
            print("电池电量过低，无法启动")
        }
    }
    
    // 新增方法：充电
    func charge(amount: Double) {
        batteryLevel += amount
        print("已充电 \(amount) %，当前电量：\(batteryLevel) %")
    }
}

✅ super.start() 的作用是调用父类的 start() 方法，确保“车辆已启动”这条信息依然输出。

使用示例

let myElectricCar = ElectricCar()
myElectricCar.start()
// 输出：
// 车辆已启动
// 电动马达已激活

这个例子说明：继承不是“取代”，而是“扩展”。你可以在保留原有功能的基础上，加入新逻辑。

属性继承与存储属性的重写

Swift 支持对属性进行继承，包括存储属性和计算属性。但要注意：子类不能重写父类的存储属性，除非你显式使用 override 关键字并定义为 lazy 或 final。

子类重写计算属性

class Bicycle: Vehicle {
    // 父类的 speed 是存储属性，子类无法直接重写
    // 但可以重写计算属性
    override var speed: Double {
        // 重写 get 方法
        get {
            return super.speed * 0.8  // 自行车速度是父类的 80%
        }
        set {
            // 重写 set 方法，限制最大值为 30
            super.speed = min(newValue, 30.0)
        }
    }
}

⚠️ 注意：speed 在父类中是存储属性，子类只能通过 override 重写为计算属性，不能直接覆盖存储属性。

测试效果

let myBicycle = Bicycle()
myBicycle.speed = 40  // 实际赋值为 30.0，因为有上限
print(myBicycle.speed) // 输出：24.0（30 * 0.8）

这个例子展示了：继承中的属性重写，是一种“行为定制”的手段。你可以在不修改父类代码的前提下，调整属性的读取和设置逻辑。

继承与初始化：构造器的传递与调用

在 Swift 中，构造器（init）也支持继承。子类的构造器必须确保父类的构造器被调用。

父类构造器

class Plane: Vehicle {
    var altitude: Double = 0.0
    
    // 重写父类的构造器
    init(altitude: Double) {
        self.altitude = altitude
        super.init()  // 必须调用父类的初始化方法
    }
}

❗ 关键点：子类构造器必须调用 super.init()，否则编译报错。

多层继承的构造器链

如果存在多层继承，构造器调用链会从子类向上追溯，直到最顶层的父类。

class Jet: Plane {
    var thrust: Double = 0.0
    
    init(altitude: Double, thrust: Double) {
        self.thrust = thrust
        super.init(altitude: altitude)  // 调用 Plane 的构造器
    }
}

使用示例

let fighterJet = Jet(altitude: 10000, thrust: 1500)
print("飞行高度：\(fighterJet.altitude) 米，推力：\(fighterJet.thrust)")
// 输出：飞行高度：10000.0 米，推力：1500.0

这个过程就像一场接力赛：每一代都必须完成自己的初始化任务，才能传递给下一代。

继承的最佳实践与常见误区

✅ 最佳实践

❌ 常见误区

• 误以为继承可以“复制”所有内容：继承的是“接口”和“行为”，不是“代码副本”。
• 忽略 super 的调用：子类构造器必须调用父类构造器，否则编译失败。
• 滥用继承导致类之间耦合过强：过度使用继承会让代码难以测试和修改。

总结：Swift 继承是构建可维护代码的基石

通过今天的学习，我们了解了 Swift 继承的核心机制：从父类中“继承”属性和方法，通过 override 重写行为，使用 super 调用父类逻辑，合理设计构造器链。

它不是为了“炫技”，而是为了让代码更清晰、更易扩展、更少重复。就像建筑中的承重墙，继承结构为整个应用提供了稳定的架构支持。

当你在项目中看到多个类有大量相似代码时，不妨停下来想一想：是否可以抽象出一个父类？是否能通过 Swift 继承来简化设计？

记住：好的继承不是“复制粘贴”，而是“合理分层”。掌握它，你就能写出更优雅、更专业的 Swift 代码。

继承相关关键词对照表

希望这篇文章能帮你真正理解 Swift 继承的本质。别忘了动手写几行代码试试，实践才是掌握的最好方式。