📦 Репозиторий занятия 72

### **Множественное наследование**

**Множественное наследование** — это возможность класса наследоваться сразу от нескольких базовых классов.  

В семействе языков высокого уровня множественное наследование поддерживают **далеко** не все.   
Кроме `Python`, множественное наследование ещё есть в `C++`, `Ruby`.  
А вот `Java`, `C#`, `Swift`, `Go`, `JavaScript` — нет.

В Python это реализуется следующим образом:


```python
class Person:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f"Hello, my name is {self.name}")

    def info(self):
        print(f"Метод из класса Person")


class Worker:
    def work(self):
        print("I am working!")

    def info(self):
        print(f"Метод из класса Worker")


class Student:
    def study(self):
        print("I am studying!")

    def info(self):
        print(f"Метод из класса Student")


class WorkingStudent(Person, Worker, Student):
    def __init__(self, name):
        super().__init__(name)  # Инициализация Person


ws = WorkingStudent("Alice")
ws.greet()      # метод из Person
ws.work()       # метод из Worker
ws.study()      # метод из Student
ws.info()       # Из какого класса будет унаследован этот метод?
```

Как видим, каждый из родительских классов имеет:

1. Свой собственный уникальный метод (`greet`, `work` и `study`)
2. Метод `info`: общее название, разное содержание

---

## Особенности множественного наследования

…

### Понятие Mixin

Это класс, который 
* передаёт наследникам свою функциональность,
* но не способен создавать свои собственные объекты.

***"Воспитывать чужих детей может, а иметь своих собственных — нет."***

Главная идея:

* Mixin добавляет **одну или несколько функций** к классу.
* Обычно **не хранит состояние** (атрибуты объекта), а лишь предоставляет методы.
* Используется вместе с **множественным наследованием**.

---

#### Пример

Создание текстового редактора.  
Условие: для разных клиентов нужен разный набор функционала

```python
# Основной класс
class Document:
    def __init__(self, name, content):
        self.name = name
        self.content = content


class EditDocument(Document):
    def edit(self):
        self.content += "\nТекст был отредактирован"
        return self


# ===== Возможные варианты дополнительного функционала =====
# Mixin для отправки документа по email
class EmailMixin:
    def send_email(self, recipient):
        print(f"Sending document '{self.name}' to {recipient} via email...")


# Mixin для сохранения документа на диск
class SaveMixin:
    def save(self):
        print(f"Saving document '{self.name}' to disk...")


# Mixin для печати документа
class PrintMixin:
    def print_doc(self):
        print('-' * 50,)
        print(f"Printing document '{self.name}' \n{self.content}")
        print('-' * 50, '\n')


# ======= Создаём полноценный текстовой редактор =========

class TextEditor(EditDocument, EmailMixin, SaveMixin, PrintMixin):
    """Текстовый редактор с возможностью редактирования, сохранения, печати и отправки по email"""
…

### Что такое проблема ромба (diamond problem)?

**Diamond problem** возникает при **множественном наследовании**, когда структура классов выглядит так:

```
      A
     / \
    B   C
     \ /
      D
```
* Во всех родительских классах есть метод `show()`, но в каждом классе он имеет разный функционал
* Класс `D` наследует от `B` и `C`.
* `B` и `C` наследуют от одного класса `A`.
* Вопрос: чей именно метод `show()` унаследует дочерний класс `D`?


---

#### Пример

```python
class A:
    def show(self):
        print("A")

class B(A):
    def show(self):
        print("B")

class C(A):
    def show(self):
        print("C")

class D(B, C):
    pass

d = D()
d.show()
print(D.__mro__)
```

### Объяснение

* `D` наследует от `B` и `C`.
* Метод `show` есть у `B`, `C` и `A`.
* Python использует **C3-линеаризацию**, чтобы определить **MRO (Method Resolution Order)**.

**Вывод программы:**

```
B
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
```

### Как Python решает `diamond problem`? (Алгоритм C3 linearization)

* Сначала поиск идёт у родителей (`B` и `C`)
* Как только метод находится, его дальнейший поиск прекращается
* Порядок поиска у родителей идёт слева-направо 
…

## Наследование, Композиция, Агрегация

В ООП есть несколько способов связывать объекты между собой: 
* **наследование**, 
* **композиция**
* и **агрегация**.

---

### 1. Наследование (Inheritance)

Наследование используется, когда один класс **расширяет или модифицирует поведение другого класса**.  
Оно описывает отношение `is-a` (объект `Dog` является расширенной версией объекта `Animal`):

* `Dog` наследует свойства `Animal`
* `Dog` наследует поведение `Animal`
* `Dog` может дополнять или изменять это поведение
* `Dog` всё ещё считается `Animal`, но более конкретным


#### Пример:

```python
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return "Some sound"

