为什么Swift初始化程序不能在其超类上调用便捷初始化程序？

考虑两个类：

class A {
    var x: Int

    init(x: Int) {
        self.x = x
    }

    convenience init() {
        self.init(x: 0)
    }
}

class B: A {
    init() {
        super.init() // Error: Must call a designated initializer of the superclass 'A'
    }
}

我不明白为什么不允许这样做。最终，每个类的指定初始化叫他们需要的任何值，那么为什么我要重复我自己B的init通过指定一个默认值x再次，当方便init在A会做得很好？

这是《 Swift编程指南》中指定的“初始化链接”规则的规则1，内容为：

规则1：指定的初始化程序必须从其直接超类调用指定的初始化程序。

https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html

强调我的。指定的初始化程序无法调用便捷初始化程序。

有一张图和规则一起演示了允许使用哪些初始化程序“方向”：

考虑

class A
{
    var a: Int
    var b: Int

    init (a: Int, b: Int) {
        print("Entering A.init(a,b)")
        self.a = a; self.b = b
    }

    convenience init(a: Int) {
        print("Entering A.init(a)")
        self.init(a: a, b: 0)
    }

    convenience init() {
        print("Entering A.init()")
        self.init(a:0)
    }
}


class B : A
{
    var c: Int

    override init(a: Int, b: Int)
    {
        print("Entering B.init(a,b)")
        self.c = 0; super.init(a: a, b: b)
    }
}

var b = B()

因为重写了所有指定的类A的初始值设定项，所以类B将继承A的所有便利性初始值设定项。因此执行此输出

Entering A.init()
Entering A.init(a:)
Entering B.init(a:,b:)
Entering A.init(a:,b:)

现在，如果允许指定的初始化程序B.init（a：b :)调用基类便捷性初始化程序A.init（a :)，则将导致对B.init（a：，b：的递归调用： ）。

这是因为您可以得到无限递归。考虑：

class SuperClass {
    init() {
    }

    convenience init(value: Int) {
        // calls init() of the current class
        // so init() for SubClass if the instance
        // is a SubClass
        self.init()
    }
}

class SubClass : SuperClass {
    override init() {
        super.init(value: 10)
    }
}

并查看：

let a = SubClass()

哪个会打电话SubClass.init()，哪个会打电话SuperClass.init(value:)，哪个会打电话SubClass.init()。

指定/便利初始化规则旨在使类初始化始终正确。

我为此找到了解决方法。它不是超级漂亮，但是它解决了不知道超类的值或想要设置默认值的问题。

您所要做的就是init直接在init子类的中使用方便创建超类的实例。然后init，使用刚刚创建的实例调用超级对象的指定对象。

class A {
    var x: Int

    init(x: Int) {
        self.x = x
    }

    convenience init() {
        self.init(x: 0)
    }
}

class B: A {
    init() {
        // calls A's convenience init, gets instance of A with default x value
        let intermediate = A() 

        super.init(x: intermediate.x) 
    }
}

考虑从方便的位置提取初始化代码init()到新的helper函数foo()，foo(...)在您的子类中调用进行初始化。

请看18:30的WWDC视频“ 403中间Swift”，深入了解初始化程序及其继承。据我了解，请考虑以下几点：

class Dragon {
    var legs: Int
    var isFlying: Bool

    init(legs: Int, isFlying: Bool) {
        self.legs = legs
        self.isFlying = isFlying
    }

    convenience initWyvern() { 
        self.init(legs: 2, isFlying: true)
    }
}

但是现在考虑一个Wyrm子类：Wyrm是没有腿也没有翅膀的龙。因此，飞龙（2条腿，2条翅膀）的初始化器是错误的！如果无法简单地调用便捷的Wyvern-Initializer，而只能调用完整指定的Initializer，则可以避免该错误：

class Wyrm: Dragon {
    init() {
        super.init(legs: 0, isFlying: false)
    }
}

您为什么不只有两个初始化程序-一个具有默认值？

class A {
  var x: Int

  init(x: Int) {
    self.x = x
  }

  init() {
    self.x = 0
  }
}

class B: A {
  override init() {
    super.init()

    // Do something else
  }
}

let s = B()
s.x // 0