Answer: Both static and class define type-level properties and methods, but static members cannot be overridden by subclasses (final), whereas class members allow dynamic dispatch and can be overridden.

Feature	static	class
Can be overridden?	No (implicitly final)	Yes (supports polymorphism)
Supported types	class, struct, enum, actor, protocol	class only (and class-bound protocols)
Stored properties	Yes (static let / static var)	No (computed properties only)
Dispatch mechanism	Static / direct dispatch (fast)	Dynamic / table dispatch
Equivalence	static func is equivalent to class final func	class func

Code Example:

class Vehicle {
    // static stored property (lazy & thread-safe)
    static let defaultWheelCount = 4

    // static method — CANNOT be overridden
    static func generalInfo() -> String {
        return "Vehicles are used for transportation."
    }

    // class computed property — CAN be overridden
    class var category: String {
        return "Generic Vehicle"
    }

    // class method — CAN be overridden
    class func maxSpeed() -> Int {
        return 120
    }
}

class SportsCar: Vehicle {
    // ❌ Error: Cannot override static method
    // override static func generalInfo() -> String { ... }

    // ✅ OK: Overriding class computed property
    override class var category: String {
        return "High Performance Vehicle"
    }

    // ✅ OK: Overriding class method
    override class func maxSpeed() -> Int {
        return 300
    }
}

Key Points:

• static is available across structs, enums, actors, and classes; class is strictly for class types.
• static let / var stored properties are lazily initialized on first access and guaranteed thread-safe (via dispatch_once under the hood).
• In protocols, type requirements are always declared using static. Conforming classes can implement them with either static (to prevent subclass overrides) or class (to allow subclass overrides).
• Prefer static by default unless you explicitly intend for subclasses to override the behavior.