Полиморфизм против наследования: разница между полиморфизмом и наследованием [2022]

Полиморфизм и наследование — очень фундаментальные концепции объектно-ориентированного программирования. Добавление объектов в современные языки программирования значительно изменило то, как мы используем язык, и то, что мы можем с ним делать. В двух словах, объектно-ориентированное программирование — это набор методов, которые позволяют программисту использовать классы и, следовательно, создавать объекты на основе этих классов.

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

Возвращаясь к нашей теме полиморфизма, наследования и права летучей мыши, мы видим явную разницу между этими двумя понятиями. Наследование — это концепция, позволяющая повторно использовать код в той же или другой программе. Мы даже можем изменить поведение кода, оставив то, что нам нравится, и отбросив то, что бесполезно для задач, которые мы пытаемся выполнить. Наследование экономит много времени при разработке почти всего, что мы видим сегодня на наших цифровых дисплеях.

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

Получите диплом инженера -программиста в лучших университетах мира. Участвуйте в программах Executive PG, Advanced Certificate Programs или Master Programs, чтобы ускорить свою карьеру.

Наследование

Было бы преступлением в парадигме программирования не считать наследование крайне важной концепцией ООП. К важности наследования никогда нельзя относиться легкомысленно, поскольку целью наследования является «повторное использование». Что делает наследование, как следует из названия, так это то, что оно позволяет расширить код, написанный в классе, в другой класс. Итак, в наследовании существует базовый класс; класс, в котором написан код, должен использоваться повторно.

Следующий класс, который мы создадим, должен быть унаследован от этого базового класса, чтобы использовать все функции и переменные, связанные с базовым классом. Всякий раз, когда класс принимает свойства другого класса (или наследует от другого класса), все члены, присутствующие в базовом классе, становятся членами этого нового производного класса.

Пример кода, приведенный ниже, покажет вам, как выглядит общая форма наследования. Здесь следует отметить одну ключевую вещь: точный синтаксис, который вам придется написать, чтобы включить наследование вашего кода, будет зависеть исключительно от выбранного вами языка программирования.

1. имя-производного-класса-класса: спецификатор-доступа-имя-базового-класса{
2. // тело производного класса
3. }

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

Опять же, в зависимости от выбранного вами языка, вам может понадобиться или не понадобиться использовать эти спецификаторы доступа. Итак, в мире C++, если вы наследуете, ничего не указывая по умолчанию, оно становится приватным. Однако, если вы наследуете структуру (обозначается ключевым словом struct), спецификатор доступа по умолчанию будет общедоступным, а не частным.

Читайте: Карьерные возможности в языке программирования R

C++ также дает вам множество вариантов выбора при наследовании. Вы найдете некоторые из них в списке ниже:

а. Иерархическое наследование: этот тип наследования следует правилу, что должен быть только один суперкласс, и от этого суперкласса должно быть много производных подклассов. Вы найдете пример ниже:

1. // Базовый класс
2. класс А
3. {
4. публичная пустота funA()
5. {
6. //
7. }
8. }
10. //Производный класс
11. класс Б: А
12. {
13. общественная пустота funB()
14. {
15. //
16. }
17. }
19. //Производный класс
20. класс С: А
21. {
22. общественная пустота funC()
23. {
24. //
25. }
26. }
28. //Производный класс
29. класс Д: С
30. {
31. общественная пустота funD()
32. {
33. //
34. }
35. }
37. //Производный класс
38. класс Е: С
39. {
40. публичная пустота funE()
41. {
42. //
43. }
44. }
46. //Производный класс
47. класс F: В
48. {
49. публичная пустота funF()
50. {
51. //
52. }
53. }
55. //Производный класс
56. класс Г: Б
57. {
58. общественная пустота funG()
59. {
60. //
61. }
62. }

б. Множественное наследование. Если вы выполняете множественное наследование, это будет означать, что у вас есть только один производный подкласс, который наследуется от нескольких суперклассов. Ниже вы найдете простой пример множественного наследования:

1. // Базовый класс
2. класс А
3. {
4. публичная пустота funA()
5. {
6. //
7. }
8. }
10. // Базовый класс
11. класс Б
12. {
13. общественная пустота funB()
14. {
15. //
16. }
17. }
19. //Производный класс
20. класс С: А, В
21. {
22. общественная пустота funC()
23. {
24. //
25. }
26. }

в. Одиночное наследование: это, пожалуй, самая простая форма наследования. Существует только один базовый класс и один производный класс. Ниже вы найдете пример:

1. // Базовый класс
2. класс А
3. {
4. публичная пустота funA()
5. {
6. //СДЕЛАТЬ:
7. }
8. }
10. //Производный класс
11. класс Б: А
12. {
13. общественная пустота funB()
14. {
15. //СДЕЛАТЬ:
16. }
17. }

Полиморфизм

Основное определение слова «полиморфизм» означает наличие множества форм. Это определение очень точно подходит для объяснения полиморфизма в контексте программирования. В этой парадигме полиморфизм принимает значение одной функции, но многих форм. Полиморфизм на самом деле происходит во время компиляции. Полиморфизм во время компиляции возможен только из-за концепции перегрузки, а во время выполнения функция переопределения делает полиморфизм реальностью. Давайте один за другим рассмотрим определение как перегрузки, так и переопределения.

