Для чего нужны модификаторы доступа?

Для чего нужны модификаторы доступа?

Модификаторы доступа (access modifiers) — это ключевая часть инкапсуляции и архитектуры, они контролируют видимость и доступность кода из разных частей приложения.

Основные модификаторы в Swift

1. open (только для классов/методов)

Максимальная видимость — доступен везде, можно переопределять в других модулях:

// В модуле A
open class BaseViewController: UIViewController {
    open func setup() { }
}

// В модуле B
class MyViewController: BaseViewController {
    override func setup() { }  // Можно переопределить
}

Когда использовать: публичные фреймворки, которые должны быть расширяемы

2. public

Видим везде в текущем и других модулях, но нельзя переопределять:

public class APIClient {
    public func fetch() { }     // доступен везде
    public func process() { }   // доступен везде
}

// В другом модуле
let client = APIClient()  // ✅ работает
class CustomClient: APIClient { }  // ❌ ошибка

3. internal (по умолчанию)

Доступен в текущем модуле, но не из других:

// File.swift
internal class UserService {
    internal func getUser() { }
}

// Другой модуль
let service = UserService()  // ❌ error: 'UserService' is inaccessible

4. fileprivate

Доступен только в текущем файле:

// UserViewController.swift
fileprivate class PrivateHelper {
    func help() { }
}

class UserViewController: UIViewController {
    let helper = PrivateHelper()  // ✅ работает
}

// Другой файл
let helper = PrivateHelper()  // ❌ error: 'PrivateHelper' is inaccessible

5. private (самый ограничивающий)

Доступен только внутри текущей области видимости (тип, расширение):

class BankAccount {
    private var balance: Double = 0
    
    func deposit(amount: Double) {
        balance += amount  // ✅ доступ внутри класса
    }
}

let account = BankAccount()
account.balance = -100  // ❌ error: 'balance' is inaccessible

Таблица модификаторов

*private также доступен в расширениях (extensions) одного типа

Зачем нужны модификаторы: практические примеры

1. Инкапсуляция — скрывание деталей реализации

class Repository {
    // Внутренние детали реализации
    private let database: Database
    private let cache: Cache
    
    // Публичный интерфейс
    public func getUser(id: Int) -> User? {
        if let cached = cache.get(id: id) {
            return cached
        }
        let user = database.fetch(id: id)
        cache.save(user)
        return user
    }
}

// Клиент не знает про базу и кеш
let user = repo.getUser(id: 1)  // просто берёт пользователя

2. Безопасность — контроль модификации

class BankAccount {
    private var balance: Double
    
    // Контролируемый доступ
    func deposit(amount: Double) {
        guard amount > 0 else { return }
        balance += amount
    }
    
    func withdraw(amount: Double) -> Bool {
        guard amount > 0, amount <= balance else { return false }
        balance -= amount
        return true
    }
    
    // Никто не может прямо модифицировать баланс
}

3. API дизайн — явный публичный интерфейс

struct PaymentProcessor {
    // Публичные методы = часть API
    public func processPayment(amount: Double) throws -> Receipt {
        let validated = try validate(amount)
        let charged = try charge(validated)
        return Receipt(charged: charged)
    }
    
    // Приватные помощники = деталь реализации
    private func validate(_ amount: Double) throws -> ValidatedAmount { }
    private func charge(_ amount: ValidatedAmount) throws -> ChargeResult { }
}

4. Модульность — разделение ответственности

// NetworkKit модуль
public class APIClient {  // доступен из других модулей
    public func request<T>(_ endpoint: String) async throws -> T { }
}

internal struct RequestBuilder {  // только для модуля NetworkKit
    func build(_ endpoint: String) -> URLRequest { }
}

fileprivate let session = URLSession.shared  // только для текущего файла

Best Practices

✅ Правила использования

1. Начни с private, повышай по необходимости

   private var value = 0  // начинаешь здесь
   // внизу поднимаешь до fileprivate, internal, public
   

2. Минимум публичного API

   // ❌ Слишком много публичного
   public class Service {
       public var state: String
       public var config: Config
       public var cache: [String: Any]
   }
   
   // ✅ Контролируемый API
   public class Service {
       public func getState() -> String { }
       public func configure(_ config: Config) { }
   }
   

3. Используй private для helper функций

   func processData(_ data: Data) -> Result {
       let parsed = parseJSON(data)
       return validate(parsed)
   }
   
   private func parseJSON(_ data: Data) -> [String: Any] { }
   private func validate(_ json: [String: Any]) -> Result { }
   

4. fileprivate для реализационных деталей

   class ViewController: UIViewController {
       fileprivate var viewModel: ViewModel  // деталь ViewController
       fileprivate func setupUI() { }        // внутренняя настройка
   }
   

Модификаторы и SOLID

Модификаторы доступа — инструмент для реализации принципа инкапсуляции (E в SOLID):

• Encapsulation: скрываешь детали, открываешь только нужный интерфейс
• Single Responsibility: каждый класс имеет одну ответственность
• Dependency Inversion: зависишь от публичного интерфейса, не от реализации

Вывод

Модификаторы доступа нужны для:

• Инкапсуляции — скрывания деталей реализации
• Безопасности — контроля модификации данных
• API дизайна — явного определения публичного интерфейса
• Архитектуры — разделения слоёв и модулей
• Поддерживаемости — избежания случайной зависимости на внутренних деталях

Правильное использование модификаторов делает код более безопасным, понятным и масштабируемым.