Tại sao các trình khởi tạo Swift không thể gọi các trình khởi tạo tiện lợi trên lớp cha của chúng?

Hãy xem xét hai lớp:

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

Tôi không hiểu tại sao điều này không được phép. Cuối cùng, khởi tạo được chỉ định của mỗi lớp được gọi với bất kỳ giá trị mà họ cần, vậy tại sao tôi cần phải lặp lại bản thân mình trong B's initbằng cách xác định một giá trị mặc định cho xmột lần nữa, khi sự tiện lợi inittrong Asẽ làm tốt?

Đây là Quy tắc 1 của quy tắc "Chuỗi khởi tạo" như được chỉ định trong Hướng dẫn lập trình Swift, có nội dung:

Quy tắc 1: Bộ khởi tạo được chỉ định phải gọi bộ khởi tạo được chỉ định từ lớp cha ngay lập tức của chúng.

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

Nhấn mạnh của tôi. Các bộ khởi tạo được chỉ định không thể gọi các bộ khởi tạo tiện lợi.

Có một sơ đồ cùng với các quy tắc để chứng minh những "hướng dẫn" của trình khởi tạo nào được phép:

Xem xét

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

Vì tất cả các trình khởi tạo được chỉ định của lớp A đều bị ghi đè, nên lớp B sẽ kế thừa tất cả các trình khởi tạo tiện lợi của A. Vì vậy, việc thực thi điều này sẽ xuất

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

Bây giờ, nếu bộ khởi tạo được chỉ định B.init (a: b :) được phép gọi bộ khởi tạo tiện lợi lớp cơ sở A.init (a :), điều này sẽ dẫn đến một cuộc gọi đệ quy tới B.init (a:, b: ).

Đó là bởi vì bạn có thể kết thúc với một đệ quy vô hạn. Xem xét:

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

và nhìn vào:

let a = SubClass()

cái nào sẽ gọi SubClass.init()cái nào sẽ gọi SuperClass.init(value:)cái nào sẽ gọi SubClass.init().

Các quy tắc init được chỉ định / tiện lợi được thiết kế để khởi tạo lớp sẽ luôn đúng.

Tôi đã tìm thấy một công việc xung quanh cho điều này. Nó không quá đẹp, nhưng nó giải quyết vấn đề không biết giá trị của lớp cha hoặc muốn đặt giá trị mặc định.

Tất cả những gì bạn phải làm là tạo một thể hiện của lớp cha, sử dụng sự tiện lợi init, ngay trong initlớp con. Sau đó, bạn gọi chỉ định initcủa siêu bằng cách sử dụng cá thể bạn vừa tạo.

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

Xem xét trích xuất mã khởi tạo từ init()chức năng trợ giúp thuận tiện của bạn sang một chức năng trợ giúp mới foo(), gọi foo(...)để thực hiện việc khởi tạo trong lớp con của bạn.

Xem WWDC-video "403 Swift trung gian" lúc 18:30 để có giải thích sâu về các trình khởi tạo và kế thừa của chúng. Như tôi đã hiểu, hãy xem xét những điều sau:

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

Nhưng bây giờ hãy xem xét một lớp con Wyrm: Wyrm là một con Rồng không có chân và không có cánh. Vì vậy, khởi tạo cho Wyvern (2 chân, 2 cánh) là sai đối với nó! Lỗi đó có thể tránh được nếu không thể gọi Wyvern-Initializer tiện lợi mà chỉ gọi được Trình khởi tạo được chỉ định đầy đủ:

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

Tại sao bạn không chỉ có hai bộ khởi tạo - một bộ có giá trị mặc định?

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