Swift类中的错误：super.init调用未初始化属性

我有两节课，Shape和Square

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

通过上面的实现，我得到了错误：

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

为什么要self.sideLength在致电之前进行设置super.init？

引用Swift编程语言，它回答了您的问题：

“ Swift的编译器执行四项有用的安全检查，以确保两阶段初始化完成且没有错误：”

安全检查1“指定的初始值设定项必须确保由其类引入的所有属性在将其委托给超类初始值设定项之前都已初始化。”

摘录自：苹果公司“ The Swift Programming Language”。iBooks。 https://itunes.apple.com/cn/book/swift-programming-language/id881256329?mt=11

Swift具有非常清晰，特定的操作序列，这些序列在初始化程序中完成。让我们从一些基本示例开始，然后逐步发展到一般情况。

让我们看一个对象A。我们将其定义如下。

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

注意，A没有超类，因此它不能调用super.init（）函数，因为它不存在。

好的，现在让我们使用名为B的新类作为A的子类。

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

这与Objective-C有所不同，在Objective-C中[super init]，通常会先调用它。在Swift中不是这样。在执行任何其他操作（包括调用方法（包括您的超类的初始化程序））之前，您有责任确保实例变量处于一致状态。

来自文档

安全检查1

指定的初始值设定项必须确保由其类引入的所有属性在委托给超类初始值设定项之前都已初始化。

为什么我们需要这样的安全检查？

为了解决这个问题，让我们迅速进行初始化过程。

两阶段初始化

Swift中的类初始化是一个两阶段的过程。在第一阶段，每个存储的属性都由引入它的类分配一个初始值。一旦确定了每个存储属性的初始状态，便开始第二阶段，并且在认为新实例可以使用之前，每个类都有机会自定义其存储属性。

两阶段初始化过程的使用使初始化安全，同时仍然为类层次结构中的每个类提供完全的灵活性。两阶段初始化可防止在初始化属性值之前访问属性值，并防止其他初始化程序意外地将属性值设置为其他值。

因此，为确保按照上述定义完成两步初始化过程，需要进行四项安全检查，其中一项是，

安全检查1

指定的初始值设定项必须确保由其类引入的所有属性在委托给超类初始值设定项之前都已初始化。

现在，两阶段初始化从未讨论过顺序，但是super.init在所有属性初始化之后，此安全检查将引入有序命令。

安全检查1似乎无关紧要，因为如果没有此安全检查1 ，则 两阶段初始化会阻止在属性值被满足之前访问属性值。

像这个样本一样

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.init在使用之前，已经初始化了每个属性。因此，安全检查1似乎无关紧要，

但是然后可能会有另一种情况，有点复杂，

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)

输出：

Shape Name :Triangle
Sides :3
Hypotenuse :12

在这里，如果我们super.init在设置之前调用过hypotenuse，则该super.init调用将调用，printShapeDescription()并且由于已被覆盖，因此它将首先回退到的Triangle类实现printShapeDescription()。printShapeDescription()Triangle类的of访问hypotenuse一个非可选属性，该属性尚未初始化。这是不允许的，因为两阶段初始化阻止了在初始化属性值之前对其进行访问

因此，请确保两阶段初始化已按定义完成，需要有一个特定的调用顺序super.init，也就是说，在初始化由self类引入的所有属性之后，因此我们需要进行安全检查1

在初始化所有实例变量之后，应调用“ super.init（）”。

在Apple的“中级Swift”视频（您可以在Apple Developer视频资源页面https://developer.apple.com/videos/wwdc/2014/上找到）中，明确指出在28:40在初始化实例变量之后，必须调用父类。

在Objective-C中，情况恰恰相反。在Swift中，由于所有属性都需要在使用前进行初始化，因此我们需要先初始化属性。这是为了防止从超类的“ init（）”方法调用重写的函数，而无需先初始化属性。

因此，“ Square”的实现应为：

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

抱歉，格式化不正确。只需在声明后放置问号，一切都会好起来的。一个问题告诉编译器该值是可选的。

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

编辑1：

有一种更好的方法来跳过此错误。根据jmaschad的评论，由于需要使用可选参数，因此没有理由使用可选参数，因为可选参数使用起来不方便，并且在访问可选参数之前，您始终必须检查其是否为nil。因此，您要做的就是在声明后初始化成员：

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

编辑2：

经过两个缺点后，我找到了更好的方法。如果要在构造函数中初始化类成员，则必须在构造函数内部以及在super.init（）调用之前为其分配初始值。像这样：

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

祝您学习Swift时好运。

swift会强制您初始化每个成员变量，然后再使用它。由于无法确定超级转弯时会发生什么，因此会出错：安全性胜过遗憾

爱德华

您可以像下面这样修改示例中的代码：

var playerShip:PlayerShip!
var deltaPoint = CGPointZero

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

这使用了一个隐式解包的可选。

在文档中，我们可以阅读：

“与可选选项一样，如果在声明隐式解包的可选变量或属性时不提供初始值，则其值将自动默认为nil。”

Swift不允许您在不初始化属性的情况下初始化超类，这与Obj C相反。因此，您必须在调用“ super.init”之前初始化所有属性。

请访问http://blog.scottlogic.com/2014/11/20/swift-initialisation.html。它为您的问题提供了很好的解释。

在声明的末尾添加nil。

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

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

这适用于我的情况，但可能不适用于您的情况

您只是以错误的顺序进行初始化。

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

我可能会收到一些反对意见，但是老实说，这样生活会更轻松：

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

这是一个非常愚蠢的设计。

考虑这样的事情：

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

如上所述，这是无效的。但是是这样的：

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

因为“自我”尚未初始化。

我衷心希望此错误能尽快修复。

（是的，我知道我可以创建一个空对象，然后设置大小，但这只是愚蠢的）。