23_inheritance_tutorial.py

# ========== НАСЛЕДОВАНИЕ ==========

# 1. Базовое наследование
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} издает звук")

# Dog наследует Animal
class Dog(Animal):
    def bark(self):
        print(f"{self.name} лает: Гав-гав!")

dog = Dog("Бобик")
dog.speak()  # Унаследованный метод
dog.bark()   # Собственный метод

# 2. Переопределение методов (override)
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} издает звук")

class Cat(Animal):
    # Переопределяем метод speak
    def speak(self):
        print(f"{self.name} мяукает: Мяу!")

class Dog(Animal):
    def speak(self):
        print(f"{self.name} лает: Гав-гав!")

cat = Cat("Мурка")
dog = Dog("Бобик")

cat.speak()  # Мяукает
dog.speak()  # Лает

# 3. Вызов метода родительского класса через super()
class Animal:
    def __init__(self, name):
        self.name = name
        print(f"Создано животное: {name}")

class Dog(Animal):
    def __init__(self, name, breed):
        # Вызываем конструктор родительского класса
        super().__init__(name)
        self.breed = breed
        print(f"Порода: {breed}")

dog = Dog("Бобик", "Овчарка")
print(f"{dog.name} - {dog.breed}")

# 4. Расширение метода родителя
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"Меня зовут {self.name}, мне {self.age} лет")

class Employee(Person):
    def __init__(self, name, age, job_title):
        super().__init__(name, age)
        self.job_title = job_title

    def introduce(self):
        # Сначала вызываем метод родителя
        super().introduce()
        # Затем добавляем свою логику
        print(f"Я работаю: {self.job_title}")

employee = Employee("Pavel", 25, "Developer")
employee.introduce()

# 5. Множественное наследование
class Flyable:
    def fly(self):
        print("Я могу летать")

class Swimmable:
    def swim(self):
        print("Я могу плавать")

class Duck(Flyable, Swimmable):
    def quack(self):
        print("Кря-кря!")

duck = Duck()
duck.fly()
duck.swim()
duck.quack()

# 6. Проблема ромба и MRO (Method Resolution Order)
class A:
    def method(self):
        print("Метод из A")

class B(A):
    def method(self):
        print("Метод из B")

class C(A):
    def method(self):
        print("Метод из C")

class D(B, C):
    pass

d = D()
d.method()  # Какой метод вызовется?

# Проверяем порядок разрешения методов (MRO)
print(f"MRO: {D.__mro__}")
# MRO: D -> B -> C -> A -> object

# 7. Проверка типов и наследования
class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()

# isinstance - проверяет, является ли объект экземпляром класса
print(f"isinstance(dog, Dog): {isinstance(dog, Dog)}")        # True
print(f"isinstance(dog, Animal): {isinstance(dog, Animal)}")  # True (наследование!)
print(f"isinstance(dog, object): {isinstance(dog, object)}")  # True (все наследуют object)

# issubclass - проверяет, является ли класс подклассом другого класса
print(f"issubclass(Dog, Animal): {issubclass(Dog, Animal)}")  # True
print(f"issubclass(Dog, Dog): {issubclass(Dog, Dog)}")        # True
print(f"issubclass(Animal, Dog): {issubclass(Animal, Dog)}")  # False

# 8. Абстрактные базовые классы (ABC)
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass  # Абстрактный метод (должен быть реализован в подклассах)

    @abstractmethod
    def perimeter(self):
        pass

# Нельзя создать экземпляр абстрактного класса
# shape = Shape()  # TypeError

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

rect = Rectangle(5, 3)
print(f"Площадь: {rect.area()}")
print(f"Периметр: {rect.perimeter()}")

# 9. Полиморфизм
class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Гав-гав!"

class Cat(Animal):
    def speak(self):
        return "Мяу!"

class Cow(Animal):
    def speak(self):
        return "Му-у!"

# Функция работает с любым Animal
def animal_sound(animal):
    print(animal.speak())

animals = [Dog(), Cat(), Cow()]
for animal in animals:
    animal_sound(animal)

# 10. Композиция vs Наследование
# Наследование: "является" (is-a)
class Vehicle:
    pass

class Car(Vehicle):  # Машина ЯВЛЯЕТСЯ транспортом
    pass

# Композиция: "имеет" (has-a)
class Engine:
    def start(self):
        print("Двигатель запущен")

class Car:
    def __init__(self):
        self.engine = Engine()  # Машина ИМЕЕТ двигатель

    def start(self):
        self.engine.start()

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

# 11. Миксины (mixin)
class LoggerMixin:
    def log(self, message):
        print(f"[LOG] {message}")

class TimestampMixin:
    def get_timestamp(self):
        from datetime import datetime
        return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

class User(LoggerMixin, TimestampMixin):
    def __init__(self, name):
        self.name = name

    def login(self):
        self.log(f"{self.name} вошел в систему в {self.get_timestamp()}")

user = User("Pavel")
user.login()

# 12. Переопределение __init__ с параметрами по умолчанию
class Animal:
    def __init__(self, name, age=0):
        self.name = name
        self.age = age

class Dog(Animal):
    def __init__(self, name, age=0, breed="Неизвестная"):
        super().__init__(name, age)
        self.breed = breed

dog1 = Dog("Бобик")
dog2 = Dog("Шарик", 5, "Овчарка")
print(f"{dog1.name}: {dog1.age} лет, {dog1.breed}")
print(f"{dog2.name}: {dog2.age} лет, {dog2.breed}")

# 13. Практический пример: иерархия сотрудников
class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def get_info(self):
        return f"{self.name}: ${self.salary}"

class Manager(Employee):
    def __init__(self, name, salary, team_size):
        super().__init__(name, salary)
        self.team_size = team_size

    def get_info(self):
        return f"{super().get_info()}, Команда: {self.team_size} человек"

class Developer(Employee):
    def __init__(self, name, salary, language):
        super().__init__(name, salary)
        self.language = language

    def get_info(self):
        return f"{super().get_info()}, Язык: {self.language}"

employees = [
    Manager("Ivan", 5000, 10),
    Developer("Pavel", 4000, "Python"),
    Developer("Maria", 4500, "JavaScript")
]

for employee in employees:
    print(employee.get_info())

# 14. Цепочка наследования
class A:
    def method(self):
        print("A.method")

class B(A):
    def method(self):
        print("B.method")
        super().method()  # Вызываем метод родителя

class C(B):
    def method(self):
        print("C.method")
        super().method()  # Вызываем метод родителя

c = C()
c.method()
# Выведет:
# C.method
# B.method
# A.method