为Swift覆盖失败的初始化程序

Question

Here is a link to a Swift tutorial. In section Initialization-Overriding a Failable Initializer Note that if you override a failable superclass initializer with a nonfailable subclass initializer, the subclass initializer cannot delegate up to the superclass initializer.

But the example below：

class Document {
    var name: String?
    // this initializer creates a document with a nil name value
    init() {}
    // this initializer creates a document with a non-empty name value
    init?(name: String) {
        if name.isEmpty { return nil }
        self.name = name
    }
}

and：

class AutomaticallyNamedDocument: Document {
    override init() {
      super.init()
      self.name = "[Untitled]"
    }
    // This is nonfailable override superclass's failable 
    override init(name: String) {
      // Why subclass initializer still can delegate up to the superclass initializer？？
      super.init()
      if name.isEmpty {
        self.name = "[Untitled]"
      } else {
        self.name = name
      }
    }
}

Subclass initializer cannot delegate up to the superclass initializer Why subclass initializer still can delegate up to the superclass initializer?

Answer 1

That passage means that you can't delegate up to the overridden failable initializer . Note this earlier passage:

A failable initializer of a class, structure, or enumeration can delegate across to another failable initializer from the same class, structure, or enumeration. Similarly, a subclass failable initializer can delegate up to a superclass failable initializer.

In either case, if you delegate to another initializer that causes initialization to fail, the entire initialization process fails immediately, and no further initialization code is executed.

That should make it clear why you can't delegate to the overridden failable initializer - were it actually to fail, the whole initialization process would fail, but you're in the middle of a non failable initializer.

In your case, you're delegating up to a nonfailable initializer of the superclass ( super.init() ), so there's no problem.