В программировании, чтобы создать надежные, безопасные и удобные в обслуживании приложения, крайне важно уметь контролировать, что становится видимым и как можно получить к этому доступ. И вот здесь на сцену выходят уровни доступа, подобно страховому полису для нашего кода: мы сами определяем, кто получает доступ к "игре", а кому вход закрыт.
Что это за уровни?
Существует 5 уровней доступа: open, public, internal, fileprivate и private
Давай разберёмся подробнее, что это такое и как применять.
OPEN
Это как особая входная дверь в дом. Когда ты объявляешь что-то с уровнем доступа open это означает, что другие модули могут не только видеть и использовать этот код, но и наследовать и переопределять его.
Где может пригодиться?
Расширяемые Классы: Идеально подходит когда мы хотим создать класс, который другие разработчики могут наследовать и дополнять своими методами и свойствами. Создаем "родительский" класс с базовым функционалом, а другие классы могут строить на нем, как на фундаменте, добавляя свои индивидуальные детали.
Библиотеки и Фреймворки: Если мы пишем код, который будет использоваться в других проектах, уровень доступа open может быть очень полезным. Это позволяет разработчикам, использующим нашу библиотеку, расширять и адаптировать ее компоненты под свои потребности.
Сильная Связь: Когда мы хотим создать крепкую связь между разными классами и модулями, open может сыграть важную роль. Предоставление "открытого" интерфейса, который может быть наследован и расширен, способствует гибкости и взаимодействию.
// Открываем класс для наследования и расширения
open class Shape {
open func area() -> Double {
return 0.0
}
}
// Cоздаем наследника в своем модуле
open class Circle: Shape {
private var radius: Double
public init(radius: Double) {
self.radius = radius
}
// Переопределяем метод рассчета площади
open override func area() -> Double {
return Double.pi * radius * radius
}
}
// Создаем наследника в другом модуле
class CustomShape: Shape {
override func area() -> Double {
return super.area() * 2
}
}
/* Другой модуль может наследовать и расширять классы, но если метод родительского
класса не будет помечен как open переопределить его мы не сможем */PUBLIC
Элементы с этим уровнем видимости доступны для всех, но с небольшим нюансом. Это как реклама на большом щите - каждый, кто проходит мимо, может это видеть, но они не могут быть переопределены (для методов) или наследованы (для классов) в других модулях.
Где может пригодиться?
Базовые функциональности: Мы можем использовать public для методов или свойств, которые предоставляют базовую функциональность нашего модуля и которые мы не хотим, чтобы можно было изменять или расширять в других модулях. Это помогает поддерживать стабильный интерфейс и избегать непредвиденных изменений.
Утилиты и вспомогательные классы: Если модуль содержит набор утилит или вспомогательных классов, которые могут быть полезными для других модулей, но мы хотим предотвратить их подклассирование или переопределение - объявляем их с уровнем доступа public.
Создание API для чтения данных: Если мы создаем API для доступа к данным (база данных, кеш, хранилище) - используем public для предоставления доступа к этим данным без возможности изменения или переопределения методов работы с данными.
// Создаем класс для наследования и расширения
public class Shape {
public func area() -> Double {
return 0.0
}
}
// Cоздаем наследника в своем модуле
class Circle: Shape {
private var radius: Double
public init(radius: Double) {
self.radius = radius
}
// Переопределяем метод рассчета площади
open override func area() -> Double {
return Double.pi * radius * radius
}
}
/* Создаем наследника в другом модуле - ошибка компиляции, вызванная нарушением правил уровней доступа.
Cannot inherit from non-open class 'Shape' outside of its defining module
Overriding non-open instance method outside of its defining module
*/
class CustomShape: Shape {
public override func area() -> Double {
return super.area() * 2
}
}На этом мы завершаем рассмотрение уровней дающих доступ внутри нашего программного пространства и за его пределами и переходим к тому, что позволяет нам контролировать связи исключительно внутри своего модуля.
INTERNAL
Уровень доступа по умолчанию. Элементы с этим уровнем доступа видны внутри всего "модуля". Модуль - это что-то вроде соседства в программировании где элементы делят один и тот же "двор". Другие модули извне не видят эти элементы, но все внутри модуля могут.
Где может пригодиться?
Внутренние реализационные детали: Если есть внутренние классы, структуры или функции, которые не должны быть видны извне, но играют важную роль внутри модуля, уровень доступа internal будет подходящим выбором.
Совместимость и расширяемость: Можно использовать для методов или свойств, которые должны быть доступны для других частей проекта, но не обязательно для внешних модулей. Это обеспечивает баланс между функциональностью и скрытностью.
// Создаем класс для наследования и расширения
internal class Shape {
func area() -> Double {
return 0.0
}
}
// Cоздаем наследника в своем модуле
internal class Circle: Shape {
private var radius: Double
init(radius: Double) {
self.radius = radius
}
// Переопределяем метод рассчета площади
override func area() -> Double {
return Double.pi * radius * radius
}
}
// Другой класс внутри модуля может наследовать и расширять классы
class CustomShape: Shape {
override func area() -> Double {
return super.area() * 2
}
}FILEPRIVATE
Этот уровень "расширяет" видимость до всего файла .swift, где элемент создан. То есть, любой код в этом файле может иметь доступ к элементам с такой видимостью. Это как комната в доме, к которой есть доступ только у семьи, живущей в этом доме.
Где может пригодиться?
Инкапсуляция внутренних деталей: Мы можем использовать fileprivate, чтобы скрыть внутренние детали реализации от других файлов и модулей. Это помогает обеспечить более чистую и защищенную архитектуру кода.
Организация кода в файле: Внутри файла лучше использовать fileprivate, чтобы явно указать какие части кода предназначены для внутреннего использования друг другом, но не видны за пределами файла.
Реализация расширений: Когда мы расширяем функциональность классов или структур хорошим выбором будет использовать fileprivate для методов или свойств, которые должны быть доступны только в пределах этого файла, но не извне.
// Создаем класс для наследования и расширения
fileprivate class Shape {
func area() -> Double {
return 0.0
}
}
// Cоздаем наследника внутри того же файла .swift
fileprivate class Circle: Shape {
private var radius: Double
init(radius: Double) {
self.radius = radius
}
// Переопределяем метод рассчета площади
override fileprivate func area() -> Double {
return Double.pi * radius * radius
}
}
/* Важно: Наследник обязательно должен быть помечен как private или fileprivate
т.к не может иметь более высокий уровень доступа, чем его родитель. Это связано с
тем, что подкласс может получить доступ к членам суперкласса, и если бы уровень
доступа подкласса был более высоким, это могло бы привести к
утечке информации из модуля с более ограниченным уровнем доступа. */PRIVATE
Самый закрытый уровень. Элементы с таким уровнем видимости доступны только внутри того файла где они созданы. Это подобно защищенному хранилищу доступ к которому имеет лишь один человек. Однако в расширении данного типа (класса, структуры или перечисления) есть попытка получить доступ к private элементам этого типа. Это позволяет расширить функциональность типа используя private элементы, которые в противном случае не видны за пределами этого файла.
Где может пригодиться?
Тайные Детали: Используй private, когда хочешь создать внутренние функции, переменные или свойства, которые должны оставаться невидимыми для всех остальных частей кода. Это улучшает безопасность, предотвращая нежелательное вмешательство.
Поддержание целостности: Предотвращает случайное изменение или использование определенных частей кода, которые могли бы повлиять на работу других компонентов.
Скрытое расширение: Может быть очень удобным, когда мы хотим добавить дополнительную функциональность типу, не раскрывая все детали внешнему миру.
// Создаем класс для наследования и расширения
private class Shape {
private func area() -> Double {
return 0.0
}
func printInfo() {
print("Some shape")
}
}
// Cоздаем наследника внутри того же файла .swift
private class Circle: Shape {
private var radius: Double
init(radius: Double) {
self.radius = radius
}
// Ошибка компиляции, переопределение private метода запрещено
// Method does not override any method from its superclass
override func area() -> Double {
return Double.pi * radius * radius
}
// Переопределяем метод т.к он не помечен как private
override func printInfo() {
print("Circle")
}
}
// Создаем расширение внутри того же файла .swift
extension Shape {
func calculateArea() -> Double {
return area() // Обращение к приватному методу area() внутри расширения
}
}
Заключение
Ну вот мы и подошли к финишу, надеюсь, теперь у тебя есть ясное представление о том, как уровни доступа могут сделать твой код более структурированным и надежным. Помни, когда ты выбираешь уровень доступа, словно создаешь правила игры в своем собственном кодовом мире – решай, кто получит доступ, а кто останется за дверью. Всегда держи в уме основные принципы: защита данных, инкапсуляция, поддержание порядка и безопасности. Не забывай воплощать эти знания в своей будущей практике программирования.
