Что такое protocols в Swift и чем они отличаются от интерфейсов в других языках?

Протоколы в Swift

Протокол (protocol) в Swift — это контракт, описывающий набор методов, свойств и других требований, которым должен соответствовать тип. Протоколы могут реализовывать классы, структуры и перечисления — это принципиальное отличие от интерфейсов в Java/Kotlin, которые применимы только к классам.

Объявление протокола

protocol Vehicle {
    var speed: Double { get }
    var fuelType: String { get set }
    func accelerate(by delta: Double)
    func describe() -> String
}

Реализация протокола структурой

struct ElectricCar: Vehicle {
    var speed: Double = 0
    var fuelType: String = "Electric"

    mutating func accelerate(by delta: Double) {
        speed += delta
    }

    func describe() -> String {
        return "Электромобиль, скорость: \(speed) км/ч"
    }
}

var car = ElectricCar()
car.accelerate(by: 60)
print(car.describe()) // "Электромобиль, скорость: 60.0 км/ч"

Protocol extensions — реализации по умолчанию

Это уникальная особенность Swift. В Java/Kotlin default-методы в интерфейсах ограничены, а в Swift протоколы могут предоставлять полноценные реализации через extension.

extension Vehicle {
    func describe() -> String {
        return "Транспорт, тип топлива: \(fuelType)"
    }
}

struct Bicycle: Vehicle {
    var speed: Double = 0
    var fuelType: String = "Human"
    mutating func accelerate(by delta: Double) { speed += delta }
    // describe() не переопределяем — используем extension
}

print(Bicycle().describe()) // "Транспорт, тип топлива: Human"

Протокол как тип (existential)

func printInfo(of vehicle: any Vehicle) {
    print(vehicle.describe())
}

let vehicles: [any Vehicle] = [ElectricCar(), Bicycle()]
vehicles.forEach { printInfo(of: $0) }

associatedtype — обобщённые протоколы

Аналогов в Java-интерфейсах нет. associatedtype позволяет протоколу работать с абстрактным типом-заполнителем.

protocol Container {
    associatedtype Item
    var items: [Item] { get }
    mutating func add(_ item: Item)
}

struct Box<T>: Container {
    var items: [T] = []
    mutating func add(_ item: T) { items.append(item) }
}

var box = Box<Int>()
box.add(1)
box.add(2)
print(box.items) // [1, 2]

Отличия от интерфейсов Java/Kotlin

• Применимы к struct, enum, class — не только к классам.
• Поддерживают associatedtype и Self-ограничения.
• Protocol extensions дают полноценные реализации по умолчанию.
• Нет неявного соответствия — тип обязан явно указать протокол.
• Свойства в протоколе задают только get/set требования, без хранения.
• Протоколы могут наследоваться от других протоколов и формировать иерархии.

Подводные камни

• Протокол с associatedtype или Self-требованием нельзя использовать как тип переменной напрямую — нужен any или some.
• В Swift 5.7+ экзистенциальный тип требует ключевого слова any; отсутствие его вызывает предупреждения компилятора.
• Метод структуры, изменяющий состояние, должен быть помечен mutating как в протоколе, так и в реализации.
• Динамическая диспетчеризация через экзистенциальный тип медленнее статической через generics.
• Protocol composition (TypeA & TypeB) полезна, но слишком сложные composition-типы затрудняют читаемость.
• Инициализаторы в протоколах требуют required в классах, иначе компилятор выдаёт ошибку.
• @objc-протоколы (для Objective-C interop) поддерживают только классы и ограничены в возможностях.

• Сводить «protocols в Swift и чем они отличаются от интерфейсов в других языках» к синтаксису и не объяснять границы Objective-C.
• Игнорировать жизненный цикл, основной поток или момент освобождения ресурсов в сценарии swift-8.
• Выбирать API по привычке, не проверяя состояние, ошибки, доступность и платформенные ограничения.

• Формулирует точную модель для «protocols в Swift и чем они отличаются от интерфейсов в других языках» и подтверждает ее корректным примером.
• Умеет связать ответ с модель памяти, тестированием и отладкой на устройстве.
• Называет ограничения подхода swift-8, включая производительность, память и сопровождение.