Overriding superclass initializer in Swift

Question

I've found numerous examples for using the Singleton pattern in Swift 3. I'm trying to use this method:

class Records: RailsData {
    static let shared = Records()
    private init() {} 
    ...
}

When I do, I get the compiler error:

Overriding declaration requires an 'override' keyword

When I add the override keyword, it compiles and everything seems to work. Is the override needed because I'm subclassing RailsData? RailData is an abstract class in that it is not instantiated directly. I also didn't make it a singleton.

I'm trying to make sure I don't get bit later by using the override modifier...

Answer 1

You are not doing anything wrong ;) The override modifier is required because your RailsData superclass declares a designated initializer with the exact same signature:

class RailsData {
    init() {...}
    ...
}

as such, the override modified is made necessary in your subclass. The same thing applies to inherited methods as well. From the The Swift Programming Language book:

When you write a subclass initializer that matches a superclass designated initializer, you are effectively providing an override of that designated initializer. Therefore, you must write the override modifier before the subclass’s initializer definition. This is true even if you are overriding an automatically provided default initializer.

As with an overridden property, method or subscript, the presence of the override modifier prompts Swift to check that the superclass has a matching designated initializer to be overridden, and validates that the parameters for your overriding initializer have been specified as intended.

Rest assured, you won't be bitten by this later on ;)

---

Motivating example. To see this initializer overriding in action, try this example:

class SuperClass {
    init(x: Int) {
        print("3. SuperClass.init(x: \(x))")
    }
    convenience init() {
        print("1. SuperClass.init()")
        self.init(x: 123) // Will be overridden by subclass.
    }
}

class SubClass: SuperClass {
    override init(x: Int) {
        print("2. SubClass.init(x: \(x))")
        super.init(x: x)
        print("4. SubClass.init(x: \(x))")
    }
}

// Calls inherited convenience initializer.
let sub = SubClass() 

outputs:

1. SuperClass.init()
2. SubClass.init(x: 123)
3. SuperClass.init(x: 123)
4. SubClass.init(x: 123)

---

Abstract classes. By the way, there is no direct, linguistic support for abstract classes in Swift — nor in Objective-C — but at least Cupertino is thinking about it ;) Currently, such a concept is merely a soft convention used by frameworks authors, etc.