class — какво е това, ключови понятия и принцип на работа в Swift

Какво е class в Swift?

Class (клас) — е съставен референтен тип в Swift, който групира свойства и методи в единна единица с поддръжка на наследяване и динамично изпращане. За разлика от struct, инстанцията на класа се създава в хийпа (heap), а променливата съхранява референция към тази инстанция, а не самите данни.

Когато присвоите променлива на клас на друга променлива, и двете сочат към един и същ обект в паметта. Промените чрез една референция са видими чрез другата — това е фундаменталното свойство на reference types, използвано в моделите на делегиране, наблюдение и споделено състояние.

Според Apple Swift Documentation, класовете са единственият начин за работа с UIKit и AppKit, където всички UI компоненти наследяват от UIView и UIViewController. Освен това класовете са необходими за имплементиране на модели, изискващи идентичност на обект (две референции към един обект) и контролиран жизнен цикъл.

Class като reference type

Семантика на reference type — ключовото свойство на класовете. При присвояване на клас на нова променлива Swift копира референцията, а не данните. Всички променливи, сочещи към една и съща инстанция, виждат нейното текущо състояние и могат да го променят. Това поведение се различава фундаментално от value types, където всяка променлива получава независимо копие.

// Пример за семантика на reference type
class User {
    var name: String
    init(name: String) { self.name = name }
}

let user1 = User(name: "Alice")
let user2 = user1           // user2 — същата референция
user2.name = "Bob"

print(user1.name)               // "Bob" — променен чрез user2!

// Проверка на идентичност с оператора ===
print(user1 === user2)          // true — същият обект

Операторите === (идентичност) и !== проверяват дали две променливи сочат към една и съща инстанция на класа. Това е разликата от == (равенство), което сравнява стойностите на свойствата. За struct операторът === не е наличен — value types нямат идентичност.

Наследяване на класове

Наследяване — механизмът, чрез който клас може да наследи свойства и методи на родителския клас. В Swift клас може да наследи само от един родител (single inheritance), но може да имплементира множество протоколи. Ключовата дума override позволява презаписване на наследен метод или свойство.

Базов клас и подклас

Всеки клас, който не наследява от друг клас, автоматично става базов (да не се бърка с NSObject). Подкласът посочва родителя чрез двуеточие след името. Ако подкласът презаписва метод на родителя, трябва да извика super.метод() за запазване на родителското поведение — това е изискване на компилатора.

Final class

Ключовата дума final пред class забранява наследяването. Компилаторът може да оптимизира извикванията на методи на final класове чрез static dispatch, което повишава производителността. Използвайте final за класове, които не са предназначени за разширяване — това документира намерението ви и ускорява кода.

// Пример за наследяване на класове в Swift
class Vehicle {
    var speed: Double = 0

    func description() -> String {
        "Speed: \(speed) km/h"
    }
}

// Car наследява Vehicle
class Car: Vehicle {
    var brand: String = "Unknown"

    override func description() -> String {
        "\(brand) - \(speed) km/h"
    }
}

// Final class — предотвратява наследяване
final class ElectricCar: Car {
    var batteryLevel: Double = 100
}

let tesla = ElectricCar()
tesla.brand = "Tesla"
tesla.speed = 120
print(tesla.description())  // "Tesla - 120.0 km/h"

Наследяването на класове е мощен, но отговорен механизъм. Дълбоката йерархия (5+ нива) затруднява поддръжката и тестването. За повторно използване на функционалност без наследяване използвайте протоколи с extension и протоколно-ориентирано програмиране — подход, който Apple популяризира като алтернатива на дълбоките класови йерархии.

Деинициализация и управление на паметта

Swift използва ARC (Automatic Reference Counting) за управление на паметта на класовете. Всяка инстанция на клас има брояч на силни референции. При създаване на нова силна референция броячът расте; при унищожаване — намалява. Когато броячът достигне нула, паметта се освобождава.

