Что такое связь обобщение?

Связь обобщение (Generalization)

Обобщение (Generalization) — это связь между классом и его родительским классом в объектно-ориентированном программировании. Она выражает отношение "является" (is-a) и реализуется через наследование. Это одна из трёх основных связей в UML диаграммах.

Суть обобщения

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

# РОДИТЕЛЬСКИЙ КЛАСС (более общий)
class Animal:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age
    
    def make_sound(self) -> str:
        return "Некий звук"
    
    def eat(self):
        print(f"{self.name} ест")

# ПОТОМКИ (более специализированные)
class Dog(Animal):
    def make_sound(self) -> str:
        return "Гав!"
    
    def fetch(self):
        return f"{self.name} принёс мяч"

class Cat(Animal):
    def make_sound(self) -> str:
        return "Мяу!"
    
    def scratch(self):
        return f"{self.name} царапает мебель"

# ИСПОЛЬЗОВАНИЕ
dog = Dog("Рекс", 5)
cat = Cat("Мурзик", 3)

print(dog.make_sound())  # Гав!
print(cat.make_sound())  # Мяу!
print(dog.fetch())       # Рекс принёс мяч
print(cat.eat())         # Мурзик ест (унаследовано)

Уровни обобщения

Обобщение может быть многоуровневым — создаётся иерархия классов:

# Уровень 1: самый общий класс
class Vehicle:
    def __init__(self, brand: str):
        self.brand = brand
    
    def start_engine(self):
        print(f"{self.brand}: Двигатель запущен")

# Уровень 2: более специализированные
class Car(Vehicle):
    def open_trunk(self):
        print("Багажник открыт")

class Truck(Vehicle):
    def open_cargo(self):
        print("Кузов открыт")

# Уровень 3: самые специализированные
class SportsCar(Car):
    def turbo_boost(self):
        print("Турбо включён!")

# Иерархия
ferrari = SportsCar("Ferrari")
ferrari.start_engine()   # От Vehicle
ferrari.open_trunk()     # От Car
ferrari.turbo_boost()    # От SportsCar

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

Класс может наследоваться от нескольких родителей (хотя это часто создаёт сложность):

class Swimmer:
    def swim(self):
        return "Плывёт"

class Flyer:
    def fly(self):
        return "Летит"

# Утка может и плавать, и летать
class Duck(Swimmer, Flyer):
    def quack(self):
        return "Кря-кря!"

duck = Duck()
print(duck.swim())   # Плывёт
print(duck.fly())    # Летит
print(duck.quack())  # Кря-кря!

Методы для управления наследованием

super() — вызов метода родителя:

class Animal:
    def __init__(self, name: str):
        self.name = name
    
    def describe(self):
        return f"Это {self.name}"

class Dog(Animal):
    def __init__(self, name: str, breed: str):
        super().__init__(name)  # Вызываем инициализацию родителя
        self.breed = breed
    
    def describe(self):
        parent_desc = super().describe()  # Вызываем метод родителя
        return f"{parent_desc}, порода: {self.breed}"

dog = Dog("Рекс", "Лабрадор")
print(dog.describe())  # Это Рекс, порода: Лабрадор

isinstance() и issubclass() — проверка наследования:

dog = Dog("Рекс", "Лабрадор")

print(isinstance(dog, Dog))     # True
print(isinstance(dog, Animal))  # True (потому что Dog наследуется от Animal)
print(isinstance(dog, Cat))     # False

print(issubclass(Dog, Animal))  # True
print(issubclass(Animal, Dog))  # False

Абстрактные классы и интерфейсы

Обобщение часто используется с абстрактными классами для определения контракта:

from abc import ABC, abstractmethod

# Абстрактный класс (контракт для потомков)
class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        pass
    
    @abstractmethod
    def perimeter(self) -> float:
        pass

# Конкретные реализации
class Circle(Shape):
    def __init__(self, radius: float):
        self.radius = radius
    
    def area(self) -> float:
        return 3.14 * self.radius ** 2
    
    def perimeter(self) -> float:
        return 2 * 3.14 * self.radius

class Square(Shape):
    def __init__(self, side: float):
        self.side = side
    
    def area(self) -> float:
        return self.side ** 2
    
    def perimeter(self) -> float:
        return 4 * self.side

# ИСПОЛЬЗОВАНИЕ
circle = Circle(5)
square = Square(4)

print(circle.area())  # 78.5
print(square.area())  # 16

Полиморфизм через обобщение

Одна из главных преимуществ обобщения — возможность обращаться с объектами через интерфейс родителя:

def print_description(animal: Animal):
    print(f"{animal.name}: {animal.make_sound()}")

dog = Dog("Рекс", "Лабрадор")
cat = Cat("Мурзик", "Персиянская")

print_description(dog)   # Рекс: Гав!
print_description(cat)   # Мурзик: Мяу!

Отличие от других связей

Обобщение — это самая строгая связь, выражающая подтип-надтип отношение.