Приведи пример типов полиморфизма

Полиморфизм в Swift: Типы и примеры

Полиморфизм — одна из ключевых концепций объектно-ориентированного программирования (ООП), позволяющая объектам разных типов обрабатываться через единый интерфейс. В Swift полиморфизм проявляется через несколько механизмов, каждый из которых решает конкретные задачи проектирования.

1. Параметрический полиморфизм (Generics)

Параметрический полиморфизм позволяет писать код, который работает с разными типами данных, оставаясь типобезопасным. Это достигается через обобщённые типы (generics).

// Обобщённая функция
func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

// Работает с любыми типами
var x = 5, y = 10
swapValues(&x, &y) // Int

var str1 = "Hello", str2 = "World"
swapValues(&str1, &str2) // String

// Обобщённый тип
struct Stack<Element> {
    private var items: [Element] = []
    
    mutating func push(_ item: Element) {
        items.append(item)
    }
    
    mutating func pop() -> Element? {
        return items.popLast()
    }
}

// Использование с разными типами
var intStack = Stack<Int>()
intStack.push(42)

var stringStack = Stack<String>()
stringStack.push("Polymorphism")

Ключевые преимущества:

• Повторное использование кода без дублирования
• Компилятор гарантирует типобезопасность — ошибки несоответствия типов обнаруживаются на этапе компиляции
• Улучшенная производительность в сравнении с динамическим полиморфизмом (отсутствие накладных расходов на диспетчеризацию)

2. Полиморфизм подтипов (Subtype Polymorphism)

Полиморфизм подтипов — классический вид полиморфизма в ООП, когда объекты производных классов могут использоваться вместо объектов базовых классов. В Swift реализуется через наследование и протоколы.

// Базовый класс
class Vehicle {
    func move() {
        print("Vehicle is moving")
    }
}

// Производные классы
class Car: Vehicle {
    override func move() {
        print("Car drives on the road")
    }
}

class Airplane: Vehicle {
    override func move() {
        print("Airplane flies in the sky")
    }
}

// Полиморфное использование
let vehicles: [Vehicle] = [Car(), Airplane()]

for vehicle in vehicles {
    vehicle.move() // Вызывается соответствующая реализация
    // Вывод:
    // Car drives on the road
    // Airplane flies in the sky
}

// Полиморфизм через протоколы
protocol Drawable {
    func draw()
}

class Circle: Drawable {
    func draw() {
        print("Drawing a circle")
    }
}

class Rectangle: Drawable {
    func draw() {
        print("Drawing a rectangle")
    }
}

let shapes: [Drawable] = [Circle(), Rectangle()]
for shape in shapes {
    shape.draw() // Каждый объект рисуется по-своему
}

Особенности в Swift:

• Поддерживается как через классы и наследование, так и через протоколы
• Динамическая диспетчеризация — решение о том, какой метод вызывать, принимается во время выполнения
• Для протоколов с требованиями к ссылочным типам используется Protocol Witness Table

3. Ad-hoc полиморфизм (перегрузка)

Ad-hoc полиморфизм позволяет определять несколько реализаций функции с одним именем, но разными параметрами. Компилятор выбирает подходящую версию на основе типов аргументов.

// Перегрузка функций
func process(_ value: Int) {
    print("Processing integer: \(value)")
}

func process(_ value: String) {
    print("Processing string: \(value)")
}

func process(_ value: Double) {
    print("Processing double: \(value * 2)")
}

// Компилятор выбирает нужную функцию
process(10)        // "Processing integer: 10"
process("Text")    // "Processing string: Text"
process(3.14)      // "Processing double: 6.28"

// Перегрузка операторов
struct Vector2D {
    var x: Double
    var y: Double
    
    static func +(left: Vector2D, right: Vector2D) -> Vector2D {
        return Vector2D(x: left.x + right.x, y: left.y + right.y)
    }
    
    static func *(vector: Vector2D, scalar: Double) -> Vector2D {
        return Vector2D(x: vector.x * scalar, y: vector.y * scalar)
    }
}

let v1 = Vector2D(x: 1, y: 2)
let v2 = Vector2D(x: 3, y: 4)
let result1 = v1 + v2  // Используется первая перегрузка
let result2 = v1 * 2.5 // Используется вторая перегрузка

Характеристики:

• Разрешение во время компиляции — нет накладных расходов на диспетчеризацию
• Улучшает читаемость кода через использование осмысленных имён для разных операций
• Особенно полезен для создания DSL (Domain-Specific Languages) и математических библиотек

4. Полиморфизм через протоколы с связанными типами (Protocols with Associated Types)

В Swift протоколы с связанными типами (Associated Types) позволяют создавать более гибкие обобщённые абстракции, чем классические дженерики.

protocol Container {
    associatedtype Item
    var count: Int { get }
    mutating func append(_ item: Item)
    subscript(index: Int) -> Item { get }
}

struct IntStack: Container {
    typealias Item = Int
    private var items: [Int] = []
    
    var count: Int { items.count }
    
    mutating func append(_ item: Int) {
        items.append(item)
    }
    
    subscript(index: Int) -> Int {
        return items[index]
    }
}

// Универсальная реализация
struct GenericStack<Element>: Container {
    typealias Item = Element
    private var items: [Element] = []
    
    var count: Int { items.count }
    
    mutating func append(_ item: Element) {
        items.append(item)
    }
    
    subscript(index: Int) -> Element {
        return items[index]
    }
}

// Использование с ограничениями where
func allItemsMatch<C1: Container, C2: Container>(
    _ container1: C1, 
    _ container2: C2
) -> Bool where C1.Item == C2.Item, C1.Item: Equatable {
    guard container1.count == container2.count else { return false }
    
    for i in 0..<container1.count {
        if container1[i] != container2[i] {
            return false
        }
    }
    return true
}

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

Рекомендации по применению:

• Используйте параметрический полиморфизм для алгоритмов и структур данных, которые должны работать с разными типами
• Полиморфизм подтипов идеален для моделирования иерархий "is-a" и реализации паттернов проектирования
• Ad-hoc полиморфизм применяйте для создания удобных API и перегрузки операторов
• Протоколы с связанными типами выбирайте, когда нужны сложные ограничения между типами

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