是否有一种标准方法可以在Swift中制作“纯虚函数”，即。一个必须由每个子类中被覆盖，并且，如果不是的话，将导致编译时错误？

您有两种选择：

1.使用协议

将超类定义为协议而不是类

Pro：编译时检查每个“子类”（不是实际的子类）是否实现了所需的方法

缺点：“超类”（协议）无法实现方法或属性

2.声明该方法的超级版本

例：

class SuperClass {
    func someFunc() {
        fatalError("Must Override")
    }
}

class Subclass : SuperClass {
    override func someFunc() {
    }
}

Pro：可以在超类中实现方法和属性

缺点：不检查编译时间

以下允许从类继承，也可以进行协议的编译时检查：）

protocol ViewControllerProtocol {
    func setupViews()
    func setupConstraints()
}

typealias ViewController = ViewControllerClass & ViewControllerProtocol

class ViewControllerClass : UIViewController {

    override func viewDidLoad() {
        self.setup()
    }

    func setup() {
        guard let controller = self as? ViewController else {
            return
        }

        controller.setupViews()
        controller.setupConstraints()
    }

    //.... and implement methods related to UIViewController at will

}

class SubClass : ViewController {

    //-- in case these aren't here... an error will be presented
    func setupViews() { ... }
    func setupConstraints() { ... }

}

不支持抽象类/虚函数，但在大多数情况下，您可以使用协议：

protocol SomeProtocol {
    func someMethod()
}

class SomeClass: SomeProtocol {
    func someMethod() {}
}

如果SomeClass没有实现someMethod，则会出现此编译时错误：

error: type 'SomeClass' does not conform to protocol 'SomeProtocol'

如果您没有太多的“虚拟”方法，另一种解决方法是让子类将“实现”作为函数对象传递给基类构造函数：

class MyVirtual {

    // 'Implementation' provided by subclass
    let fooImpl: (() -> String)

    // Delegates to 'implementation' provided by subclass
    func foo() -> String {
        return fooImpl()
    }

    init(fooImpl: (() -> String)) {
        self.fooImpl = fooImpl
    }
}

class MyImpl: MyVirtual {

    // 'Implementation' for super.foo()
    func myFoo() -> String {
        return "I am foo"
    }

    init() {
        // pass the 'implementation' to the superclass
        super.init(myFoo)
    }
}

您可以使用协议VS断言在回答表明这里通过drewag。但是，缺少该协议的示例。我在这里覆盖

协议

protocol SomeProtocol {
    func someMethod()
}

class SomeClass: SomeProtocol {
    func someMethod() {}
}

现在，需要每个子类来实现在编译时检查的协议。如果SomeClass没有实现someMethod，则会出现此编译时错误：

错误：类型“ SomeClass”不符合协议“ SomeProtocol”

注意：这仅适用于实现协议的最高级类。任何子类都可以巧妙地忽略协议要求。-作为评论的memmons

断言

class SuperClass {
    func someFunc() {
        fatalError("Must Override")
    }
}

class Subclass : SuperClass {
    override func someFunc() {
    }
}

但是，断言仅在运行时有效。

作为iOS开发的新手，我不完全确定何时实施该方法，但是要获得两全其美的一种方法是对协议进行扩展：

protocol ThingsToDo {
    func doThingOne()
}

extension ThingsToDo {
    func doThingTwo() { /* Define code here */}
}

class Person: ThingsToDo {
    func doThingOne() {
        // Already defined in extension
        doThingTwo()
        // Rest of code
    }
}

扩展名是使您可以使用函数默认值的功能，而常规协议中的函数仍会提供编译时错误（如果未定义）