> ## 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 Class Property
A class property is a type-level property associated with a class definition itself rather than with any specific instance of that class. In Swift, class properties are declared using the `class` keyword, which enables dynamic dispatch and allows subclasses to override the property's implementation.
## Technical Characteristics
* **Computed Only:** Swift restricts the `class` keyword to *computed* properties. You cannot declare a stored `class` property.
* **Overridability:** The primary mechanical distinction of a `class` property is that it permits subclass overriding.
* **Type-Level Access:** Class properties are accessed and mutated through the type name directly, or dynamically at runtime using the type of an instance.
## Syntax and Dynamic Dispatch
To declare an overridable type property, use the `class` modifier followed by `var` and a computed getter (and optionally a setter). Because `class` properties utilize dynamic dispatch, their overridden implementations can be resolved at runtime polymorphically.
```swift theme={"dark"}
class BaseClass {
// A computed class property (Overridable)
class var overridableProperty: String {
return "Base Implementation"
}
// A method demonstrating polymorphic access
func printProperty() {
print(type(of: self).overridableProperty)
}
}
class SubClass: BaseClass {
// Overriding the computed class property
override class var overridableProperty: String {
return "Subclass Implementation"
}
}
// Upcasting a SubClass instance to BaseClass
let instance: BaseClass = SubClass()
// Demonstrating dynamic dispatch via type(of:)
let dynamicValue = type(of: instance).overridableProperty
// Evaluates to "Subclass Implementation"
// Demonstrating dynamic dispatch via internal type(of: self)
instance.printProperty()
// Prints "Subclass Implementation"
```
## `class` vs. `static`
While both `class` and `static` define type properties, they dictate different dispatch mechanisms and storage capabilities:
1. **`class` Properties:** Utilize dynamic dispatch. They are strictly computed properties that subclasses can override.
2. **`static` Properties:** Utilize static dispatch. They can be either stored or computed properties. For *computed* properties, a `static` declaration is mechanically equivalent to a `final class` declaration, meaning it cannot be overridden by subclasses. However, this equivalence does not apply to stored properties, as the `class` keyword strictly prohibits stored properties, even when marked `final`.
## Memory and Initialization
Because `class` properties are strictly computed, they do not occupy persistent memory for state storage. They execute their defined getter and setter blocks upon access. If state storage is required at the type level within a class hierarchy, a `static` stored property must be used. Stored `static` properties are lazily initialized on their first access and are guaranteed by the Swift runtime to be thread-safe during initialization.
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
