class — ano ito, mga pangunahing konsepto at prinsipyo ng paggana sa Swift

Ano ang class sa Swift?

Class (klase) — ay isang pinagsama-samang uri ng referensya sa Swift na nagpapangkat ng mga property at method sa iisang entity na may suporta para sa inheritance at dynamic dispatch. Hindi tulad ng struct, ang instance ng klase ay nilikha sa heap, at ang variable ay nag-iimbak ng referensya sa instance na ito, hindi ang data mismo.

Kapag nagtalaga ka ng variable ng klase sa ibang variable, pareho silang tumutukoy sa parehong object sa memorya. Ang mga pagbabago sa pamamagitan ng isang referensya ay nakikita sa pamamagitan ng isa pa — ito ang pangunahing katangian ng reference types, na ginagamit sa mga pattern ng delegasyon, pagmamasid at pinagsamang estado.

Ayon sa Apple Swift Documentation, ang mga klase ay ang tanging paraan upang magtrabaho sa UIKit at AppKit, kung saan lahat ng UI component ay nagmamana mula sa UIView at UIViewController. Bukod pa rito, ang mga klase ay kinakailangan para sa pagpapatupad ng mga pattern na nangangailangan ng pagkakakilanlan ng object (dalawang referensya sa isang object) at kontroladong buhay.

Class bilang reference type

Semantika ng reference type — ang pangunahing katangian ng mga klase. Kapag nagtalaga ng klase sa isang bagong variable, kinokopya ng Swift ang referensya, hindi ang data. Lahat ng variable na tumutukoy sa parehong instance ay nakikita ang kasalukuyang estado nito at maaaring baguhin ito. Ang pag-uugali na ito ay pangunahing naiiba sa value types, kung saan ang bawat variable ay tumatanggap ng independiyenteng kopya.

// Halimbawa ng semantika ng reference type
class User {
    var name: String
    init(name: String) { self.name = name }
}

let user1 = User(name: "Alice")
let user2 = user1           // user2 — parehong referensya
user2.name = "Bob"

print(user1.name)               // "Bob" — binago sa pamamagitan ng user2!

// Pagsusuri ng pagkakakilanlan gamit ang === operator
print(user1 === user2)          // true — parehong object

Ang mga operator na === (pagkakakilanlan) at !== ay sumusuri kung ang dalawang variable ay tumutukoy sa parehong instance ng klase. Ito ang pagkakaiba sa == (pagkakapantay-pantay), na nagkukumpara sa mga halaga ng property. Para sa struct ang operator na === ay hindi magagamit — ang value types ay walang pagkakakilanlan.

Inheritance ng mga klase

Inheritance — ang mekanismo kung saan ang isang klase ay maaaring kumuha ng mga property at method ng parent class. Sa Swift, ang isang klase ay maaari lamang magmana mula sa isang magulang (single inheritance), ngunit maaaring magpatupad ng maraming protocol. Ang keyword na override ay nagpapahintulot na i-override ang isang minanang method o property.

Base class at subclass

Ang bawat klase na hindi nagmamana mula sa ibang klase ay awtomatikong nagiging isang base na klase (huwag ipagkamali sa NSObject). Ang subclass ay nagpapahiwatig ng magulang sa pamamagitan ng tutuldok pagkatapos ng pangalan. Kung ang subclass ay nag-override ng method ng magulang, dapat itong tumawag ng super.metodo() upang mapanatili ang pag-uugali ng magulang — ito ay isang pangangailangan ng compiler.

Final class

Ang keyword na final bago ang class ay nagbabawal ng inheritance. Maaaring i-optimize ng compiler ang mga tawag sa method ng final classes sa pamamagitan ng static dispatch, na nagpapataas ng performance. Gamitin ang final para sa mga klase na hindi nilayon para palawakin — ito ay nagdodokumento ng iyong intensyon at nagpapabilis ng code.

