Чем отличаются static и class для статических свойств и методов?

Отличие static и class в Swift

В Swift ключевые слова static и class используются для объявления статических (или типовых) свойств и методов, но между ними есть важные различия, связанные с поддержкой наследования и полиморфизма.

Основное сходство

Оба ключевых слова позволяют обращаться к свойствам и методам не через экземпляр, а через сам тип, используя синтаксис ИмяТипа.свойство или ИмяТипа.метод(). Они принадлежат самому типу, а не его экземплярам.

Ключевые различия

1. Поддержка переопределения (override)

• class — может быть переопределён в подклассах с использованием ключевого слова override. Это позволяет реализовать полиморфизм на уровне типов.
• static — не может быть переопределён. Он является финализированным (final) по своей природе, даже без явного указания final.

2. Применимость

• class — используется только в классах и только для методов и свойств, поддерживающих вычисление (computed properties). Не может использоваться для хранения значений (stored properties) в классах.
• static — может использоваться как в классах, так и в структурах (struct), перечислениях (enum) и протоколах. Поддерживает как stored properties, так и computed properties, а также методы.

Примеры кода

Использование class для переопределяемого метода

class Vehicle {
    class func description() -> String {
        return "Это транспортное средство"
    }
}

class Car: Vehicle {
    override class func description() -> String {
        return "Это автомобиль"
    }
}

print(Vehicle.description()) // "Это транспортное средство"
print(Car.description())     // "Это автомобиль"

Использование static для финализированных членов

struct MathUtils {
    static let pi = 3.14159 // stored property
    
    static func square(_ x: Double) -> Double {
        return x * x
    }
}

class Configuration {
    static let version = "1.0" // static stored property в классе
    
    static func defaultSettings() -> [String: Any] {
        return ["theme": "light"]
    }
}

print(MathUtils.pi)               // 3.14159
print(Configuration.version)      // "1.0"

Попытка переопределить static приведёт к ошибке

class Base {
    static func utility() { print("Base utility") }
}

class Derived: Base {
    // ОШИБКА: Cannot override static method
    // override static func utility() { }
}

class для вычисляемых свойств с возможностью переопределения

class Animal {
    class var speciesName: String {
        return "Animal"
    }
}

class Dog: Animal {
    override class var speciesName: String {
        return "Canis lupus familiaris"
    }
}

print(Animal.speciesName) // "Animal"
print(Dog.speciesName)    // "Canis lupus familiaris"

Когда что использовать?

Используйте class, когда:

• Работаете исключительно с классами (не со структурами или перечислениями)
• Нужна возможность переопределения в подклассах
• Объявляете вычисляемое свойство или метод на уровне типа

Используйте static, когда:

• Нужна универсальность (работа со структурами, перечислениями, протоколами)
• Требуется объявить stored property на уровне типа в классе
• Нужно запретить переопределение (явно указать финализированное поведение)
• Пишете расширения (extension) для существующих типов, где часто используется static

Важные нюансы

1. В протоколах можно требовать реализации статических членов только через static:

protocol Identifiable {
    static var id: String { get }
}

struct User: Identifiable {
    static let id = "user_identifier" // обязательно static
}

1. В расширениях для классов также предпочтительнее static для единообразия:

extension String {
    static var empty: String { return "" } // всегда static в расширениях
}

1. Производительность: static members могут быть немного эффективнее в некоторых случаях, так как компилятор может выполнять дополнительные оптимизации для финализированных членов.

Заключение

Основное концептуальное отличие заключается в поддержке полиморфизма: class позволяет создавать иерархии типовых методов и свойств, сохраняя принципы ООП, в то время как static предоставляет более простой, финализированный подход, универсально применимый ко всем типам данных в Swift. Выбор между ними зависит от конкретных требований к дизайну вашей системы типов и необходимости поддержки наследования.