# Наследуемся от Animal
class Dog(Animal):
    def speak(self):
        return "Woof!"

dog = Dog("Buddy")
print(dog.name)   # Buddy
print(dog.speak())  # Woof!
```

* `Dog` **является** `Animal` → отношение `is-a`.
* Подкласс наследует методы и атрибуты родителя, но может их переопределять.

---

## 2. Композиция (Composition)

Композиция описывает отношение "**состоит из**" (`has-a`) и подразумевает,  
что один объект **содержит другой как часть себя**.  
При этом компонент обычно создаётся внутри объекта и полностью принадлежит ему:

* `Car` **содержит в себе** объект `Engine`
* `Car` **использует** `Engine` для реализации части своего поведения (например, `start()`)
* `Engine` **создаётся внутри** `Car` и **не существует отдельно** от него
* `Engine` **не является** видом `Car`, но является **частью** `Car`
* Жизненный цикл `Engine` **полностью зависит от** `Car`: 
  * когда `Car` уничтожается, `Engine` тоже исчезает
* Отношение `Car`–`Engine` — это **целое–часть**

### Пример:
…

## Вложенные классы

**Вложенный класс** — это класс, определённый *внутри другого класса*.

Он НЕ существует самостоятельно, а только как **атрибут** внешнего класса.

```python
class Human:
    class Heart:
        def beat(self):
            return "Тук-тук"

h = Human()
heart = Human.Heart()
print(heart.beat())  # Тук-тук


try:
    heart2 = Heart()
except Exception as e:
    print(f'{e.__class__.__name__}: {e}')
    # NameError: name 'Heart' is not defined
```

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

Вложенный класс — это разновидность композиции.  
С той только разницей, в отличие от обычной композиции,  
вложенный класс в принципе невозможно создать без внешнего.


### Схема трёх вариантов отношения объектов:

```
        НАСЛЕДОВАНИЕ               КОМПОЗИЦИЯ                            АГРЕГАЦИЯ 
          (is-a)               (has-a, часть целого)            (has-a, независимый компонент)
             ^          
             |
     +----------------+         +-----------------+         +-----------------+       +--------------+
     |      Dog       |         |       Car       |         |                 |       |              |
     +----------------+         |  +-----------+  |         |    Employee     |-------|  Department  |
             |                  |  |           |  |         |                 |       |              |
             v                  |  |  Engine   |  |         +-----------------+       +--------------+
     +----------------+         |  |           |  |         
     |     Animal     |         |  +-----------+  |
     +----------------+         +-----------------+ 

                                     КОМПОЗИЦИЯ
                                          |
                                          v
                                +-----------------+
                                |     Car         |
                                |  class Engine   |  ← вложенный класс (часть Car)
                                +-----------------+

```

Внешний класс используют для логической группировки вспомогательных структур,   
которые не имеют смысла вне контекста внешнего класса.

…

## Вложенные классы: ключевая идея

Вложенные классы **не создают автоматически связи** 
* ни между классами, 
* ни между экземплярами.  

Они ТОЛЬКО создают пространство имён: `i = Outer.Inner()`

Все связи между объектами могут быть созданы ТОЛЬКО ЯВНО, так как:
* `Outer` не получает объект `Inner` по умолчанию;
* `Inner` не получает доступ к экземплярам `Outer` по умолчанию.

Предел "автоматического возможного":
* Доступ к атрибуту самого класса `Outer` (не не его экземпляров!) из методов класса `Inner`.

```python
class Outer:
    class_attr = 100   # атрибут КЛАССА

    class Inner:
        def show_outer_class_attr(self):
            print(Outer.class_attr)   # ✔ доступ есть

i = Outer.Inner()
i.show_outer_class_attr()
```

---

### Пример 1. Нет связи ни между классами, ни между объектами*

```python
class Human:
    class Heart:
        def beat(self):
            return "Тук-тук"

# Создаём отдельные объекты
some_human = Human()
heart = Human.Heart()

# Попытка узнать "чьё это сердце" со стороны человека (some_human):
try:
    print(some_human.heart.beat())
except Exception as e:
    print(f"{e.__class__.__name__}: {e}")  
    # AttributeError: 'Human' object has no attribute 'heart'

# Попытка узнать "что это за человек" со стороны сердца (heart):
try:
    print(heart.Human())
except Exception as e:
    print(f"{e.__class__.__name__}: {e}")
    # AttributeError: 'Heart' object has no attribute 'Human
```

**Вывод:**

* `Heart` существует как класс внутри `Human`.
* **Нет связи между объектом `alice` и объектом `heart`**, если мы её явно не создаём.
…