Why should I write required init() {}?

I don't understand why I get the compiler error:

>Constructing an object of class type 'Self' with a metatype value must use a 'required' initializer`

Below is full code.

class ParentFactory {
    static func create() -> Self {
        return self.init()
    }
    
//    required init(){}
    
    func printMessage() {
        print("Super")
    }
}

class Child1Factory: ParentFactory {
    override func printMessage() {
        print("1 Class")
    }
}

class Child2Factory: ParentFactory {
    override func printMessage() {
        print("2 Class")
    }
}


class Factory {
    static func createFactory(_ type: String) -> ParentFactory {
        if type == "1" {
            return Child1Factory.create()
        } else {
            return Child2Factory.create()
        }
    }
}

If I write required init() {}, the error does not occur. I don't understand why I need required init even if it doesn't have any code in the initializer.

From the Swift documentation
> Swift provides a default initializer for any structure or class that provides default values for all of its properties and doesn’t provide at least one initializer itself. The default initializer simply creates a new instance with all of its properties set to their default values.

Your ParentFactory has no stored properties and so, in theory, the default initialiser will be created and should be sufficient. But, you have used the meta type Self, so you aren't necessarily instantiating a ParentFactory - It could be a subclass of ParentFactory, and indeed this is what you are doing.

Now, imagine if Child1Factory looked like this:

class Child1Factory: ParentFactory {
    let aProperty: Int
    
    init(number: Int) {
        self.aProperty = number
        super.init()
    }

    override func printMessage() {
        print("1 Class")
    }
}

This is a perfectly valid implementation - We have an initialiser that initialises the class properties and that calls the superclass initialiser. However, I can't say let child = Child1Factory() - That initialiser doesn't exist, but this is exactly what you are doing when you call Child1Factory.create and it executes Self.init().

To protect against this, your parent class must have a required init that matches the signature of the Self init - That way it is guaranteed that this class and all subclasses will have an init with that signature.

It doesn't matter that the initialiser is empty. What matters is that you are ensuring that all subclasses can be called with that initialiser signature.