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 може довести до crash-а при приступу ослобођеној меморији.

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 користите класе за контролере, view-ове и њихове delegate-е.

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.