Что означает ключевое слово `open` в Swift и чем оно отличается от `public`?

Разница между open и public

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

Ключевое слово open — это самый высокий уровень доступа в Swift. Оно существует именно для того, чтобы разрешить две вещи за пределами модуля:

• Наследование от класса
• Переопределение методов, свойств, сабскриптов

public же даёт доступ к классу и его членам для использования (вызов методов, чтение свойств), но не разрешает наследование и переопределение.

Почему это важно? Представьте, что вы создаёте фреймворк. Вы хотите, чтобы пользователи могли вызывать ваши методы, но не могли менять внутреннюю логику через наследование. Например, у вас есть класс NetworkManager с критической логикой обработки запросов. Если сделать его public, пользователь сможет вызвать fetchData(), но не сможет создать подкласс и переопределить метод, нарушив работу сети. Это защита целостности вашего API.

Если же вы пишете библиотеку, которая предназначена для расширения (например, базовый класс для UI-компонентов), вы используете open. Это явное разрешение: «Я, автор библиотеки, разрешаю тебе наследоваться и переопределять мои методы».

Почему open только для классов?

Да, это верно. open применяется только к классам и их членам (методам, свойствам, сабскриптам). Вот почему:

• Структуры не поддерживают наследование в принципе, поэтому open для них не имеет смысла. Для структур используется public.
• Протоколы не могут быть "открыты" в том же смысле. Если протокол объявлен как public, его можно реализовать в другом модуле. Для протоколов нет понятия "наследование от протокола" — есть только "соответствие протоколу". Поэтому open для протоколов не применяется.

Как это работает в вашем примере

В вашем коде:

// Мой фреймворк
public class MyBaseClass {
    public func doSomething() {
        print("Base implementation")
    }
}

Вы объявили класс как public. Это значит, что из другого модуля вы можете:

• Создать экземпляр MyBaseClass
• Вызвать метод doSomething()

Но вы не можете:

• Наследоваться от MyBaseClass
• Переопределить doSomething()

Когда вы пишете class MySubclass: MyBaseClass — это попытка наследования, которая запрещена для public классов из другого модуля. Компилятор выдаёт ошибку.

Решение — сделать класс open:

// Мой фреймворк
open class MyBaseClass {
    open func doSomething() {  // метод тоже должен быть open для переопределения
        print("Base implementation")
    }
}

// В другом модуле — работает
class MySubclass: MyBaseClass {
    override func doSomething() {
        print("Overridden")
    }
}

Нужен ли open в обычном приложении?

Если вы пишете монолитное приложение (один модуль), то разницы между open и public нет. Внутри одного модуля все классы по умолчанию имеют доступ internal, и вы можете наследоваться от любого класса, если он не помечен final.

open становится важен только когда:

• Вы разрабатываете фреймворк, библиотеку или пакет (SPM)
• Вы используете модульную архитектуру с разделением на модули (например, через CocoaPods, Carthage, SPM)
• Вы пишете код, который будут расширять другие разработчики

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

Краткая памятка

• open — доступ + наследование + переопределение (только для классов)
• public — только доступ, без наследования и переопределения
• internal — доступ в пределах модуля (по умолчанию)
• fileprivate — доступ в пределах файла
• private — доступ в пределах объявления

Надеюсь, теперь стало понятнее! open — это инструмент для авторов библиотек, чтобы явно указать: «Этот класс предназначен для расширения».

open class MyBaseClass {
    public func cannotOverride() {
        print("Этот метод нельзя переопределить")
    }
    
    open func canOverride() {
        print("Этот метод можно переопределить")
    }
}