Final Method

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.

​

Syntax and Compiler Behavior

class BaseClass {
    // A standard method utilizing dynamic dispatch
    func standardMethod() {
        print("Base implementation")
    }
    
    // A final method utilizing static dispatch
    final func lockedMethod() {
        print("Final implementation")
    }
}

class DerivedClass: BaseClass {
    // Valid: Overriding a dynamically dispatched method
    override func standardMethod() {
        print("Derived implementation")
    }
    
    // COMPILER ERROR: Instance method overrides a 'final' instance method
    // override func lockedMethod() {
    //     print("Attempted override")
    // }
}

​

Technical Characteristics

• Dispatch Mechanism: By default, Swift classes use dynamic dispatch for methods, requiring the runtime to look up the method’s implementation in a vtable before executing it. The final keyword eliminates this overhead by emitting direct function calls. Instead of hardcoding absolute memory addresses, the compiler and linker resolve these direct calls using relative offsets, maintaining compatibility with modern Position Independent Code (PIC) and Address Space Layout Randomization (ASLR).
• Compiler Optimization: Because the compiler guarantees the method cannot be overridden, it can aggressively optimize the code. This includes inlining the method—replacing the function call entirely with the function’s body—which reduces call-stack overhead.
• Type Restriction: The final modifier is exclusively applicable to reference types (class). Value types (struct and enum) do not support inheritance; therefore, their methods are inherently statically dispatched, rendering the final keyword syntactically invalid in those contexts.
• Type Methods: When applied to a type method (class func), the final modifier prevents subclasses from providing their own implementation. A final class func is functionally identical to a static func.

class Configuration {
    // Can be overridden by subclasses
    class func defaultSettings() {} 
    
    // Cannot be overridden; identical in behavior to 'static func'
    final class func coreSettings() {} 
}

• Extension Behavior: Native Swift does not support overriding methods declared in extensions. Methods declared within a class extension cannot be overridden by subclasses unless explicitly marked with the @objc dynamic modifiers, which forces the method to rely entirely on the Objective-C runtime for message passing. Without @objc dynamic, extension methods are implicitly statically dispatched. While functionally redundant, explicitly declaring these non-@objc extension methods as final is permitted by the compiler.