В чем разница между static func и class func в Swift?

Статические методы и методы класса: ключевое отличие в наследовании

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

Краткий ответ:

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

Подробное объяснение с примерами

Представьте, что у вас есть базовый класс и вы хотите, чтобы подклассы могли изменять поведение метода, вызываемого на уровне типа. Используйте class func:

class Animal {
    class func makeSound() {
        print("Животное издает звук")
    }
    
    static func species() {
        print("Вид: Животное")
    }
}

class Dog: Animal {
    // ✅ Разрешено переопределить class func
    override class func makeSound() {
        print("Гав-гав!")
    }
    
    // ❌ Ошибка: нельзя переопределить static func
    // override static func species() { ... }
}

// Вызовы
Animal.makeSound() // "Животное издает звук"
Dog.makeSound()    // "Гав-гав!" — переопределенный метод работает

Animal.species()   // "Вид: Животное"
Dog.species()      // "Вид: Животное" — static не переопределяется

Почему static нельзя переопределить?

Ключевое слово static подразумевает, что метод принадлежит именно этому конкретному типу и не подлежит изменению в иерархии наследования. Это делает код более предсказуемым и безопасным. По сути, static func — это class final func.

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

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

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

1. Свойства: То же самое правило действует для свойств. static var — конечное, class var — переопределяемое (при этом обязательно указывать { get set }).
2. Структуры и перечисления: У них нет наследования, поэтому доступен только static. class для них не применим.
3. Протоколы: В протоколах можно объявить и static, и class требования, но реализация в структурах будет только static, а в классах — любая.

Пример с полиморфизмом

Допустим, у вас есть игра с разными типами персонажей. Использование class func позволит централизованно создавать персонажей через фабричный метод:

class Character {
    class func create() -> Character {
        return Character()
    }
}

class Warrior: Character {
    override class func create() -> Character {
        return Warrior()
    }
}

class Mage: Character {
    override class func create() -> Character {
        return Mage()
    }
}

// Использование
let hero = Warrior.create() // вернет экземпляр Warrior

Если бы create был объявлен как static, то Warrior.create() всегда возвращал бы Character, а не Warrior.

Итог

static func — это жесткая привязка к типу без возможности переопределения. class func — гибкий механизм для полиморфизма в классах. Выбирайте в зависимости от того, нужна ли вам переопределяемость.

class MyClass {
    final class func doSomething() { }
}