🍎 Swift

POO: Herança em Swift: Um Guia Detalhado

Lição 18 / 36 • Leitura completa da teoria

Что это такое и зачем? (аналогия из реальной жизни)

Представь, что ты решил создать свою видеоигру. В ней будут разные персонажи: эльфы, орки, маги и драконы. У каждого из них есть общие свойства: имя, уровень здоровья, сила атаки. И есть общие действия: бежать, атаковать, получать урон.

Если бы мы писали код для каждого персонажа с нуля, нам пришлось бы 100 раз повторять одно и то же: «у эльфа есть имя, у орка есть имя, у мага есть имя...». Это скучно, долго и очень легко ошибиться. А если мы захотим добавить всем персонажам новое свойство, например «мана»? Придётся лезть в код каждого класса и добавлять его вручную.

Тут на помощь приходит наследование. Это механизм, который позволяет создать один общий класс (назовём его Персонаж) с базовыми свойствами и методами, а затем сказать: «Эльф — это Персонаж, но с длинными ушами и магией». Или: «Орк — это Персонаж, но с яростью и топором».

Аналогия из жизни: Представь, что ты рисуешь животных. Сначала ты рисуешь общий контур: голова, туловище, 4 лапы, хвост. Это твой «родительский» класс. Потом ты берёшь этот контур и дорисовываешь кошке усы, собаке — длинный язык, а зайцу — длинные уши. Ты не рисуешь каждый раз голову и лапы заново — ты используешь готовую основу. Вот это и есть наследование.

В программировании наследование решает три главные задачи:

Переиспользование кода: Не нужно писать одно и то же много раз.
Иерархия: Код становится логичным и структурированным, как в реальном мире.
Расширяемость: Легко добавить новый класс на основе существующего, не ломая старый код.

Теория: как это работает изнутри

Давай заглянем «под капот» и разберёмся, что на самом деле происходит в памяти компьютера, когда мы используем наследование.

Базовый класс (Родитель, Суперкласс)

Это класс, от которого наследуют. Он содержит самые общие свойства и методы. В нашей аналогии с животными — это класс «Животное» с методом «дышать».

Производный класс (Дочерний, Подкласс)

Это класс, который наследует всё от родителя, а потом добавляет что-то своё. Например, класс «Кошка» наследует «дышать» от «Животного» и добавляет метод «мурлыкать».

Цепочка наследования

Наследование может быть многоуровневым. Класс «Котёнок» может наследовать от «Кошка», которая наследует от «Животное». Получается цепочка: Котёнок → Кошка → Животное. Котёнок умеет и дышать (от Животного), и мурлыкать (от Кошки), и пищать (своё).

Важно: В Swift, в отличие от C++, нет множественного наследования. Класс может иметь только одного прямого родителя. Но это не ограничение — это защита от путаницы. Представь, что ты наследуешь одновременно от «Человек» и от «Птица». Какой метод «летать» ты унаследуешь? В Swift такой проблемы нет.

Переопределение (Override)

Дочерний класс может изменить поведение метода родителя. Например, у всех «Животных» есть метод «подать_голос()», который выводит «...». Но «Кошка» переопределяет его и выводит «Мяу!». Это называется полиморфизм — способность объектов разных классов отвечать на одни и те же сообщения по-своему.

super — ключ к родителю

Внутри дочернего класса мы можем обратиться к родителю через ключевое слово super. Это нужно, когда мы хотим не заменить метод родителя полностью, а дополнить его. Например, «Кошка» сначала делает всё, что делает «Животное» при пробуждении (открывает глаза, зевает), а потом добавляет своё (потягивается и мурлыкает).

Синтаксис в Swift: все формы и варианты

В Swift наследование реализуется очень элегантно. Давай разберём все возможные варианты.

Объявление базового класса

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

// Создаём базовый класс "ТранспортноеСредство"
class ТранспортноеСредство {
    // Свойства
    var скорость: Int = 0
    var количество_колёс: Int
    
    // Инициализатор (конструктор)
    init(колёса: Int) {
        self.количество_колёс = колёса
    }
    
    // Метод, который можно переопределить
    func описать() -> String {
        return "Это транспортное средство с (количество_колёс) колёсами"
    }
    
    // Метод, который НЕЛЬЗЯ переопределить (final)
    final func завести() {
        print("Двигатель запущен")
    }
}

Наследование и переопределение

Чтобы создать дочерний класс, нужно указать родителя через двоеточие. Для переопределения метода используется ключевое слово override.

// Класс "Автомобиль" наследует от "ТранспортноеСредство"
class Автомобиль: ТранспортноеСредство {
    var марка: String
    
