Краткий ответ

Подкласс обязан сначала задать значения всем своим хранимым свойствам, а затем вызвать super.init, потому что объект нельзя передавать суперклассу в частично инициализированном состоянии. Это правило является частью двухфазной инициализации: сначала каждый класс подготавливает собственные свойства, затем завершается цепочка инициализаторов суперклассов.

До завершения первой фазы нельзя читать свойства, вызывать методы или использовать self как готовое значение. Поэтому суперкласс не может случайно взаимодействовать с объектом, состояние которого ещё не подготовлено.

Исторический контекст

Инициализация в объектных языках часто осложняется наследованием: один объект содержит состояние нескольких классов, а его создание проходит через цепочку инициализаторов. Если разрешить произвольный порядок, метод суперкласса может обратиться к ещё неинициализированному состоянию подкласса.

Swift использует двухфазную модель, чтобы явно разделить подготовку памяти и работу с готовым объектом. Такой подход решает проблему частично сконструированных экземпляров и делает порядок установления инвариантов предсказуемым.

Постановка проблемы

Рассмотрим подкласс с обязательным свойством. До его инициализации экземпляр не удовлетворяет требованиям собственного типа, даже если суперкласс уже может начать свою работу.

Если бы подкласс сначала вызывал суперкласс, а потом задавал свои свойства, суперкласс потенциально мог бы вызвать переопределённый метод или прочитать состояние объекта. Результатом стало бы обращение к данным без корректного значения, поэтому компилятор запрещает такой сценарий.

Подробное решение

Правильная последовательность для designated initializer подкласса такова:

Инициализировать все хранимые свойства, объявленные подклассом.
Вызвать designated initializer суперкласса через super.init.
После возврата из него перейти к действиям, требующим полностью инициализированного self.

Минимальный пример:

class Base {
    let baseID: Int

    init() {
        baseID = 1
    }
}

class Child: Base {
    let name: String

    init(name: String) {
        self.name = name
        super.init()
    }
}

Здесь name принадлежит Child, поэтому оно получает значение до вызова super.init. Свойство baseID принадлежит Base, поэтому его инициализацией занимается инициализатор суперкласса.

Даже после инициализации собственных свойств подкласс обычно ещё не может читать свойства, вызывать методы или передавать self до завершения вызова super.init: первая фаза заканчивается только после инициализации суперкласса. Это предотвращает использование методов на объекте, который ещё не полностью готов.

Свойство с начальным значением считается инициализированным автоматически. Поэтому подкласс может вызвать super.init без явного присваивания такого свойства, но запрет на использование self до окончания первой фазы всё равно сохраняется.

Правило относится прежде всего к designated initializers. Convenience initializer не строит цепочку напрямую через суперкласс: он обязан делегировать инициализацию другому инициализатору того же класса, а designated initializer уже выполняет необходимые вызовы вверх по иерархии.

Ситуация из практики

Предположим, базовый класс регистрирует объект в менеджере во время своего инициализатора, а подкласс хранит обязательный идентификатор этого объекта. Попытка вызвать регистрацию до присваивания идентификатора опасна: базовый класс может обратиться к переопределённому методу или ожидать состояние, которого ещё нет.

Возможны несколько решений. Можно передать идентификатор в инициализатор базового класса, но это связывает базовый класс с деталями подкласса. Можно добавить отдельный метод завершения настройки, однако объект придётся временно хранить в неполностью готовом состоянии, что усложняет контроль ошибок.

Обычно выбирают изменение дизайна: базовый инициализатор получает только необходимые ему данные, подкласс сначала инициализирует собственные свойства, затем вызывает super.init, а дальнейшая работа выполняется после завершения цепочки. Это сохраняет инварианты классов и исключает опасный вызов методов во время конструирования.

Что кандидаты часто упускают

Вопрос: Может ли подкласс напрямую присвоить значение хранимому свойству, объявленному в суперклассе?

Ответ: Нет, подкласс не инициализирует такие свойства напрямую. Инициализация должна выполняться designated initializer того класса, которому свойство принадлежит. Подкласс передаёт управление вверх через super.init, а суперкласс отвечает за свои инварианты и внутреннее состояние.
Вопрос: Если у всех свойств подкласса есть значения по умолчанию, можно ли вызвать super.init первым?

Ответ: Наличие значений по умолчанию означает, что собственные свойства подкласса уже считаются инициализированными. Однако это не отменяет двухфазную инициализацию: до завершения super.init нельзя читать свойства, вызывать методы или использовать self как готовый объект. Значения по умолчанию снимают требование о явных присваиваниях, но не разрешают произвольный доступ к экземпляру.
Вопрос: Почему вызов переопределённого метода из инициализатора особенно опасен?

Ответ: Переопределённый метод может выполниться на подклассе, свойства которого ещё не инициализированы. Он способен прочитать некорректное состояние или изменить его в момент, когда инварианты класса ещё не установлены. Поэтому Swift запрещает вызовы экземплярных методов и использование self до завершения первой фазы, а в практическом дизайне инициализаторы стараются не запускать полиморфное поведение.