Static func vs class func в Swift: в чём разница?

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

Static func vs class func в Swift: исчерпывающее руководство для разработчиков

Каждый, кто пишет на Swift, рано или поздно сталкивается с дилеммой: static func или class func? На первый взгляд, оба ключевых слова служат для создания методов уровня типа. Но разница между ними — не просто синтаксическая прихоть, а фундаментальное различие, связанное с наследованием и полиморфизмом. В этой статье мы раз и навсегда разберёмся, чем отличается static func от class func в Swift, когда применять каждый из них, и как эти знания помогут писать более чистый и гибкий код.

Что такое методы типа в Swift?

Прежде чем нырять в различия, давайте вспомним основы. В Swift методы делятся на два типа:

Методы экземпляра (instance methods) — вызываются на конкретном объекте класса, структуры или перечисления.
Методы типа (type methods) — вызываются на самом типе, а не на его экземпляре. Для их объявления используются ключевые слова static или class.

Методы типа идеально подходят для фабричных методов, синглтонов, утилитарных функций и конфигураций, не привязанных к конкретному состоянию объекта.

Static func: главный страж неизменности

static func — это метод, который не может быть переопределён в подклассе. Он принадлежит исключительно тому типу, в котором определён. Ключевое слово static работает одинаково для классов, структур и перечислений.

Пример: static func в классе

class Animal {
    static func describe() {
        print("Я — животное. Мою сущность нельзя изменить.")
    }
    
    func speak() {
        print("Издаю звук")
    }
}

class Dog: Animal {
    // Ошибка! Нельзя переопределить static метод
    // override static func describe() { }
    
    override func speak() {
        print("Гав-гав!")
    }
}

// Использование
Animal.describe()  // "Я — животное. Мою сущность нельзя изменить."
Dog.describe()     // Тоже "Я — животное. Мою сущность нельзя изменить."

Обратите внимание: Dog.describe() вызывает метод родительского класса. Хотя технически подкласс наследует статический метод, переопределить его нельзя. Это поведение напоминает final class func.

Static func в структурах

Структуры (value types) также поддерживают статические методы:

struct MathHelper {
    static func square(_ number: Int) -> Int {
        return number * number
    }
}

let result = MathHelper.square(5)  // 25

Поскольку структуры не поддерживают наследование, static здесь — единственный возможный способ объявить метод типа.

Class func: гибкость наследования

class func — это метод типа, который можно переопределить в подклассе. Он доступен только для классов (reference types). Структуры и перечисления не могут использовать class.

Пример: class func и его переопределение

class Vehicle {
    class func makeNoise() {
        print("Транспортное средство издаёт шум")
    }
    
    class final func isMotorized() -> Bool {
        return true
    }
}

class Car: Vehicle {
    override class func makeNoise() {
        print("Автомобиль гудит: бжжжж!")
    }
    
    // Ошибка! Нельзя переопределить final class func
    // override class func isMotorized() -> Bool { return false }
}

// Использование
Vehicle.makeNoise()  // "Транспортное средство издаёт шум"
Car.makeNoise()      // "Автомобиль гудит: бжжжж!"

Как видите, class func ведёт себя как обычный виртуальный метод, но вызывается на уровне типа. Это открывает возможности для полиморфизма на уровне классов.

Главные отличия static func vs class func

Сведём ключевые различия в наглядную таблицу:

Переопределение: static func — нельзя переопределить; class func — можно (если не стоит модификатор final).
Поддерживаемые типы: static — классы, структуры, перечисления; class — только классы.
Полиморфизм: static — статическая диспетчеризация (вызов известен на этапе компиляции); class — динамическая диспетчеризация (вызов определяется во время выполнения).
Аналог в Objective-C: static func ≈ + (type)method без переопределения; class func ≈ + (type)method с возможностью переопределения.

Когда использовать static func, а когда class func?

Выбор между static и class — это не вопрос вкуса, а вопрос архитектуры.

Сценарии для static func:

Вы создаёте утилитарные функции, которые не должны меняться в подклассах (например, математические расчёты).
Вы работаете со структурами или перечислениями.
Нужна максимальная производительность — статическая диспетчеризация быстрее.
Вы реализуете синглтон через статическое свойство.

Сценарии для class func:

Вы проектируете иерархию классов, где подклассы могут предоставлять свою версию метода типа.
Нужен полиморфизм на уровне типа (например, фабричный метод, возвращающий разные классы).
Вы работаете с Objective-C runtime, где class методы могут быть динамически заменены.

Практический пример: фабричный метод с class func

Давайте посмотрим, как class func может быть полезен в реальном проекте:

class Shape {
    class func createDefault() -> Shape {
        return Shape()
    }
    
    func draw() {
        print("Рисую фигуру")
    }
}

class Circle: Shape {
    override class func createDefault() -> Shape {
        return Circle()
    }
    
    override func draw() {
        print("Рисую круг")
    }
}

class Square: Shape {
    override class func createDefault() -> Shape {
        return Square()
    }
    
    override func draw() {
        print("Рисую квадрат")
    }
}

// Использование полиморфизма
let shapes: [Shape.Type] = [Shape.self, Circle.self, Square.self]

for type in shapes {
    let shape = type.createDefault()
    shape.draw()
}
// Вывод:
// Рисую фигуру
// Рисую круг
// Рисую квадрат

Попробуйте заменить class func на static func — и полиморфизм сломается: все вызовы будут возвращать Shape().