    // Инициализатор дочернего класса
    init(марка: String) {
        self.марка = марка
        // Сначала вызываем инициализатор родителя
        super.init(колёса: 4)
    }
    
    // Переопределяем метод родителя
    override func описать() -> String {
        // Используем super, чтобы взять часть описания от родителя
        let базовое_описание = super.описать()
        return "(базовое_описание). Это автомобиль марки (марка)"
    }
}

Свойства: наследование и переопределение

Можно переопределять не только методы, но и свойства (вычисляемые). Хранимые свойства переопределить нельзя, но можно добавить наблюдателей (willSet/didSet).

class Электромобиль: Автомобиль {
    var заряд_батареи: Int = 100
    
    override var скорость: Int {
        didSet {
            if скорость > 100 {
                print("Внимание! Высокая скорость для электромобиля!")
            }
        }
    }
    
    // Переопределяем вычисляемое свойство
    override var описание: String {
        return "Электромобиль (марка), заряд: (заряд_батареи)%"
    }
}

Запрет наследования (final)

Если поставить final перед классом, от него нельзя будет наследовать. Если поставить final перед методом или свойством, его нельзя будет переопределить.

final class СекретныйАвтомобиль: Автомобиль {
    // Этот класс нельзя унаследовать
}

Примеры кода — от простого к сложному

Пример 1: Базовое наследование

// Родительский класс
class Робот {
    var имя: String
    
    init(имя: String) {
        self.имя = имя
    }
    
    func приветствие() {
        print("Привет! Я (имя).")
    }
}

// Дочерний класс
class БоевойРобот: Робот {
    var урон: Int
    
    init(имя: String, урон: Int) {
        self.урон = урон
        super.init(имя: имя)  // Вызываем родительский инициализатор
    }
    
    func атаковать() {
        print("(имя) атакует с уроном (урон)!")
    }
}

// Использование
let робот = Робот(имя: "R2-D2")
робот.приветствие()  // "Привет! Я R2-D2."

let боевой = БоевойРобот(имя: "Терминатор", урон: 50)
боевой.приветствие()  // "Привет! Я Терминатор." (унаследованный метод)
боевой.атаковать()    // "Терминатор атакует с уроном 50!" (свой метод)

Пример 2: Переопределение метода

class Животное {
    func звук() -> String {
        return "..."
    }
}

class Собака: Животное {
    override func звук() -> String {
        return "Гав-гав!"
    }
}

class Кошка: Животное {
    override func звук() -> String {
        return "Мяу!"
    }
}

// Полиморфизм в действии
let животные: [Животное] = [Собака(), Кошка(), Животное()]
for животное in животные {
    print(животное.звук())  // Каждый объект ведёт себя по-своему
}
// Вывод:
// Гав-гав!
// Мяу!
// ...

Пример 3: super — вызов родительского метода

class Повар {
    func готовить() {
        print("Готовлю базовое блюдо")
    }
}

class Сушист: Повар {
    override func готовить() {
        super.готовить()  // Сначала делаем базовую готовку
        print("...и заворачиваю роллы!")
    }
}

let сушист = Сушист()
сушист.готовить()
// Вывод:
// Готовлю базовое блюдо
// ...и заворачиваю роллы!

Пример 4: Многоуровневое наследование

class Устройство {
    var включено = false
    
    func включить() {
        включено = true
        print("Устройство включено")
    }
}

class Смартфон: Устройство {
    func звонить(номер: String) {
        if включено {
            print("Звоню на номер (номер)")
        } else {
            print("Сначала включите телефон!")
        }
    }
}

class Айфон: Смартфон {
    override func включить() {
        super.включить()
        print("Добро пожаловать в iOS!")
    }
    
    func использоватьFaceID() {
        print("Сканирую лицо... Доступ разрешён!")
    }
}

let телефон = Айфон()
телефон.включить()
// Вывод:
// Устройство включено
// Добро пожаловать в iOS!
телефон.звонить(номер: "+7-999-123-45-67")
// Вывод: Звоню на номер +7-999-123-45-67
телефон.использоватьFaceID()
// Вывод: Сканирую лицо... Доступ разрешён!

Пример 5: Наследование и инициализаторы

class Фигура {
    var цвет: String
    
    init(цвет: String) {
        self.цвет = цвет
    }
    
    func площадь() -> Double {
        return 0
    }
}

class Круг: Фигура {
    var радиус: Double
    
    init(цвет: String, радиус: Double) {
        self.радиус = радиус
        super.init(цвет: цвет)  // Обязательно вызываем родительский init
    }
    
