class — mi ez, kulcsfogalmak és működési elv Swiftben

Mi a class Swiftben?

Class (osztály) — egy összetett hivatkozási típus Swiftben, amely tulajdonságokat és metódusokat csoportosít egyetlen entitásba az öröklődés és a dinamikus kiküldés támogatásával. A struct-tól eltérően az osztály példánya a heapen jön létre, és a változó egy hivatkozást tárol erre a példányra, nem magukat az adatokat.

Amikor egy osztályváltozót hozzárendelsz egy másik változóhoz, mindkettő ugyanarra az objektumra hivatkozik a memóriában. Az egyik hivatkozáson keresztüli változtatások láthatóak a másikon keresztül — ez a reference types alapvető tulajdonsága, amelyet delegálási, megfigyelési és megosztott állapot mintákban használnak.

A Apple Swift Documentation szerint az osztályok az egyetlen mód a UIKit és AppKit használatára, ahol az összes UI-komponens a UIView és UIViewController osztályokból örököl. Ezenkívül az osztályok szükségesek olyan minták megvalósításához, amelyek objektumazonosságot (két hivatkozás egy objektumra) és ellenőrzött élettartamot igényelnek.

Class mint reference type

A reference type szemantika — az osztályok kulcstulajdonsága. Amikor egy osztályt egy új változóhoz rendelsz, a Swift a hivatkozást másolja, nem az adatokat. Minden változó, amely ugyanarra a példányra hivatkozik, látja annak aktuális állapotát és módosíthatja azt. Ez a viselkedés alapvetően különbözik a value types-tól, ahol minden változó független másolatot kap.

// Példa reference type szemantikára
class User {
    var name: String
    init(name: String) { self.name = name }
}

let user1 = User(name: "Alice")
let user2 = user1           // user2 — ugyanaz a hivatkozás
user2.name = "Bob"

print(user1.name)               // "Bob" — megváltoztatva user2-n keresztül!

// Azonosság ellenőrzése === operátorral
print(user1 === user2)          // true — ugyanaz az objektum

A === (azonosság) és !== operátorok ellenőrzik, hogy két változó ugyanarra az osztálypéldányra hivatkozik-e. Ez a különbség a == (egyenlőség) operátortól, amely a tulajdonságok értékeit hasonlítja össze. A struct esetében a === operátor nem elérhető — a value types-nak nincs azonossága.

Osztályok öröklődése

Öröklődés — az a mechanizmus, amellyel egy osztály átveheti a szülőosztály tulajdonságait és metódusait. Swiftben egy osztály csak egy szülőtől örökölhet (single inheritance), de több protokollt is megvalósíthat. Az override kulcsszó lehetővé teszi egy örökölt metódus vagy tulajdonság felülírását.

Bázisosztály és alosztály

Minden olyan osztály, amely nem örököl másik osztálytól, automatikusan bázisosztállyá válik (nem tévesztendő össze az NSObject-tel). Az alosztály kettősponttal jelöli a szülőt a név után. Ha az alosztály felülírja a szülő metódusát, meg kell hívnia a super.metódus()-t a szülő viselkedésének megőrzéséhez — ez a fordító követelménye.

Final class

A final kulcsszó a class előtt megtiltja az öröklődést. A fordító optimalizálhatja a final osztályok metódushívásait static dispatch segítségével, ami növeli a teljesítményt. Használd a final-t olyan osztályokhoz, amelyeket nem bővítésre szántál — ez dokumentálja a szándékodat és gyorsítja a kódot.

