Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

A class in Swift is a reference type that defines a custom data structure encapsulating properties, methods, subscripts, and initializers. Unlike value types (structs and enums), class instances are allocated on the heap, managed by Automatic Reference Counting (ARC), and support object-oriented paradigms such as inheritance, polymorphism, and runtime type casting. 
class SuperclassName {
    init() {
        // Base class initialization
    }
    
    func performAction() {
        // Base implementation
    }
}

class SubclassName: SuperclassName {
    // Stored properties
    var mutableProperty: String
    let immutableProperty: Int
    
    // Designated initializer
    init(mutableProperty: String, immutableProperty: Int) {
        self.mutableProperty = mutableProperty
        self.immutableProperty = immutableProperty
        super.init() // Delegation to superclass
    }
    
    // Convenience initializer
    convenience init(mutableProperty: String) {
        self.init(mutableProperty: mutableProperty, immutableProperty: 0)
    }
    
    // Method override
    override func performAction() {
        super.performAction()
        // Additional implementation
    }
    
    // Instance method modifying stored property
    func updateProperty(newValue: String) {
        self.mutableProperty = newValue // No 'mutating' keyword required
    }
    
    // Deinitializer
    deinit {
        // Resource cleanup before ARC deallocation
    }
}

​
Core Characteristics

Reference Semantics When a class instance is assigned to a variable, passed to a function, or added to a collection, Swift passes a reference to the existing memory location rather than creating a copy. Mutating the instance through one variable mutates the underlying object, reflecting the change across all references. Mutability and Methods Unlike value types, methods within a class do not require—and cannot use—the mutating keyword to modify stored properties. Because classes are reference types, their internal state can be modified even if the reference to the class instance is declared as a constant (let), provided the properties themselves are declared as variables (var). Inheritance and Overriding Swift enforces single inheritance. A class can inherit methods, properties, and subscripts from a single superclass. Subclasses must explicitly use the override keyword to modify inherited behavior, preventing accidental shadowing. Classes or specific members can be marked with the final modifier to prevent subclassing or overriding. Initializer Delegation Rules Classes do not receive an implicit memberwise initializer. Swift enforces strict rules for how initializers delegate to one another:
  1. Designated Initializers: Must initialize all uninitialized stored properties introduced by their class before delegating up to a superclass initializer (super.init()).
  2. Convenience Initializers: Must delegate across to another initializer within the same class (self.init()) and ultimately resolve to a designated initializer.
Two-Phase Initialization To guarantee memory safety, class initialization occurs in two distinct phases:
  • Phase 1: Each stored property is assigned an initial value by the class that introduced it. This phase begins at the subclass and delegates up the class hierarchy to the base class.
  • Phase 2: Once the base class is reached and all memory is initialized, the chain works back down. Each class in the hierarchy is granted the opportunity to customize its stored properties or call instance methods before initialization completes.
Deinitialization Classes can define a single deinit block. This block is automatically invoked by ARC immediately before the instance is deallocated, allowing for manual cleanup of resources that ARC does not manage (e.g., closing file handles, terminating network connections, or unregistering observers). Identity Operators Because multiple variables can reference the same class instance, Swift provides identity operators (=== and !==). These operators evaluate whether two variables point to the exact same memory address, which is distinct from the equality operator (==) that evaluates value equivalence based on the Equatable protocol. Type Casting Classes support runtime type inspection and casting. The is operator checks if an instance belongs to a specific subclass type. The as? (conditional) and as! (forced) operators attempt to downcast a reference to a specific subclass type within the class hierarchy.
Master Swift with Deep Grasping Methodology!Learn More