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

required init() означает, что каждый неконечный наследник должен поддерживать этот инициализатор: либо унаследовать его, либо явно реализовать. В примере компилятор отклонит Child, потому что его собственный designated-инициализатор не оставляет возможности унаследовать Base.init() по правилам инициализации классов.

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

Классы поддерживают наследование, но создание экземпляра через метатип должно оставаться корректным для любого конкретного наследника. Одного объявления инициализатора в базовом классе недостаточно: без дополнительного требования компилятор не мог бы гарантировать наличие этого инициализатора у всех подклассов.

required формализует такой контракт на уровне типа. Он особенно полезен, когда базовый или обобщённый код должен создавать экземпляры неизвестного заранее подкласса.

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

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

Неверное понимание приводит к ошибке компиляции: разработчик считает, что наличие другого инициализатора в Child достаточно, но Swift не считает инициализаторы взаимозаменяемыми. Инициализатор init(value:) не выполняет контракт required init().

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

required распространяет требование на всю цепочку наследования. Каждый неконечный подкласс обязан предоставить требуемый инициализатор. Это можно сделать двумя способами:

унаследовать инициализатор автоматически, если выполняются правила наследования инициализаторов;
реализовать его явно, при этом также пометив init как required.

В данном коде Child объявляет собственный designated-инициализатор и хранит свойство value. Поэтому автоматическое наследование Base.init() не происходит: подкласс должен сам инициализировать value. Исправление выглядит так:

class Base {
    required init() {}
}

class Child: Base {
    let value: Int

    required init() {
        self.value = 0
        super.init()
    }

    init(value: Int) {
        self.value = value
        super.init()
    }
}

Здесь required init() сначала инициализирует все свойства Child, затем вызывает super.init(). Пометка required в реализации обязательна, иначе контракт базового класса не будет продолжен для дальнейших наследников.

Требование относится именно к инициализаторам. Обычный метод с таким же именем не заменяет инициализатор, а наличие другого набора параметров не удовлетворяет требуемой сигнатуре.

У final-класса дальнейших наследников быть не может, поэтому требование не нужно распространять дальше. При этом сам final-класс всё ещё должен корректно соответствовать требованиям своих предков.

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

Предположим, базовый класс фабрики создаёт объект через метатип:

class Base {
    required init() {}
}

func make<T: Base>(_ type: T.Type) -> T {
    T()
}

final class Service: Base {
    required init() {}
}

let service = make(Service.self)

Вариант без required дал бы фабрике слишком слабый контракт: ограничение T: Base не гарантировало бы наличие T.init(). Можно было бы передавать типы, которые наследуются от Base, но не имеют доступного конструктора без аргументов.

Альтернатива — передавать замыкание-фабрику, например () -> T. Это гибче и позволяет создавать объект со сложными зависимостями, но требует явно передавать способ создания при каждом вызове. required лучше подходит, когда единый конструктор является обязательной частью контракта самого типа.

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

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

Обязательно ли явно писать required во всех подклассах?

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

Можно ли переопределить required init() без слова override?

Да. При реализации требуемого инициализатора в подклассе слово override не пишется: required уже выражает и требование базового класса, и факт переопределения. Используется форма required init(...).

Зачем required при вызове через метатип, если конкретный тип известен во время выполнения?

Метатип может содержать тип, неизвестный статически, например SomeBase.Type. Без требования компилятор не может предположить, что у любого подкласса существует нужная сигнатура инициализатора. required делает наличие этого конструктора частью контракта всей иерархии и позволяет безопасно вызывать его через обобщённое ограничение или метатип.