Swift Override Property

In Swift, overriding a property allows a subclass to provide a custom implementation for an instance or class property inherited from its superclass. This is achieved using the override keyword and enables the subclass to modify the inherited property’s getter, setter, or attach property observers (willSet and didSet), regardless of whether the original property was implemented as a stored or computed property.

Syntax and Signature Matching

When overriding a property, you must explicitly state both the name and the type of the property. This allows the Swift compiler to verify that the override matches a valid property in the superclass chain.

override var propertyName: PropertyType {
    // Implementation of getter, setter, or observers
}

Rules for Overriding Mutability

Swift enforces strict rules regarding the read/write mutability of overridden properties:

Expanding Mutability: You can present an inherited read-only property as a read-write property by providing both a get and a set block in your subclass.
Restricting Mutability: You cannot present an inherited read-write property as a read-only property. If the superclass provides a setter, the subclass override must also provide a setter.

Overriding Getters and Setters

You cannot override an inherited stored property with a new stored property. Overriding inherently requires providing a custom getter (and optionally a setter). When overriding a getter or setter, you typically access the inherited value using the super prefix to avoid infinite recursion.

class BaseClass {
    var numericValue: Int {
        return 10
    }
}

class DerivedClass: BaseClass {
    // Overriding a read-only property to make it read-write
    override var numericValue: Int {
        get {
            return super.numericValue * 2
        }
        set {
            // Custom setter implementation
        }
    }
}

Overriding Property Observers

Instead of modifying the getter or setter, you can override a property to add willSet and didSet observers to an inherited property. This allows the subclass to be notified when the inherited property’s value changes.

class BaseClass {
    var status: String = "Active"
}

class DerivedClass: BaseClass {
    override var status: String {
        willSet {
            // Executes before the value is stored
        }
        didSet {
            // Executes after the value is stored
        }
    }
}

Constraints on Property Observers:

You cannot add property observers to inherited constant stored properties (let) or inherited read-only computed properties, because their values cannot be mutated.
You cannot provide both a custom setter and property observers for the same overridden property. If you need to observe changes and you are already providing a custom setter, you must place the observation logic directly inside the custom setter.

Tired of Poor Swift Skills? Fix That With Deep Grasping!Learn More