Gibt es eine Standardmethode, um in Swift eine "reine virtuelle Funktion" zu erstellen, d. H. einer, der muss von jeder Unterklasse außer Kraft gesetzt werden, und die, wenn sie es nicht, eine Kompilierung Fehler verursacht ist?

Sie haben zwei Möglichkeiten:

1. Verwenden Sie ein Protokoll

Definieren Sie die Oberklasse als Protokoll anstelle einer Klasse

Pro : Überprüfung der Kompilierungszeit, um festzustellen, ob jede "Unterklasse" (keine tatsächliche Unterklasse) die erforderlichen Methoden implementiert.

Con : Die "Superklasse" (Protokoll) kann keine Methoden oder Eigenschaften implementieren

2. Bestätigen Sie in der Super-Version der Methode

Beispiel:

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

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

Pro : Kann Methoden und Eigenschaften in der Oberklasse implementieren

Con : Keine Überprüfung der Kompilierungszeit

Im Folgenden können Sie von einer Klasse erben und die Kompilierungszeit des Protokolls überprüfen lassen :)

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() { ... }

}

Es gibt keine Unterstützung für abstrakte Klassen- / virtuelle Funktionen, aber Sie könnten wahrscheinlich in den meisten Fällen ein Protokoll verwenden:

protocol SomeProtocol {
    func someMethod()
}

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

Wenn SomeClass someMethod nicht implementiert, wird der folgende Fehler beim Kompilieren angezeigt:

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

Eine andere Problemumgehung, wenn Sie nicht zu viele "virtuelle" Methoden haben, besteht darin, dass die Unterklasse die "Implementierungen" als Funktionsobjekte an den Basisklassenkonstruktor übergibt:

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)
    }
}

Sie können das Protokoll gegen die Behauptung verwenden, wie in der Antwort hier von vorgeschlagen drewag. Ein Beispiel für das Protokoll fehlt jedoch. Ich decke hier ab,

Protokoll

protocol SomeProtocol {
    func someMethod()
}

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

Jetzt müssen alle Unterklassen das Protokoll implementieren, das in der Kompilierungszeit überprüft wird. Wenn SomeClass someMethod nicht implementiert, wird der folgende Fehler beim Kompilieren angezeigt:

Fehler: Typ 'SomeClass' entspricht nicht dem Protokoll 'SomeProtocol'

Hinweis: Dies funktioniert nur für die oberste Klasse, die das Protokoll implementiert. Alle Unterklassen können die Protokollanforderungen leichtfertig ignorieren. - wie kommentiert vonmemmons

Behauptung

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

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

Assertion funktioniert jedoch nur zur Laufzeit.

Da ich neu in der iOS-Entwicklung bin, bin ich mir nicht ganz sicher, wann dies implementiert wurde. Eine Möglichkeit, das Beste aus beiden Welten herauszuholen, besteht darin, eine Erweiterung für ein Protokoll zu implementieren:

protocol ThingsToDo {
    func doThingOne()
}

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

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

Mit der Erweiterung können Sie den Standardwert für eine Funktion festlegen, während die Funktion im regulären Protokoll weiterhin einen Fehler bei der Kompilierung liefert, wenn sie nicht definiert ist