Final Method

A final method in Swift is an instance or type method declared with the final modifier to explicitly prevent any subclass from overriding its implementation. Applying this modifier alters the method’s resolution mechanism, instructing the Swift compiler to use static (direct) dispatch instead of dynamic (table) dispatch, completely bypassing the class’s virtual method table (vtable).

Syntax and Compiler Behavior

When a method is marked final, the compiler enforces strict inheritance rules. Any attempt to override the method in a subclass results in a compile-time error.

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.

Master Swift with Deep Grasping Methodology!

Learn More