Fehler in der Swift-Klasse: Eigenschaft beim Aufruf von super.init nicht initialisiert

Ich habe zwei Klassen ShapeundSquare

class Shape {
    var numberOfSides = 0
    var name: String
    init(name:String) {
        self.name = name
    }
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

class Square: Shape {
    var sideLength: Double

    init(sideLength:Double, name:String) {
        super.init(name:name) // Error here
        self.sideLength = sideLength
        numberOfSides = 4
    }
    func area () -> Double {
        return sideLength * sideLength
    }
}

Bei der obigen Implementierung erhalte ich den Fehler:

property 'self.sideLength' not initialized at super.init call
    super.init(name:name)

Warum muss ich einstellen, self.sideLengthbevor ich anrufe super.init?

Zitat aus der Programmiersprache Swift, das Ihre Frage beantwortet:

„Der Compiler von Swift führt vier hilfreiche Sicherheitsüberprüfungen durch, um sicherzustellen, dass die zweiphasige Initialisierung fehlerfrei abgeschlossen wird:“

Sicherheitsprüfung 1 „Ein bestimmter Initialisierer muss sicherstellen, dass alle von seiner Klasse eingeführten Eigenschaften initialisiert werden, bevor er an einen Initialisierer der Oberklasse delegiert.“

Auszug aus: Apple Inc. "Die schnelle Programmiersprache". iBooks. https://itunes.apple.com/us/book/swift-programming-language/id881256329?mt=11

Swift hat eine sehr klare, spezifische Abfolge von Operationen, die in Initialisierern ausgeführt werden. Beginnen wir mit einigen grundlegenden Beispielen und arbeiten uns bis zu einem allgemeinen Fall vor.

Nehmen wir ein Objekt A. Wir definieren es wie folgt.

class A {
    var x: Int
    init(x: Int) {
        self.x = x
    }
}

Beachten Sie, dass A keine Superklasse hat und daher keine super.init () -Funktion aufrufen kann, da diese nicht vorhanden ist.

OK, jetzt wollen wir die Unterklasse A mit einer neuen Klasse namens B unterteilen.

class B: A {
    var y: Int
    init(x: Int, y: Int) {
        self.y = y
        super.init(x: x)
    }
}

Dies ist eine Abweichung von Objective-C, wo [super init]normalerweise zuerst vor allem anderen aufgerufen wird. Nicht so bei Swift. Sie sind dafür verantwortlich, sicherzustellen, dass sich Ihre Instanzvariablen in einem konsistenten Zustand befinden, bevor Sie etwas anderes tun, einschließlich der Aufrufmethoden (einschließlich des Initialisierers Ihrer Oberklasse).

Aus den Dokumenten

Sicherheitsüberprüfung 1

Ein designierter Initialisierer muss sicherstellen, dass alle von seiner Klasse eingeführten Eigenschaften initialisiert werden, bevor er an einen Superklassen-Initialisierer delegiert.

Warum brauchen wir so eine Sicherheitsüberprüfung?

Um dies zu beantworten, lassen Sie uns den Initialisierungsprozess schnell durchlaufen.

Zweiphaseninitialisierung

Die Klasseninitialisierung in Swift ist ein zweiphasiger Prozess. In der ersten Phase wird jeder gespeicherten Eigenschaft von der Klasse, die sie eingeführt hat, ein Anfangswert zugewiesen. Sobald der Anfangszustand für jede gespeicherte Eigenschaft bestimmt wurde, beginnt die zweite Phase, und jede Klasse hat die Möglichkeit, ihre gespeicherten Eigenschaften weiter anzupassen, bevor die neue Instanz als einsatzbereit betrachtet wird.

Die Verwendung eines zweiphasigen Initialisierungsprozesses macht die Initialisierung sicher und bietet gleichzeitig jeder Klasse in einer Klassenhierarchie vollständige Flexibilität. Die zweiphasige Initialisierung verhindert, dass auf Eigenschaftswerte zugegriffen wird, bevor sie initialisiert werden , und verhindert, dass Eigenschaftswerte von einem anderen Initialisierer unerwartet auf einen anderen Wert gesetzt werden.

Um sicherzustellen, dass der zweistufige Initialisierungsprozess wie oben definiert durchgeführt wird, gibt es vier Sicherheitsüberprüfungen. Eine davon ist:

Sicherheitsüberprüfung 1

Ein designierter Initialisierer muss sicherstellen, dass alle von seiner Klasse eingeführten Eigenschaften initialisiert werden, bevor er an einen Superklassen-Initialisierer delegiert.

Bei der zweiphasigen Initialisierung geht es nie um die Reihenfolge, aber diese Sicherheitsüberprüfung führt super.initdazu, dass nach der Initialisierung aller Eigenschaften eine Bestellung durchgeführt wird.

Die Sicherheitsüberprüfung 1 scheint irrelevant zu sein, da die zweiphasige Initialisierung verhindert, dass auf Eigenschaftswerte zugegriffen werden kann, bevor sie initialisiert werden, ohne diese Sicherheitsüberprüfung 1 erfüllt werden kann.

Wie in diesem Beispiel

class Shape {
    var name: String
    var sides : Int
    init(sides:Int, named: String) {
        self.sides = sides
        self.name = named
    }
}

class Triangle: Shape {
    var hypotenuse: Int
    init(hypotenuse:Int) {
        super.init(sides: 3, named: "Triangle") 
        self.hypotenuse = hypotenuse
    }
}

Triangle.inithat jede Eigenschaft vor der Verwendung initialisiert. Sicherheitscheck 1 scheint also irrelevant,

Aber dann könnte es ein anderes Szenario geben, ein bisschen komplex,

class Shape {
    var name: String
    var sides : Int
    init(sides:Int, named: String) {
        self.sides = sides
        self.name = named
        printShapeDescription()
    }
    func printShapeDescription() {
        print("Shape Name :\(self.name)")
        print("Sides :\(self.sides)")
    }
}

class Triangle: Shape {
    var hypotenuse: Int
    init(hypotenuse:Int) {
        self.hypotenuse = hypotenuse
        super.init(sides: 3, named: "Triangle")
    }

