Является ли наследование причиной, что между объектами может быть получено полиморфное поведение?

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

Нет, наследование — это не необходимое условие для полиморфизма, хотя в классическом ООП они часто используются вместе. Полиморфизм можно достичь несколькими способами, не полагаясь только на наследование.

Что такое полиморфизм

Полиморфизм — это способность объектов разных типов отвечать на один и тот же вызов метода, но с разным поведением. Буквально: «много форм».

Типы полиморфизма в Python

1. Утиный полиморфизм (Duck Typing)

# Не нужно наследование, только совпадение интерфейса
class Dog:
    def make_sound(self):
        return "Гав!"

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

class Bird:
    def make_sound(self):
        return "Чирик!"

# Функция работает с любым объектом, имеющим метод make_sound
def animal_concert(animals):
    for animal in animals:
        print(animal.make_sound())

# Нет наследования, но есть полиморфизм!
animals = [Dog(), Cat(), Bird()]
animal_concert(animals)  # Гав! Мяу! Чирик!

# Python не проверяет тип, только наличие метода

Это работает в Python благодаря динамической типизации — это основной способ полиморфизма в Python, и наследование вообще не требуется.

2. Полиморфизм через наследование

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Гав!"

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

# Наследование от одного родителя гарантирует интерфейс
# Но это не единственный способ получить полиморфизм

3. Структурный подтип (Protocol в Python 3.8+)

from typing import Protocol

class Drawable(Protocol):
    def draw(self) -> str:
        ...

class Circle:
    def draw(self) -> str:
        return "Рисую круг"

class Square:
    def draw(self) -> str:
        return "Рисую квадрат"

# Нет явного наследования, но есть полиморфизм
def render(obj: Drawable):
    print(obj.draw())

render(Circle())  # Работает
render(Square())  # Работает

# Protocol проверяет совпадение интерфейса статически

Наследование — не причина полиморфизма

# Часто ошибочно думают: наследование => полиморфизм
# На самом деле: совпадающий интерфейс => полиморфизм

# Пример: две строки наследуют от str, но это не создаёт полиморфизм
class MyStr(str):
    pass

# Пример: две функции не наследуют друг от друга, но полиморфны
def process_dog(dog):
    return dog.make_sound()

def process_cat(cat):
    return cat.make_sound()

# Полиморфизм через обобщённую функцию
def process_animal(animal):  # animal может быть Dog или Cat
    return animal.make_sound()

Главное: наследование != полиморфизм

# Случай 1: наследование БЕЗ полиморфизма
class Parent:
    def method_a(self):
        return "A"

class Child(Parent):
    def method_b(self):
        return "B"

obj = Child()
obj.method_a()  # Работает, но это не полиморфизм

# Случай 2: полиморфизм БЕЗ наследования
class ClassA:
    def execute(self):
        return "A"

class ClassB:
    def execute(self):
        return "B"

def run(obj):
    return obj.execute()  # Полиморфизм!

run(ClassA())  # "A"
run(ClassB())  # "B"

# Нет наследования между ClassA и ClassB, но есть полиморфизм

Полиморфизм операторов (без наследования)

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    def __str__(self):
        return f"({self.x}, {self.y})"

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
    
    def __add__(self, other):
        return Complex(self.real + other.real, self.imag + other.imag)

# Оператор + работает по-разному
v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)  # (4, 6)

c1 = Complex(1, 2)
c2 = Complex(3, 4)
print((c1 + c2).real)  # 4

# Полиморфизм операторов, нет наследования

Когда наследование полезно для полиморфизма

# Наследование ГАРАНТИРУЕТ совпадающий интерфейс
from abc import ABC, abstractmethod

class Logger(ABC):
    @abstractmethod
    def log(self, message):
        pass

class FileLogger(Logger):
    def log(self, message):
        print(f"File: {message}")

class ConsoleLogger(Logger):
    def log(self, message):
        print(f"Console: {message}")

# Преимущество: мы знаем, что все Logger имеют метод log
def app_logger(logger: Logger, msg: str):
    logger.log(msg)  # Гарантировано работает

Вывод

1. Полиморфизм не требует наследования — это ключевой момент
2. Python использует утиную типизацию — интерфейс важнее типа
3. Наследование помогает формализовать полиморфизм, но это не обязательно
4. Протоколы и структурная типизация — современный способ гарантировать полиморфизм без наследования
5. Причина полиморфизма — совпадающий интерфейс методов, а не иерархия классов

Полиморфизм — это про то, как объекты реагируют на вызовы, а не про то, как они наследуют. Наследование просто один из инструментов для создания полиморфного кода.