เหตุใด Swift initializers จึงไม่สามารถเรียกตัวเริ่มต้นความสะดวกในซูเปอร์คลาสได้

พิจารณาสองคลาส:

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

ฉันไม่เห็นว่าเหตุใดจึงไม่อนุญาต ในที่สุด initializer ที่กำหนดของแต่ละคลาสจะถูกเรียกด้วยค่าที่ต้องการดังนั้นทำไมฉันต้องทำซ้ำตัวเองในB's initโดยการระบุค่าเริ่มต้นxอีกครั้งเมื่อความสะดวกinitในAจะทำได้ดี?

นี่คือกฎข้อที่ 1 ของกฎ "Initializer Chaining" ตามที่ระบุไว้ในคู่มือการเขียนโปรแกรม Swift ซึ่งอ่านว่า:

กฎข้อที่ 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:)

ตอนนี้ถ้า initializer ที่กำหนด B.init (a: b :) จะได้รับอนุญาตให้เรียก initializer สะดวกระดับพื้นฐาน Ainit (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()ฟังก์ชันที่สะดวกของคุณไปยังฟังก์ชันตัวช่วยใหม่foo()เรียกfoo(...)ให้ทำการเริ่มต้นในคลาสย่อยของคุณ

ดูวิดีโอ WWDC "403 intermediate Swift" เวลา 18:30 น. เพื่อดูคำอธิบายเชิงลึกเกี่ยวกับตัวเริ่มต้นและการถ่ายทอดทางพันธุกรรม ตามที่ฉันเข้าใจแล้วให้พิจารณาสิ่งต่อไปนี้:

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 เป็นมังกรที่ไม่มีขาและไม่มีปีก ดังนั้น Initializer สำหรับ Wyvern (2 ขา 2 ปีก) จึงผิด! ข้อผิดพลาดนั้นสามารถหลีกเลี่ยงได้หากไม่สามารถเรียกใช้ Wyvern-Initializer ที่สะดวกได้ แต่มีเพียง Initializer ที่กำหนดแบบเต็มเท่านั้น:

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

ทำไมคุณไม่มี initializers สองตัว - ตัวแรกมีค่าดีฟอลต์

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