继承与多态

在面向对象编程中，继承和多态是两个核心概念，它们帮助我们构建更灵活和可扩展的代码。Swift 是一门支持面向对象编程的语言，它提供了类继承和多态的机制，使得开发者能够实现代码复用、扩展和灵活性。

1. 继承

继承是指子类从父类继承属性和方法，从而能够重用父类的代码并扩展其功能。继承是面向对象编程的一个关键特性，它使得类之间可以建立层级关系。

继承的基本语法

在 Swift 中，通过 class 关键字定义类，并使用冒号（:）继承自父类。子类可以访问父类的属性和方法，并可以重写父类的方法和属性。

class Animal {
    var name: String

    init(name: String) {
        self.name = name
    }

    func speak() {
        print("\(name) makes a sound.")
    }
}

class Dog: Animal {
    var breed: String

    init(name: String, breed: String) {
        self.breed = breed
        super.init(name: name)
    }

    override func speak() {
        print("\(name) barks.")
    }
}

let dog = Dog(name: "Buddy", breed: "Golden Retriever")
dog.speak()  // 输出 "Buddy barks."

在上面的代码中，Dog 类继承自 Animal 类。Dog 类通过 super.init 调用父类的构造函数，并重写了 speak 方法。

父类方法的重写

子类可以重写父类的方法，以提供不同的实现。使用 override 关键字标明方法是重写的方法。

class Animal {
    func speak() {
        print("Animal makes a sound.")
    }
}

class Dog: Animal {
    override func speak() {
        print("Dog barks.")
    }
}

let animal = Animal()
animal.speak()  // 输出 "Animal makes a sound."

let dog = Dog()
dog.speak()  // 输出 "Dog barks."

在这个例子中，Dog 类重写了 Animal 类的 speak 方法。当 Dog 类调用 speak 方法时，会执行子类中的实现，而不是父类中的实现。

2. 多态

多态是指同一操作作用于不同的对象时，能够产生不同的结果。在 Swift 中，多态通过继承和方法重写来实现。多态使得我们能够用相同的接口操作不同类型的对象。

静态多态 vs 动态多态

  • 静态多态（编译时多态）：方法重载和操作符重载。
  • 动态多态（运行时多态）：通过继承和方法重写实现，不同的对象可以有不同的行为。

动态多态的例子

多态的核心在于基类类型的引用或指针可以指向任何子类的实例，这样就能够在运行时决定调用哪个版本的方法。

class Animal {
    func speak() {
        print("Animal makes a sound.")
    }
}

class Dog: Animal {
    override func speak() {
        print("Dog barks.")
    }
}

class Cat: Animal {
    override func speak() {
        print("Cat meows.")
    }
}

let animals: [Animal] = [Dog(), Cat()]

for animal in animals {
    animal.speak()
}
// 输出：
// Dog barks.
// Cat meows.

在这个例子中，animals 数组存储了 Dog 和 Cat 的实例。尽管数组的类型是 Animal，但 Swift 会根据实际对象的类型（Dog 或 Cat）来调用适当的 speak 方法，这是通过动态多态实现的。

3. 重写属性

除了方法之外，子类还可以重写父类的属性。这通常用于修改属性的 getter 或 setter 行为。

重写存储属性

子类可以通过定义自己的存储属性来重写父类的存储属性。然而，如果父类的属性是常量或只读属性，子类是不能重写它的。

class Animal {
    var name: String

    init(name: String) {
        self.name = name
    }
}

class Dog: Animal {
    override var name: String {
        get {
            return "Dog: \(super.name)"
        }
        set {
            super.name = newValue
        }
    }
}

let dog = Dog(name: "Buddy")
print(dog.name)  // 输出 "Dog: Buddy"
dog.name = "Max"
print(dog.name)  // 输出 "Dog: Max"

在这个例子中，Dog 类重写了 name 属性，使用 getter 和 setter 修改了父类属性的访问行为。

重写计算属性

子类可以重写父类的计算属性，并改变其计算逻辑。

class Animal {
    var name: String

    init(name: String) {
        self.name = name
    }

    // 计算属性
    var description: String {
        return "Animal: \(name)"
    }
}

class Dog: Animal {
    override var description: String {
        return "Dog: \(name)"
    }
}

let animal = Animal(name: "Generic Animal")
print(animal.description)  // 输出 "Animal: Generic Animal"

let dog = Dog(name: "Buddy")
print(dog.description)  // 输出 "Dog: Buddy"

在这个例子中，Dog 类重写了 description 计算属性，返回了不同的描述信息。

4. 抽象类与协议

尽管 Swift 不支持传统意义上的抽象类，但你可以使用协议（Protocol）来定义一个抽象的接口，然后让不同的类实现它。通过协议，Swift 提供了一种灵活的方式来实现多态。

protocol Speakable {
    func speak()
}

class Dog: Speakable {
    func speak() {
        print("Dog barks.")
    }
}

class Cat: Speakable {
    func speak() {
        print("Cat meows.")
    }
}

let speakables: [Speakable] = [Dog(), Cat()]

for speakable in speakables {
    speakable.speak()
}
// 输出：
// Dog barks.
// Cat meows.

在这个例子中，Speakable 协议定义了一个 speak 方法，Dog 和 Cat 类都实现了该协议。通过协议的方式，我们实现了多态，而不需要依赖继承。

5. 总结

  • 继承：允许子类继承父类的属性和方法，能够重用代码并扩展功能。
  • 多态：通过方法重写，允许相同的操作作用于不同类型的对象，在运行时确定调用的具体方法。
  • 方法重写：子类可以重写父类的方法，提供特定的实现。
  • 属性重写：子类可以重写父类的属性，修改其 getter 和 setter 行为。
  • 协议：通过协议，Swift 提供了一种方式来实现抽象和多态，允许不同类型的对象遵循相同的接口。

通过继承和多态，Swift 支持高度灵活的代码组织方式，允许开发者在保持代码复用的同时，灵活地定制不同类型的行为。

Last Updated::