// Példa osztályöröklődésre Swiftben
class Vehicle {
    var speed: Double = 0

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

// Car örököl a Vehicle-től
class Car: Vehicle {
    var brand: String = "Unknown"

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

// Final class — megakadályozza az öröklődést
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"

Az osztályöröklődés egy hatékony, de felelősségteljes mechanizmus. A mély hierarchia (5+ szint) megnehezíti a karbantartást és a tesztelést. Funkcionalitás öröklődés nélküli újrafelhasználásához használj protokollokat extension-nel és protokoll-orientált programozást — ezt a megközelítést az Apple a mély osztályhierarchiák alternatívájaként népszerűsíti.

Deinicializáció és memóriakezelés

A Swift ARC-t (Automatic Reference Counting) használ az osztályok memóriájának kezelésére. Minden osztálypéldánynak van egy erős hivatkozások számlálója. Új erős hivatkozás létrehozásakor a számláló nő; megsemmisítéskor csökken. Amikor a számláló eléri a nullát, a memória felszabadul.

Deinit

Deinit — metódus, amely automatikusan meghívódik az osztálypéldány felszabadítása előtt. Ebben szabadulnak fel az erőforrások: fájlok záródnak, értesítésekből történik leiratkozás, időzítők állnak le. A deinit csak az osztályokban létezik — a struktúrákban és felsorolásokban nincs.

Gyenge és gazdátlan hivatkozások

Az erős hivatkozási ciklusok (retain cycles) megelőzésére a Swift weak és unowned hivatkozásokat biztosít. Weak — opcionális hivatkozás, amely automatikusan nil lesz az objektum felszabadításakor. Unowned — nem opcionális, de olyan objektumra hivatkozik, amely garantáltan tovább él az aktuális kontextusnál. Tipikus retain cycle a parent-child kapcsolatban keletkezik: a child erős hivatkozást tart a parent-re.

// Példa ARC-re és gyenge hivatkozásra
class Parent {
    var name: String
    var child: Child?

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

class Child {
    var name: String
    weak var parent: Parent?   // weak megakadályozza a retain cycle-t

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

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

parent = nil  // Mindkét objektum felszabadult!
// Weak nélkül retain cycle-t hozna létre

Mindig használj weak-et a gyermekobjektumtól a szülő felé mutató hivatkozásokhoz és a closure-ök capture listáiban. Az unowned-ot csak akkor használd, ha biztos vagy benne, hogy az objektum túléli az aktuális kontextust — az unowned helytelen használata crash-hez vezethet felszabadított memória elérésekor.

Class vs Struct: kulcsfontosságú különbségek

A class és struct közötti választás architekturális döntés, amely befolyásolja a teljesítményt, a szálbiztonságot és az API-tervezést. Vizsgáljuk meg a kulcsfontosságú különbségek táblázatát, amely segít a helyes döntés meghozatalában minden konkrét esetben.

Használj osztályokat, amikor közös azonosságra van szükség (a kód több része dolgozik egy objektummal), öröklődésre vagy Objective-C runtime-mal való interakcióra. Minden más esetben a struktúrák preferáltak — gyorsabbak, biztonságosabbak több szálú kódban és nem igényelnek memóriakezelést.

Mikor használjuk a class-t Swiftben

Az Apple azon ajánlása ellenére, hogy alapértelmezetten struct-ot használj, az osztályok néhány konkrét forgatókönyvben elengedhetetlenek. Vizsgáljuk meg mindegyiket gyakorlati példákkal.

UIKit és AppKit komponensek

Az iOS és macOS összes UI-komponense olyan osztály, amely a UIView (iOS) vagy NSView (macOS) osztályból örököl. Nem helyettesítheted az UIViewController-t egy struktúrával — öröklődést és deinit-et igényel az erőforrások felszabadításához. A UIKit használatakor használj osztályokat a vezérlőkhöz, nézetekhez és azok delegate-jaihoz.

Singleton és megosztott állapot

A Singleton minta (egy osztálypéldány a teljes alkalmazáshoz) hivatkozási szemantikát igényel. Menedzserek: NetworkManager, SettingsManager, AnalyticsService — általában osztályokként valósulnak meg shared static property-vel. A struktúrák nem megfelelőek, mert minden másolat független példány lenne.

Dependency Injection és hivatkozási objektumok

Amikor egy objektumnak egyetlen igazságforrásnak (single source of truth) kell lennie, és modulok között hivatkozással kerül átadásra — használj class-t. Ez az állapotkezelésre vonatkozik, ahol az objektum egy helyen történő megváltoztatásának láthatónak kell lennie az összes függő komponensben. Az ObservableObject-hez a SwiftUI-ben az osztályok kötelezőek.

// ObservableObject — class szükséges a SwiftUI-hoz
import SwiftUI

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

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

// Használat SwiftUI View-ban
struct ContentView: View {
    @StateObject var viewModel = AppViewModel()

    var body: some View {
        Text(viewModel.isLoggedIn ? "Üdvözöljük" : "Bejelentkezés")
    }
}

Szabály: ha egy objektumnak azonossággal kell rendelkeznie (két hivatkozás -> egy objektum), egyedi példánynak kell lennie, vagy UIKit/Objective-C-vel kell dolgoznia — válaszd a class-t. Ha az objektum csak adatokat tárol — válaszd a struct-ot.