Полиморфизм и наследование не зависят друг от друга

// C++ lack of polymorphism with no inheritance

class Jalopy {
     public boolean start() {
          …
     }
}

// Jalopy does not inherit from Car, the following is illegal

Car cars[] = { new VolkswagenBeetle(),new Jalopy() };

for( I = 0; I < 2; i++)
     Cars[i].start();

Во время компиляции это приведет к ошибке, потому что тип Jalopy не является производным от Car . Хотя оба они реализуют метод start () с одинаковой сигнатурой, компилятор остановит меня из-за статической ошибки типа.

Строгая проверка типов, введенная во время компиляции, означает, что весь полиморфизм должен проходить через наследование. Это приводит к проблемам с глубокой иерархией наследования и множественным наследованием, когда возникают всевозможные проблемы с неожиданными побочными эффектами. Даже умеренно сложные программы становятся очень сложными для понимания и поддержки на C ++ .

Историческая справка: C ++ доминировал до середины 1990-х годов просто потому, что это было объектно-ориентированное решение, которое НЕ было интерпретировано. Это означало, что на медленных процессорах того времени он имел приличную производительность.   Мы использовали C ++, потому что мы не могли получить сопоставимую производительность ни с одним из интерпретируемых объектно-ориентированных языков того времени, т.е. Smalltalk.

Ослабление связи

Негативные последствия тесной связи между наследованием и полиморфизмом приводят к тому, что Java и C # вводят концепцию интерфейса, которая разделяет идеи наследования и полиморфизма, но при этом строго контролирует тип во время компиляции.

Во-первых, можно реализовать приведенный выше пример C ++ точно с использованием наследования, как показано в C # ниже:

// C# polymorphism using inheritance

class Car {
     public virtual boolean start();  // declare signature
}

class VolkswagenBeetle : Car {
     public override boolean start() {
          // implementation code
     }
}

class SportsCar : Car {
     public override boolean start() {
          // implementation code
     }
}

// Invocation of polymorphism
Car cars[] = { new VolkswagenBeetle(), new SportsCar() };

for( I = 0; I < 2; i++)
     Cars[i].start();

Кроме того, используя концепцию интерфейса, мы можем написать классы на Java следующим образом:

// Java polymorphism using interface

interface Car {
     public boolean start();  
}

class VolkswagenBeetle implements Car {
     public boolean start() {
          // implementation code
     }
}

class SportsCar implements Car {
     public boolean start() {
          // implementation code
     }
}

Используя
интерфейс , реализации VolkswagenBeetle и SportsCar могут быть полностью независимыми, если они продолжают удовлетворять интерфейсу Car. Таким образом, теперь мы можем сделать наш класс Jalopy полиморфным с двумя другими классами просто:

class Jalopy implements Car {
    …
}

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

Есть языки, где у вас есть полиморфизм без использования наследования .   Некоторыми примерами являются JavaScript, Python, Ruby, VB.NET и Small Talk.

На каждом из этих языков можно написать car.start (), ничего не зная об объекте car и его методе.

# Python polymorphism



class VolkswagenBeetle(Car):
     def start(): # Code to start Volkswagen

class SportsCar(Car):
     def start(): # Code to start SportsCar

# Invocation of polymorphism
cars = [ VolkswagenBeetle(), SportsCar() ]
for car in cars:
     car.start()

Возможность получить чистый полиморфизм из этих языков имеет только один тип переменной до времени выполнения: var в JavaScript, def в Python, def в Ruby, dim в VB.NET. Только с одним типом переменной не может быть ошибки типа до времени выполнения.

Историческая справка: только во время введения Java и C # мощность процессора была достаточной для интерпретируемых языков, чтобы обеспечить достаточную производительность во время выполнения.   Переход от полиморфизма и наследования, тесно связанных с более слабой связью, зависел от способности интерпретаторов времени выполнения выполнять практические приложения с достойной производительностью.

Там нет такого понятия, как бесплатный обед

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

Когда проверка типов откладывается до времени выполнения, вы хотите, чтобы объект отвечал: « Я понятия не имею, как запустить () », если вы случайно отправили ему метод start ().

            startCar = getattr(obj, "start", None)
            if callable(startCar):
                startCar ()