Перегрузка требует, чтобы код, который вы пишете, или функция класса были написаны более одного раза с разными параметрами, но с одним и тем же типом возвращаемого значения. Это означает, что аргументы, которые вы передаете в функцию, могут быть разными, и просто глядя на окончательные значения, которые передаются в функцию во время выполнения, решается, какая форма функции должна быть вызвана. Как правило, мы видим, что конструктор класса является наиболее перегруженной функцией. Вся эта теория станет намного понятнее, и вам будет легче укоренить ее в уме с помощью примера.

1. перегрузка класса {
2. инт а, б;
3. публичный:
4. int перегрузка (int x){ // первый конструктор перегрузки()
5. а=х;
6. вернуть а;
7. }
8. int перегрузка (int x, int y){ //второй конструктор перегрузки()
9. а=х;
10. б=у;
11. вернуть а*б;
12. }
13. };
14. интервал основной () {
15. перегрузка О1;
16. О1. перегрузка (20); // первый вызов конструктора перегрузки()
17. О1. перегрузка (20,40); // второй вызов конструктора перегрузки()

Здесь, в этом примере, мы видим перегрузку в действии. Посмотрите, как вызываются разные конструкторы в зависимости от того, является ли конечное значение объекта в скобках одним целым числом или двумя.

Далее давайте рассмотрим определение переопределения. Вы можете выполнять переопределение только тех конкретных функций, которые унаследованы. Да, наследование является ключевым моментом в обеспечении возможности переопределения функций. Если вы хотите написать функцию, а также переопределить ее, в C++ вам придется использовать ключевое слово virtual перед определением функции, а в производном классе, использующем то же имя для вашей функции, просто удалите ключевое слово virtual. Чтобы закрепить ваше понимание, вот пример:

1. база класса {
2. публичный:
3. virtual void funct (){ // виртуальная функция базового класса
4. cout<<“Это функция базового класса()”;
5. }
6. };
7. производный класс1: общедоступная база{
8. публичный:
9. void funct (){ // виртуальная функция базового класса, переопределенная в производном1 классе
10. cout<<“Это funct() производного1 класса”;
11. }
12. };
13. основной ( )
14. {
15. основание *р, б;
16. производный1 d1;
17. *р=&б;
18. р-> функция (); // вызов базового класса funct().
19. *p=&d1;
20. вернуть 0;
21. }

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

Некоторые существенные различия между полиморфизмом и наследованием:

1. Наследование, по сути, создает класс, а затем другие классы в вашей программе получают свои функции из уже существующего базового класса. Однако полиморфизм — это интерфейс, и поскольку он является интерфейсом, он может принимать различные формы и формы.
2. Наследование — это свойство, относящееся только к классам, тогда как полиморфизм распространяется на любой метод и/или функцию.
3. Наследование позволяет производному классу использовать все функции и переменные, объявленные в базовом классе, без их повторного явного определения. Вот почему мы говорим, что наследование увеличивает возможность повторного использования кода и уменьшает длину кода, который нам пришлось бы писать, если бы наследование отсутствовало. Принимая во внимание, что полиморфизм позволяет одному и тому же имени функции иметь два очень разных кода. Таким образом, в некотором смысле, вместо того, чтобы уменьшать длину кода, который нам пришлось бы писать, полиморфизм расширяет его еще больше.
4. Есть много форм, которые может принимать наследование; вы можете быть очень изобретательны с наследованием. Однако полиморфизм может быть достигнут только двумя способами, т. е. перегрузкой и переопределением. Вы все еще можете сойти с ума при использовании полиморфизма, но вы ограничены только двумя способами его реализации в вашем коде.

Обязательно к прочтению: обязательно к прочтению 47 вопросов и ответов из интервью OOPS для новичков и опытных

Полиморфизм против наследования: табличная дифференциация

В таблице ниже вы найдете четкую разницу между полиморфизмом и наследованием:

Проверьте: Что такое приведение типов в Java | Понимание приведения типов для начинающих

Заключение

Можно с уверенностью сказать, что и полиморфизм, и наследование являются важными понятиями для воплощения любой программы в жизнь. Они оба являются основой, на которой была заложена идея объектно-ориентированного программирования. Есть много различий между полиморфизмом и наследованием, потому что они служат двум очень разным целям.

Полиморфизм позволяет программисту написать несколько определений функции. В то же время наследование позволяет пользователю повторно использовать уже написанный код. Чтобы полностью понять и оценить эти две концепции, рекомендуется дополнительно прочитать обе темы.

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

Если вам интересно узнать больше о разработке программного обеспечения с полным стеком, ознакомьтесь с дипломом PG upGrad & IIIT-B по разработке программного обеспечения с полным стеком, который предназначен для работающих профессионалов и предлагает более 500 часов интенсивного обучения, более 9 проектов и задания, статус выпускника IIIT-B, практические практические проекты и помощь в трудоустройстве в ведущих фирмах.

Планируйте свою карьеру в области разработки программного обеспечения прямо сейчас.

Подать заявку на получение связанной с работой сертификации PG в области разработки программного обеспечения от upGrad