    override func площадь() -> Double {
        return Double.pi * радиус * радиус
    }
}

class Прямоугольник: Фигура {
    var ширина: Double
    var высота: Double
    
    init(цвет: String, ширина: Double, высота: Double) {
        self.ширина = ширина
        self.высота = высота
        super.init(цвет: цвет)
    }
    
    override func площадь() -> Double {
        return ширина * высота
    }
}

let круг = Круг(цвет: "Красный", радиус: 5.0)
print("Площадь круга: (круг.площадь())")  // 78.54

let прямоугольник = Прямоугольник(цвет: "Синий", ширина: 4.0, высота: 6.0)
print("Площадь прямоугольника: (прямоугольник.площадь())")  // 24.0

Пример 6: Наблюдатели свойств при наследовании

class БанковскийСчёт {
    var баланс: Double = 0 {
        didSet {
            if баланс < 0 {
                print("Внимание! Отрицательный баланс!")
            }
        }
    }
    
    func пополнить(сумма: Double) {
        баланс += сумма
    }
}

class КредитныйСчёт: БанковскийСчёт {
    var кредитныйЛимит: Double = 1000
    
    override var баланс: Double {
        didSet {
            if баланс < -кредитныйЛимит {
                print("Критично! Превышен кредитный лимит!")
            }
        }
    }
    
    override func пополнить(сумма: Double) {
        super.пополнить(сумма: сумма)
        print("Баланс обновлён: (баланс) руб.")
    }
}

let счёт = КредитныйСчёт()
счёт.пополнить(сумма: 500)  // Баланс обновлён: 500.0 руб.
счёт.баланс = -1500  // Критично! Превышен кредитный лимит!

Пример 7: final — защита от переопределения

class Документ {
    final func идентификатор() -> String {
        return "Док-(UUID().uuidString)"
    }
    
    func описание() -> String {
        return "Это документ"
    }
}

class СекретныйДокумент: Документ {
    // Ошибка! Нельзя переопределить final метод
    // override func идентификатор() -> String { ... }
    
    override func описание() -> String {
        return "Это СЕКРЕТНЫЙ документ"
    }
}

final class ЗасекреченныйДокумент: Документ {
    // От этого класса вообще нельзя наследовать
}

Сравнение с Python: чем похоже и чем отличается

Если ты уже знаком с Python или планируешь изучать его, вот ключевые различия в реализации наследования:

Характеристика	Swift	Python
Множественное наследование	Нет. Только один родитель.	Да. Можно наследовать от нескольких классов.
Ключевое слово для переопределения	`override` — обязательно указывать.	Не нужно. Метод просто переопределяется.
Вызов родительского метода	`super.метод()`	`super().метод()` или `Родитель.метод(self)`
Инициализация	Строгие правила: нужно вызвать `super.init()` после установки своих свойств.	Гибкая: `super().__init__()` можно вызывать в любом месте.
Запрет наследования	`final class` — явный запрет.	Нет встроенного механизма (можно через метаклассы, но сложно).
Типизация	Строгая статическая. Компилятор проверяет типы.	Динамическая. Ошибки могут проявиться в рантайме.
Протоколы/Интерфейсы	Есть протоколы (аналог интерфейсов). Класс может подписываться на множество протоколов.	Есть абстрактные классы через `ABC`.

Совет: Если ты переходишь с Python на Swift, запомни главное правило: в Swift нужно явно писать override и строго соблюдать порядок инициализации. Компилятор будет ругаться, если ты что-то пропустишь — это хорошо, потому что многие ошибки отлавливаются ещё до запуска программы.

Типичные ошибки и подводные камни

Ошибка 1: Забыл вызвать super.init()

class Родитель {
    var имя: String
    init(имя: String) {
        self.имя = имя
    }
}

class Ребёнок: Родитель {
    var возраст: Int
    init(возраст: Int) {
        self.возраст = возраст
        // Ошибка! Не вызван super.init()
    }
}

Решение: Всегда вызывай super.init() после инициализации всех свойств дочернего класса.

Ошибка 2: Неправильный порядок инициализации

class Ребёнок: Родитель {
    var возраст: Int
    init(возраст: Int) {
        super.init(имя: "Неизвестно")  // Ошибка! Сначала свои свойства
        self.возраст = возраст
    }
}

Правило: Сначала инициализируем все свои свойства, потом вызываем super.init().

Ошибка 3: Забыл указать override

class Кот: Животное {
    func звук() -> String {  // Ошибка! Нужно override
        return "Мяу"
    }
}

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

Ошибка 4: Слишком глубокая иерархия

