Final используется только для классов?

Нет, ключевое слово final в Swift используется НЕ только для классов. Оно применяется к любому наследуемому элементу языка, чтобы запретить его дальнейшее переопределение (override) или наследование.

Основные области применения final

1. Для классов

Это наиболее известный случай. final запрещает наследование от класса.

final class Vehicle {
    // Этот класс нельзя унаследовать
    func move() {
        print("Moving")
    }
}

// Ошибка компиляции: Inheritance from a final class 'Vehicle'
// class Car: Vehicle { }

2. Для методов (функций) внутри класса

final запрещает переопределение метода в подклассах. Это особенно полезно, когда вы хотите зафиксировать реализацию ключевого метода, но оставить возможность наследования самого класса.

class Shape {
    // Этот метод нельзя переопределить в дочерних классах
    final func draw() {
        print("Basic drawing logic")
    }
    
    // Этот метод можно переопределить
    func calculateArea() -> Double {
        return 0.0
    }
}

class Circle: Shape {
    // Можно переопределить
    override func calculateArea() -> Double {
        return 3.14 * radius * radius
    }
    
    // Ошибка: Cannot override a final method
    // override func draw() { }
}

3. Для свойств (properties)

Аналогично методам, final может быть применен к свойствам (как stored, так и computed), чтобы запретить их переопределение в подклассах.

class Database {
    // Final stored property
    final let connectionString: String
    
    init(connectionString: String) {
        self.connectionString = connectionString
    }
    
    // Final computed property
    final var isConnected: Bool {
        return !connectionString.isEmpty
    }
}

class PostgreSQLDatabase: Database {
    // Ошибка: Cannot override a final property
    // override var isConnected: Bool { return true }
}

4. Для сабскриптов (subscripts)

final также работает с сабскриптами.

class DataContainer {
    private var data: [Int] = []
    
    final subscript(index: Int) -> Int {
        get { return data[index] }
        set { data[index] = newValue }
    }
}

Ключевые моменты и преимущества использования final

• Оптимизация производительности: Когда компилятор Swift видит final, он знает, что диспетчеризация (определение того, какой метод вызывать) будет всегда статической, а не динамической (через vtable). Это позволяет проводить агрессивную оптимизацию, инлайнинг методов и в целом повышает скорость выполнения кода.
• Безопасность и проектирование: final явно выражает намерение разработчика. Если элемент помечен как final, это контракт, гарантирующий, что его поведение не изменится в подклассах. Это предотвращает случайное или злонамеренное переопределение критически важной логики.
• Упрощение рефакторинга: Зная, что класс или метод final, вы можете безопасно менять его реализацию, не опасаясь сломать работу неизвестных подклассов в кодовой базе.
• Применимость к протоколам: Хотя непосредственно к протоколам final не применяется, класс, реализующий протокол, может быть объявлен как final, что запретит наследование от этого класса.

Практический пример использования

// Базовый класс, который можно наследовать, но с защищенным API
class NetworkService {
    // Критический метод подключения - финализирован для безопасности
    final func establishConnection() {
        // Базовая, надежная логика установки соединения
        print("Establishing secure connection...")
    }
    
    // Метод для обработки данных - можно кастомизировать в наследниках
    func processData(_ data: Data) {
        // Базовая реализация
    }
}

// Специализированный сервис
class JSONNetworkService: NetworkService {
    // Можно переопределить
    override func processData(_ data: Data) {
        // Специфичная обработка JSON
        print("Processing JSON data")
    }
    
    // НЕЛЬЗЯ переопределить establishConnection()
}

// Финальный класс-утилита, который не предназначен для расширения
final class Logger {
    static let shared = Logger()
    
    private init() {}
    
    func log(_ message: String) {
        print("[LOG]: \(message)")
    }
}

Итог

Ключевое слово final в Swift — это мощный инструмент контроля над иерархией наследования, который применяется к классам, методам, свойствам и сабскриптам. Его использование:

1. Запрещает наследование (для классов).
2. Запрещает переопределение (для методов, свойств, сабскриптов).
3. Повышает производительность за счет статической диспетчеризации.
4. Улучшает дизайн API, явно обозначая элементы, не предназначенные для модификации.

Рекомендуется активно использовать final по умолчанию, особенно при разработке библиотек и фреймворков, а также в performance-critical коде, и снимать это ограничение только там, где действительно требуется полиморфное поведение и наследование.