Deinit

Deinit — метод, който се извиква автоматично преди освобождаването на инстанцията на класа. В него се освобождават ресурси: затварят се файлове, отписват се от известия, спират се таймери. Deinit съществува само при класовете — структурите и изброяванията го нямат.

Слаби и безстопанствени референции

За предотвратяване на цикли от силни референции (retain cycles), Swift предоставя weak и unowned референции. Weak — опционална референция, която автоматично става nil при освобождаване на обекта. Unowned — неопционална, но сочи към обект, който гарантирано живее по-дълго от текущия контекст. Типичен retain cycle възниква в parent-child връзка: child държи силна референция към parent.

// Пример за ARC и слаба референция
class Parent {
    var name: String
    var child: Child?

    init(name: String) { self.name = name }
    deinit { print("\(name) деалоциран") }
}

class Child {
    var name: String
    weak var parent: Parent?   // weak предотвратява retain cycle

    init(name: String) { self.name = name }
    deinit { print("\(name) деалоциран") }
}

var parent: Parent? = Parent(name: "Anna")
parent?.child = Child(name: "Mia")
parent?.child?.parent = parent

parent = nil  // И двата обекта са деалоцирани!
// Без weak би създало retain cycle

Винаги използвайте weak за референции от дъщерния обект към родителя и за capture списъци в затваряния. Използвайте unowned само когато сте сигурни, че обектът ще надживее текущия контекст — неправилното използване на unowned може да доведе до срив при достъп до освободена памет.

Class vs Struct: ключови разлики

Изборът между class и struct е архитектурно решение, което влияе на производителността, нишковата безопасност и дизайна на API. Нека разгледаме таблицата с ключови разлики, която ще помогне за вземане на правилно решение във всеки конкретен случай.

Използвайте класове, когато имате нужда от обща идентичност (няколко части от кода работят с един обект), наследяване или взаимодействие с Objective-C runtime. За всичко останало структурите са предпочитани — те са по-бързи, по-безопасни в многонишков код и не изискват управление на паметта.

Кога да използвате class в Swift

Въпреки препоръката на Apple да използвате struct по подразбиране, класовете са необходими в няколко конкретни сценария. Нека разгледаме всеки с практически примери.

UIKit и AppKit компоненти

Всички UI компоненти в iOS и macOS са класове, които наследяват от UIView (iOS) или NSView (macOS). Не можете да замените UIViewController със структура — той изисква наследяване и deinit за освобождаване на ресурси. При работа с UIKit използвайте класове за контролери, изгледи и техните делегати.

Singleton и споделено състояние

Моделът Singleton (една инстанция на клас за цялото приложение) изисква референтна семантика. Мениджъри: NetworkManager, SettingsManager, AnalyticsService — обикновено се имплементират като класове със shared static property. Структурите не са подходящи, защото всяко копие би било независима инстанция.

Dependency Injection и референтни обекти

Когато обект трябва да бъде единствен източник на истина (single source of truth) и се предава между модули чрез референция — използвайте class. Това се отнася до управлението на състояние, където промяна на обекта на едно място трябва да бъде видима във всички зависими компоненти. За ObservableObject в SwiftUI класовете са задължителни.

// ObservableObject — class е необходим за SwiftUI
import SwiftUI

class AppViewModel: ObservableObject {
    @Published var isLoggedIn: Bool = false
    @Published var username: String = ""

    func login(user: String) {
        isLoggedIn = true
        username = user
    }
}

// Използване в SwiftUI View
struct ContentView: View {
    @StateObject var viewModel = AppViewModel()

    var body: some View {
        Text(viewModel.isLoggedIn ? "Добре дошли" : "Вход")
    }
}

Правило: ако обект трябва да има идентичност (две референции -> един обект), да бъде уникална инстанция или да работи с UIKit/Objective-C — изберете class. Ако обект просто съхранява данни — изберете struct.