    override func printShapeDescription() {
        super.printShapeDescription()
        print("Hypotenuse :\(self.hypotenuse)")
    }
}

let triangle = Triangle(hypotenuse: 12)

Ausgabe :

Shape Name :Triangle
Sides :3
Hypotenuse :12

Wenn wir das super.initvor dem Setzen des aufgerufen hätten hypotenuse, hätte der super.initAufruf dann das aufgerufen, printShapeDescription()und da dies überschrieben wurde, würde er zuerst auf die Implementierung der Triangle-Klasse von zurückgreifen printShapeDescription(). Die printShapeDescription()of Triangle-Klasse greift auf hypotenuseeine nicht optionale Eigenschaft zu, die noch nicht initialisiert wurde. Dies ist nicht zulässig, da durch die zweiphasige Initialisierung verhindert wird, dass auf Eigenschaftswerte zugegriffen wird, bevor sie initialisiert werden

Stellen Sie also sicher, dass die Zwei-Phasen-Initialisierung wie definiert durchgeführt wird. Es muss eine bestimmte super.initAufrufreihenfolge geben. Nach der Initialisierung aller von der selfKlasse eingeführten Eigenschaften benötigen wir daher eine Sicherheitsüberprüfung 1

Die "super.init ()" sollte aufgerufen werden, nachdem Sie alle Ihre Instanzvariablen initialisiert haben.

In Apples "Intermediate Swift" -Video (Sie finden es auf der Apple Developer-Video-Ressourcenseite https://developer.apple.com/videos/wwdc/2014/ ) wird gegen 28:40 Uhr ausdrücklich angegeben, dass alle Initialisierer in Die Superklasse muss aufgerufen werden, nachdem Sie Ihre Instanzvariablen initialisiert haben.

In Objective-C war es umgekehrt. Da in Swift alle Eigenschaften initialisiert werden müssen, bevor sie verwendet werden, müssen wir zuerst die Eigenschaften initialisieren. Dies soll verhindern, dass die "init ()" - Methode der Superklasse die aufgerufene Funktion aufruft, ohne zuvor die Eigenschaften zu initialisieren.

Die Implementierung von "Square" sollte also sein:

class Square: Shape {
    var sideLength: Double

    init(sideLength:Double, name:String) {
        self.sideLength = sideLength
        numberOfSides = 4
        super.init(name:name) // Correct position for "super.init()"
    }
    func area () -> Double {
        return sideLength * sideLength
    }
}

Entschuldigung für die hässliche Formatierung. Setzen Sie einfach ein Fragezeichen nach der Deklaration und alles wird in Ordnung sein. Eine Frage teilt dem Compiler mit, dass der Wert optional ist.

class Square: Shape {
    var sideLength: Double?   // <=== like this ..

    init(sideLength:Double, name:String) {
        super.init(name:name) // Error here
        self.sideLength = sideLength
        numberOfSides = 4
    }
    func area () -> Double {
        return sideLength * sideLength
    }
}

Edit1:

Es gibt eine bessere Möglichkeit, diesen Fehler zu überspringen. Laut dem Kommentar von jmaschad gibt es in Ihrem Fall keinen Grund, optional zu verwenden, da optionale Optionen nicht bequem zu verwenden sind und Sie immer überprüfen müssen, ob optional nicht null ist, bevor Sie darauf zugreifen. Alles was Sie tun müssen, ist das Mitglied nach der Deklaration zu initialisieren:

class Square: Shape {
    var sideLength: Double=Double()   

    init(sideLength:Double, name:String) {
        super.init(name:name)
        self.sideLength = sideLength
        numberOfSides = 4
    }
    func area () -> Double {
        return sideLength * sideLength
    }
}

Edit2:

Nachdem zwei Minuten auf diese Antwort gekommen waren, fand ich einen noch besseren Weg. Wenn Sie möchten, dass das Klassenmitglied in Ihrem Konstruktor initialisiert wird, müssen Sie ihm im Konstruktor und vor dem Aufruf von super.init () einen Anfangswert zuweisen. So was:

class Square: Shape {
    var sideLength: Double  

    init(sideLength:Double, name:String) {
        self.sideLength = sideLength   // <= before super.init call..
        super.init(name:name)
        numberOfSides = 4
    }
    func area () -> Double {
        return sideLength * sideLength
    }
}

Viel Glück beim Lernen von Swift.

swift erzwingt, dass Sie jede Mitgliedsvariable initialisieren, bevor sie jemals verwendet wird / werden könnte. Da es nicht sicher sein kann, was passiert, wenn es an der Reihe ist, tritt ein Fehler auf: Besser sicher als leid

Edward,

Sie können den Code in Ihrem Beispiel folgendermaßen ändern:

var playerShip:PlayerShip!
var deltaPoint = CGPointZero

init(size: CGSize)
{
    super.init(size: size)
    playerLayerNode.addChild(playerShip)        
}

Dies verwendet eine implizit entpackte Option.

In der Dokumentation können wir lesen:

"Wenn Sie wie bei den Optionen keinen Anfangswert angeben, wenn Sie eine implizit entpackte optionale Variable oder Eigenschaft deklarieren, wird der Wert automatisch auf Null gesetzt."

Mit Swift können Sie keine Superklasse initialisieren, ohne die Eigenschaften zu initialisieren, umgekehrt zu Obj C. Sie müssen also alle Eigenschaften initialisieren, bevor Sie "super.init" aufrufen.

Bitte gehen Sie zu http://blog.scottlogic.com/2014/11/20/swift-initialisation.html . Es gibt eine schöne Erklärung für Ihr Problem.

Fügen Sie am Ende der Deklaration null hinzu.

// Must be nil or swift complains
var someProtocol:SomeProtocol? = nil

// Init the view
override init(frame: CGRect)
    super.init(frame: frame)
    ...

Dies funktionierte für meinen Fall, aber möglicherweise nicht für Ihren

Sie starten nur in der falschen Reihenfolge.

     class Shape2 {
        var numberOfSides = 0
        var name: String
        init(name:String) {
            self.name = name
        }
        func simpleDescription() -> String {
            return "A shape with \(numberOfSides) sides."
        }
    }

    class Square2: Shape2 {
        var sideLength: Double

        init(sideLength:Double, name:String) {

            self.sideLength = sideLength
            super.init(name:name) // It should be behind "self.sideLength = sideLength"
            numberOfSides = 4
        }
        func area () -> Double {
            return sideLength * sideLength
        }
    }

Ich werde wahrscheinlich einige Abstimmungen erhalten, aber um ehrlich zu sein, ist das Leben auf diese Weise einfacher:

class CSListServerData<ListItem: CSJsonData>: CSServerData {
    var key: String!
    var type: ListItem.Type!
    var property: CSJsonDataList<ListItem>!

    func construct(_ key: String, _ type: ListItem.Type) -> Self {
        self.key = key
        self.type = type
        property = CSJsonDataList(self, type, key)
        return self
    }

    func construct(_ type: ListItem.Type) { construct("list", type) }

    var list: [ListItem] { property.list }
}

Es ist ein erstaunlich dummes Design.

Betrachten Sie so etwas:

.
.
.
var playerShip:PlayerShip
var deltaPoint = CGPointZero

init(size: CGSize)
{
    super.init(size: size)
    playerShip = PlayerShip(pos: CGPointMake(self.size.width / 2.0, 100))
    playerLayerNode.addChild(playerShip)        
}
.
.
.

Dies ist ungültig, wie oben erwähnt. Aber so ist:

.
.
.
var playerShip:PlayerShip = PlayerShip(pos: CGPointMake(self.size.width / 2.0, 100))
var deltaPoint = CGPointZero

init(size: CGSize)
{
    super.init(size: size)
    playerLayerNode.addChild(playerShip)        
}
.
.
.

Weil 'Selbst' nicht initialisiert wurde.

Ich hoffe aufrichtig, dass dieser Fehler bald behoben ist.

(Ja, ich weiß, ich könnte ein leeres Objekt erstellen und dann die Größe einstellen, aber das ist einfach dumm).