// Halimbawa ng inheritance ng klase sa Swift
class Vehicle {
    var speed: Double = 0

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

// Car ay nagmamana mula sa Vehicle
class Car: Vehicle {
    var brand: String = "Unknown"

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

// Final class — pumipigil sa inheritance
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"

Ang inheritance ng klase ay isang makapangyarihan ngunit responsableng mekanismo. Ang malalim na herarkiya (5+ antas) ay nagpapahirap sa pagpapanatili at pagsubok. Para sa muling paggamit ng functionality nang walang inheritance, gumamit ng protocols na may extension at protocol-oriented programming — isang approach na itinaguyod ng Apple bilang alternatibo sa malalim na class hierarchies.

Deinitialization at pamamahala ng memorya

Gumagamit ang Swift ng ARC (Automatic Reference Counting) para sa pamamahala ng memorya ng mga klase. Bawat instance ng klase ay may counter ng malalakas na referensya. Kapag gumawa ng bagong malakas na referensya, tumataas ang counter; kapag nawasak — bumababa. Kapag ang counter ay umabot sa zero, ang memorya ay pinapalaya.

Deinit

Deinit — method na awtomatikong tinatawag bago palayain ang instance ng klase. Dito pinapalaya ang mga resources: isinasara ang mga file, nag-a-unsubscribe mula sa mga notification, humihinto ng mga timer. Ang deinit ay umiiral lamang sa mga klase — ang mga istraktura at enumeration ay wala nito.

Mahihina at walang-ari na referensya

Upang maiwasan ang mga siklo ng malalakas na referensya (retain cycles), nagbibigay ang Swift ng weak at unowned referensya. Weak — isang opsyonal na referensya na awtomatikong nagiging nil kapag ang object ay pinalaya. Unowned — hindi opsyonal, ngunit tumutukoy sa isang object na garantisadong mas mahaba ang buhay kaysa sa kasalukuyang konteksto. Ang tipikal na retain cycle ay lumalabas sa parent-child na relasyon: ang child ay nag-iimbak ng malakas na referensya sa parent.

// Halimbawa ng ARC at weak referensya
class Parent {
    var name: String
    var child: Child?

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

class Child {
    var name: String
    weak var parent: Parent?   // weak ay pumipigil sa retain cycle

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

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

parent = nil  // Parehong object ay deallocated!
// Kung walang weak, lilikha ito ng retain cycle

Palaging gumamit ng weak para sa mga referensya mula sa child object patungo sa parent at para sa mga capture list sa closures. Gamitin ang unowned lamang kapag sigurado kang ang object ay makakaligtas sa kasalukuyang konteksto — ang maling paggamit ng unowned ay maaaring humantong sa crash kapag ina-access ang pinalayang memorya.

Class vs Struct: mga pangunahing pagkakaiba

Ang pagpili sa pagitan ng class at struct ay isang desisyong arkitektural na nakakaapekto sa performance, kaligtasan ng thread, at disenyo ng API. Tingnan natin ang talahanayan ng mga pangunahing pagkakaiba na makakatulong sa paggawa ng tamang desisyon sa bawat konkretong kaso.

Gamitin ang mga klase kapag kailangan mo ng karaniwang pagkakakilanlan (maraming bahagi ng code ang gumagana sa iisang object), inheritance o interaksyon sa Objective-C runtime. Para sa lahat ng iba pa, ang mga istraktura ay mas gusto — mas mabilis ang mga ito, mas ligtas sa multi-thread na code at hindi nangangailangan ng pamamahala ng memorya.

Kailan gagamitin ang class sa Swift

Sa kabila ng rekomendasyon ng Apple na gamitin ang struct bilang default, ang mga klase ay kinakailangan sa ilang konkretong sitwasyon. Talakayin natin ang bawat isa na may praktikal na mga halimbawa.

Mga component ng UIKit at AppKit

Lahat ng UI component sa iOS at macOS ay mga klase na nagmamana mula sa UIView (iOS) o NSView (macOS). Hindi mo maaaring palitan ang UIViewController ng isang istraktura — nangangailangan ito ng inheritance at deinit para sa pagpapalaya ng resources. Kapag nagtatrabaho sa UIKit, gumamit ng mga klase para sa controllers, views, at kanilang mga delegate.

Singleton at pinagsamang estado

Ang pattern na Singleton (isang instance ng klase para sa buong application) ay nangangailangan ng semantika ng referensya. Mga manager: NetworkManager, SettingsManager, AnalyticsService — karaniwang ipinapatupad bilang mga klase na may shared static property. Ang mga istraktura ay hindi angkop dahil ang bawat kopya ay magiging independiyenteng instance.

Dependency Injection at mga referensyal na object

Kapag ang isang object ay dapat na tanging pinagmulan ng katotohanan (single source of truth) at ipinapasa sa pagitan ng mga module sa pamamagitan ng referensya — gamitin ang class. Ito ay nauugnay sa pamamahala ng estado kung saan ang pagbabago ng object sa isang lugar ay dapat makita sa lahat ng umaasang component. Para sa ObservableObject sa SwiftUI, ang mga klase ay sapilitan.

// ObservableObject — class kinakailangan para sa SwiftUI
import SwiftUI

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

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

// Paggamit sa SwiftUI View
struct ContentView: View {
    @StateObject var viewModel = AppViewModel()

    var body: some View {
        Text(viewModel.isLoggedIn ? "Maligayang pagdating" : "Mag-login")
    }
}

Patakaran: kung ang isang object ay dapat magkaroon ng pagkakakilanlan (dalawang referensya -> isang object), maging nag-iisang instance o gumana sa UIKit/Objective-C — piliin ang class. Kung ang object ay nag-iimbak lamang ng data — piliin ang struct.