class — co to je, klíčové pojmy a princip fungování ve Swiftu

Co je class ve Swiftu?

Class (třída) — je složený referenční typ ve Swiftu, který seskupuje vlastnosti a metody do jedné entity s podporou dědičnosti a dynamického odesílání. Na rozdíl od struct je instance třídy vytvořena v hromadě (heap) a proměnná ukládá referenci na tuto instanci, nikoli samotná data.

Když přiřadíte proměnnou třídy jiné proměnné, obě odkazují na stejný objekt v paměti. Změny prostřednictvím jedné reference jsou viditelné přes druhou — to je základní vlastnost reference types, používaná ve vzorech delegování, pozorování a sdíleného stavu.

Podle Apple Swift Documentation jsou třídy jediným způsobem práce s UIKit a AppKit, kde všechny UI komponenty dědí z UIView a UIViewController. Kromě toho jsou třídy nezbytné pro implementaci vzorů vyžadujících identitu objektu (dvě reference na jeden objekt) a řízenou životnost.

Class jako reference type

Sémantika reference type — klíčová vlastnost tříd. Při přiřazení třídy nové proměnné Swift kopíruje referenci, nikoli data. Všechny proměnné odkazující na stejnou instanci vidí její aktuální stav a mohou jej měnit. Toto chování se zásadně liší od value types, kde každá proměnná dostává nezávislou kopii.

// Příklad sémantiky reference type
class User {
    var name: String
    init(name: String) { self.name = name }
}

let user1 = User(name: "Alice")
let user2 = user1           // user2 — stejná reference
user2.name = "Bob"

print(user1.name)               // "Bob" — změněno přes user2!

// Kontrola identity operátorem ===
print(user1 === user2)          // true — stejný objekt

Operátory === (identita) a !== kontrolují, zda dvě proměnné odkazují na stejnou instanci třídy. To je rozdíl od == (rovnost), které porovnává hodnoty vlastností. Pro struct není operátor === dostupný — value types nemají identitu.

Dědičnost tříd

Dědičnost — mechanismus, kterým třída může převzít vlastnosti a metody rodičovské třídy. Ve Swiftu může třída dědit pouze od jednoho rodiče (single inheritance), ale může implementovat více protokolů. Klíčové slovo override umožňuje přepsat zděděnou metodu nebo vlastnost.

Základní třída a podtřída

Každá třída, která nedědí od jiné třídy, se automaticky stává základní (nezaměňovat s NSObject). Podtřída označuje rodiče dvojtečkou za názvem. Pokud podtřída přepisuje metodu rodiče, musí zavolat super.metodu() pro zachování chování rodiče — to je požadavek kompilátoru.

Final class

Klíčové slovo final před class zakazuje dědičnost. Kompilátor může optimalizovat volání metod final tříd pomocí static dispatch, což zvyšuje výkon. Používejte final pro třídy, které nejsou určeny k rozšiřování — dokumentuje to váš záměr a zrychluje kód.

// Příklad dědičnosti tříd ve Swiftu
class Vehicle {
    var speed: Double = 0

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

// Car dědí z Vehicle
class Car: Vehicle {
    var brand: String = "Unknown"

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

// Final class — zabraňuje dědičnosti
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"

Dědičnost tříd je mocný, ale zodpovědný mechanismus. Hluboká hierarchie (5+ úrovní) ztěžuje údržbu a testování. Pro opětovné použití funkcionality bez dědičnosti používejte protokoly s extension a protokolově orientované programování — přístup, který Apple propaguje jako alternativu k hlubokým hierarchiím tříd.

Deinicializace a správa paměti

Swift používá ARC (Automatic Reference Counting) pro správu paměti tříd. Každá instance třídy má čítač silných referencí. Při vytvoření nové silné reference čítač roste; při zničení — klesá. Když čítač dosáhne nuly, paměť se uvolní.

Deinit

Deinit — metoda volaná automaticky před uvolněním instance třídy. V ní se uvolňují zdroje: zavírají se soubory, odhlašují se z oznámení, zastavují se časovače. Deinit existuje pouze u tříd — struktury a výčty jej nemají.

Slabé a nevlastnící reference

Pro prevenci cyklů silných referencí (retain cycles) poskytuje Swift weak a unowned reference. Weak — volitelná reference, která se automaticky stane nil při uvolnění objektu. Unowned — nevolitelná, ale odkazuje na objekt, který zaručeně žije déle než aktuální kontext. Typický retain cycle vzniká ve vztahu parent-child: child drží silnou referenci na parent.

// Příklad ARC a slabé reference
class Parent {
    var name: String
    var child: Child?

    init(name: String) { self.name = name }
    deinit { print("\(name) dealokován") }
}

class Child {
    var name: String
    weak var parent: Parent?   // weak zabraňuje retain cycle

    init(name: String) { self.name = name }
    deinit { print("\(name) dealokován") }
}

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

parent = nil  // Oba objekty dealokovány!
// Bez weak by vytvořilo retain cycle

Vždy používejte weak pro reference z dětského objektu na rodiče a pro capture seznamy v closures. Unowned používejte pouze když jste si jisti, že objekt přežije aktuální kontext — nesprávné použití unowned může vést k pádu při přístupu k uvolněné paměti.

Class vs Struct: klíčové rozdíly

Volba mezi class a struct je architektonické rozhodnutí ovlivňující výkon, bezpečnost vláken a návrh API. Podívejme se na tabulku klíčových rozdílů, která pomůže učinit správné rozhodnutí v každém konkrétním případě.

Používejte třídy, když potřebujete společnou identitu (více částí kódu pracuje s jedním objektem), dědičnost nebo interakci s Objective-C runtime. Pro vše ostatní jsou preferovány struktury — jsou rychlejší, bezpečnější ve vícevláknovém kódu a nevyžadují správu paměti.

Kdy použít class ve Swiftu

Navzdory doporučení Apple používat ve výchozím nastavení struct jsou třídy nezbytné v několika konkrétních scénářích. Pojďme prozkoumat každý s praktickými příklady.

Komponenty UIKit a AppKit

Všechny UI komponenty v iOS a macOS jsou třídy dědící z UIView (iOS) nebo NSView (macOS). Nemůžete nahradit UIViewController strukturou — vyžaduje dědičnost a deinit pro uvolnění zdrojů. Při práci s UIKit používejte třídy pro controllery, view a jejich delegáty.

Singleton a sdílený stav

Vzor Singleton (jedna instance třídy pro celou aplikaci) vyžaduje referenční sémantiku. Správci: NetworkManager, SettingsManager, AnalyticsService — obvykle implementovány jako třídy s shared static property. Struktury nejsou vhodné, protože každá kopie by byla nezávislou instancí.

Dependency Injection a referenční objekty

Když má být objekt jediným zdrojem pravdy (single source of truth) a je předáván mezi moduly referencí — použijte class. Týká se to správy stavu, kde změna objektu na jednom místě musí být viditelná ve všech závislých komponentách. Pro ObservableObject ve SwiftUI jsou třídy povinné.

// ObservableObject — class vyžadován pro SwiftUI
import SwiftUI

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

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

// Použití ve SwiftUI View
struct ContentView: View {
    @StateObject var viewModel = AppViewModel()

    var body: some View {
        Text(viewModel.isLoggedIn ? "Vítejte" : "Přihlásit se")
    }
}

Pravidlo: pokud má mít objekt identitu (dvě reference -> jeden objekt), být jedinečnou instancí nebo pracovat s UIKit/Objective-C — zvolte class. Pokud objekt pouze ukládá data — zvolte struct.