Class

Junior

Essence

A class describes a type of objects: their properties, methods and initialisers. It is the blueprint instances are built from. In Swift a class is a reference type: the instance lives on the heap, variables hold a reference to it, and ARC manages its lifetime.

What makes a class special in Swift

• Reference semantics: let b = a gives two references to one object; a change through b is visible through a.
• Inheritance (single): override of methods and properties, super; final forbids subclassing and speeds up calls (static dispatch instead of vtable).
• Initialisers: designated/convenience, two-phase initialisation, every property must have a value before super.init.
• deinit runs when the object is freed; structs have none.
• Identity: ===, ObjectIdentifier.
• Objective-C interoperability: only classes can inherit from NSObject and be @objc.

class Animal {
    let name: String
    init(name: String) { self.name = name }
    func sound() -> String { "..." }
    deinit { print("\(name) released") }
}

final class Dog: Animal {                  // final: no further subclassing
    override func sound() -> String { "Woof" }
}

func demo() {
    var pet: Animal? = Dog(name: "Rex")
    let same = pet  // a second reference to the same object
    print(pet!.sound())                    // Woof — dynamic dispatch
    pet = nil  // the object is alive: `same` holds it
    print(same?.name ?? "nil")             // Rex
}                                          // same goes away → "Rex released"

Class vs struct — the follow-up question

• struct: copied, no inheritance (protocols instead), no deinit, usually on the stack, Sendable by default when all fields are Sendable.
• class: a reference, inheritance, deinit, heap + ARC; in Swift 6 passing it between threads needs @MainActor/actor or manual synchronisation.

Apple recommends starting with a struct and using a class when you need identity (a shared mutable resource, a controller, a cache), inheritance from system classes (UIView, NSObject) or deinit.

What the interviewer looks for

• Do you know that let on a class fixes the reference, not the contents.
• Do you understand why final exists (performance, closed for extension) and how class func differs from static func (the former can be overridden).
• Can you explain a retain cycle: two objects holding strong references to each other never reach deinit; the cure is weak/unowned.