Не делай цепочки наследования длиннее 3-4 уровней. Это усложняет понимание кода. Вместо этого используй композицию (включение одного класса в другой) или протоколы.

Ошибка 5: Наследование ради наследования

Не наследуй, если между классами нет отношения «является» (is-a). Класс «Утка» не должен наследовать от класса «Вертолёт», даже если оба умеют летать. Используй протоколы для общих способностей.

Лучшие практики и советы профессионалов

1. Принцип подстановки Барбары Лисков (LSP)

Дочерний класс должен полностью заменять родительский без изменения логики программы. Если у тебя есть функция, которая принимает Животное, она должна работать и с Собакой, и с Кошкой.

Плохо: Класс «Пингвин» наследует от «Птица», но переопределяет метод «летать» так, что он выбрасывает ошибку. Это нарушает LSP.

2. Предпочитай композицию наследованию

Вместо того чтобы создавать глубокую иерархию, часто лучше включить один объект в другой. Например, вместо «Автомобиль наследует от Двигатель», лучше сделать «Автомобиль содержит Двигатель».

// Композиция (лучше)
class Двигатель {
    func запустить() { print("Двигатель работает") }
}

class Автомобиль {
    let двигатель = Двигатель()
    func поехать() {
        двигатель.запустить()
        print("Поехали!")
    }
}

3. Используй final для методов, которые не должны переопределяться

Это делает код безопаснее и иногда ускоряет работу программы (компилятор может оптимизировать вызовы).

4. Документируй, какие методы можно переопределять

В комментариях к классу пиши, какие методы предназначены для переопределения, а какие — нет. Это поможет другим разработчикам (и тебе в будущем).

5. Не бойся протоколов

В Swift протоколы часто лучше наследования. Они позволяют группировать поведение без создания жёсткой иерархии.

// Протокол — это контракт
protocol Летающий {
    func летать()
}

// Класс может подписаться на протокол, не наследуя ничего
class Самолёт: Летающий {
    func летать() {
        print("Самолёт летит")
    }
}

class Птица: Летающий {
    func летать() {
        print("Птица летит")
    }
}

Вопросы для самопроверки

Что такое наследование в ООП?
Ответ: Механизм, позволяющий создать новый класс на основе существующего, наследуя его свойства и методы.
Какое ключевое слово используется для переопределения метода в Swift?
Ответ: override.
Может ли класс в Swift наследовать от двух классов одновременно?
Ответ: Нет, в Swift только одиночное наследование.
Что произойдёт, если не вызвать super.init() в дочернем классе?
Ответ: Компилятор выдаст ошибку. Вызов родительского инициализатора обязателен.
Как запретить наследование от класса?
Ответ: Поставить ключевое слово final перед class.
В чём разница между наследованием и композицией?
Ответ: Наследование — это отношение «является» (is-a). Композиция — «содержит» (has-a).
Что такое полиморфизм?
Ответ: Способность объектов разных классов отвечать на одни и те же вызовы по-своему.
Можно ли переопределить хранимое свойство в Swift?
Ответ: Нет, но можно добавить к нему наблюдатели (willSet/didSet).
Что такое принцип подстановки Барбары Лисков?
Ответ: Дочерний класс должен быть взаимозаменяем с родительским без нарушения логики программы.
Как вызвать метод родителя из дочернего класса?
Ответ: Использовать ключевое слово super: super.имяМетода().

Итог и что изучить дальше

Мы разобрали одну из трёх главных концепций объектно-ориентированного программирования — наследование. Ты узнал:

Как создавать иерархии классов
Как переопределять методы и свойства
Как работает инициализация в цепочке наследования
Как избегать типичных ошибок

Наследование — мощный инструмент, но, как и любой инструмент, им нужно пользоваться с умом. Не пытайся всё организовать в виде иерархии классов. Иногда лучше использовать композицию или протоколы.

Что изучать дальше?

Полиморфизм — как одна и та же функция работает с разными типами объектов.
Инкапсуляция — как скрывать внутреннее устройство класса и защищать данные.
Протоколы в Swift — более гибкая альтернатива наследованию для описания поведения.
Абстрактные классы — классы, которые нельзя создать напрямую, только наследовать от них.
Паттерны проектирования — готовые решения типовых задач (например, «Фабрика», «Стратегия», «Декоратор»).

Золотое правило: Наследование — это отношение «является». Если ты сомневаешься, является ли класс А классом Б, лучше используй композицию или протоколы. Код скажет тебе спасибо.

← Anterior POO: Classes e Objetos em Swift: Um Guia Detalhado Próximo → POO: Encapsulamento e Polimorfismo em Swift: Um Gu