class — ce este, concepte cheie și principiul de funcționare în Swift

Ce este class în Swift?

Class (clasă) — este un tip referință compus în Swift care grupează proprietăți și metode într-o entitate unică cu suport pentru moștenire și expediere dinamică. Spre deosebire de struct, instanța clasei este creată în heap, iar variabila stochează o referință către această instanță, nu datele în sine.

Când atribuiți o variabilă de clasă altei variabile, ambele se referă la același obiect în memorie. Modificările printr-o referință sunt vizibile prin cealaltă — aceasta este proprietatea fundamentală a reference types, utilizată în modelele de delegare, observare și stare partajată.

Conform Apple Swift Documentation, clasele sunt singura modalitate de a lucra cu UIKit și AppKit, unde toate componentele UI moștenesc din UIView și UIViewController. În plus, clasele sunt necesare pentru implementarea modelelor care necesită identitate de obiect (două referințe către un obiect) și durată de viață controlată.

Class ca reference type

Semantica reference type — proprietatea cheie a claselor. La atribuirea unei clase unei noi variabile, Swift copiază referința, nu datele. Toate variabilele care se referă la aceeași instanță văd starea sa curentă și o pot modifica. Acest comportament diferă fundamental de value types, unde fiecare variabilă primește o copie independentă.

// Exemplu de semantică reference type
class User {
    var name: String
    init(name: String) { self.name = name }
}

let user1 = User(name: "Alice")
let user2 = user1           // user2 — aceeași referință
user2.name = "Bob"

print(user1.name)               // "Bob" — modificat prin user2!

// Verificare identitate cu operatorul ===
print(user1 === user2)          // true — același obiect

Operatorii === (identitate) și !== verifică dacă două variabile se referă la aceeași instanță a clasei. Aceasta este diferența față de == (egalitate), care compară valorile proprietăților. Pentru struct operatorul === nu este disponibil — value types nu au identitate.

Moștenirea claselor

Moștenirea — mecanismul prin care o clasă poate prelua proprietățile și metodele clasei părinte. În Swift o clasă poate moșteni doar de la un părinte (single inheritance), dar poate implementa multiple protocoale. Cuvântul cheie override permite suprascrierea unei metode sau proprietăți moștenite.

Clasa de bază și subclasa

Orice clasă care nu moștenește de la o altă clasă devine automat o clasă de bază (a nu se confunda cu NSObject). Subclasa indică părintele prin două puncte după nume. Dacă subclasa suprascrie metoda părintelui, trebuie să apeleze super.metoda() pentru a păstra comportamentul părintelui — aceasta este o cerință a compilatorului.

Final class

Cuvântul cheie final înainte de class interzice moștenirea. Compilatorul poate optimiza apelurile metodelor claselor final prin static dispatch, ceea ce crește performanța. Folosiți final pentru clasele care nu sunt destinate extinderii — documentează intenția și accelerează codul.

// Exemplu de moștenire a claselor în Swift
class Vehicle {
    var speed: Double = 0

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

// Car moștenește Vehicle
class Car: Vehicle {
    var brand: String = "Unknown"

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

// Final class — previne moștenirea
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"

Moștenirea claselor este un mecanism puternic, dar responsabil. Ierarhia profundă (5+ niveluri) complică întreținerea și testarea. Pentru reutilizarea funcționalității fără moștenire utilizați protocoale cu extension și programarea orientată pe protocoale — abordare pe care Apple o promovează ca alternativă la ierarhiile profunde de clase.

Deinițializarea și gestionarea memoriei

Swift utilizează ARC (Automatic Reference Counting) pentru gestionarea memoriei claselor. Fiecare instanță a clasei are un contor de referințe puternice. La crearea unei noi referințe puternice contorul crește; la distrugere — scade. Când contorul ajunge la zero, memoria este eliberată.

Deinit

Deinit — metodă apelată automat înainte de eliberarea instanței clasei. În ea se eliberează resurse: se închid fișiere, se dezabonează de la notificări, se opresc temporizatoarele. Deinit există doar la clase — structurile și enumerările nu îl au.

Referințe slabe și fără proprietar

Pentru prevenirea ciclurilor de referințe puternice (retain cycles), Swift oferă referințe weak și unowned. Weak — referință opțională care devine automat nil la eliberarea obiectului. Unowned — neopțională, dar se referă la un obiect care garantează că trăiește mai mult decât contextul curent. Un retain cycle tipic apare în relația parent-child: child păstrează o referință puternică către parent.

// Exemplu de ARC și referință weak
class Parent {
    var name: String
    var child: Child?

    init(name: String) { self.name = name }
    deinit { print("\(name) dealocat") }
}

class Child {
    var name: String
    weak var parent: Parent?   // weak previne retain cycle

    init(name: String) { self.name = name }
    deinit { print("\(name) dealocat") }
}

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

parent = nil  // Ambele obiecte dealocate!
// Fără weak ar crea un retain cycle

Folosiți întotdeauna weak pentru referințele de la obiectul copil către părinte și pentru listele de captură în closure-uri. Unowned utilizați doar când sunteți siguri că obiectul va supraviețui contextului curent — utilizarea incorectă a unowned poate duce la crash la accesarea memoriei eliberate.

Class vs Struct: diferențe cheie

Alegerea între class și struct este o decizie arhitecturală care influențează performanța, siguranța firelor de execuție și designul API. Să examinăm tabelul diferențelor cheie care va ajuta să luați decizia corectă în fiecare caz concret.

Folosiți clase când aveți nevoie de identitate comună (mai multe părți de cod lucrează cu un singur obiect), moștenire sau interacțiune cu Objective-C runtime. Pentru orice altceva, structurile sunt preferate — sunt mai rapide, mai sigure în cod multi-thread și nu necesită gestionarea memoriei.

Când să folosiți class în Swift

În ciuda recomandării Apple de a folosi struct implicit, clasele sunt necesare în câteva scenarii concrete. Să le examinăm pe fiecare cu exemple practice.

Componente UIKit și AppKit

Toate componentele UI în iOS și macOS sunt clase care moștenesc din UIView (iOS) sau NSView (macOS). Nu puteți înlocui UIViewController cu o structură — necesită moștenire și deinit pentru eliberarea resurselor. La lucrul cu UIKit utilizați clase pentru controlere, view-uri și delegate-urile lor.

Singleton și stare partajată

Modelul Singleton (o singură instanță a clasei pentru întreaga aplicație) necesită semantică referențială. Manageri: NetworkManager, SettingsManager, AnalyticsService — de obicei implementați ca clase cu shared static property. Structurile nu sunt potrivite deoarece fiecare copie ar fi o instanță independentă.

Dependency Injection și obiecte referențiale

Când un obiect trebuie să fie singura sursă de adevăr (single source of truth) și este transmis între module prin referință — folosiți class. Aceasta se referă la gestionarea stării unde modificarea obiectului într-un loc trebuie să fie vizibilă în toate componentele dependente. Pentru ObservableObject în SwiftUI clasele sunt obligatorii.

// ObservableObject — class necesar pentru SwiftUI
import SwiftUI

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

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

// Utilizare în view SwiftUI
struct ContentView: View {
    @StateObject var viewModel = AppViewModel()

    var body: some View {
        Text(viewModel.isLoggedIn ? "Bun venit" : "Autentificare")
    }
}

Regula: dacă obiectul trebuie să aibă identitate (două referințe -> un obiect), să fie o instanță unică sau să lucreze cu UIKit/Objective-C — alegeți class. Dacă obiectul doar stochează date — alegeți struct.