> ## 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.
# 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.
```swift theme={"dark"}
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.
```swift theme={"dark"}
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.
```swift theme={"dark"}
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:**
1. You cannot add property observers to inherited constant stored properties (`let`) or inherited read-only computed properties, because their values cannot be mutated.
2. 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
