что такое динамический полиморфизм и статический
Слово полиморфизм означает наличие многих форм. В парадигме объектно-ориентированного программирования полиморфизм часто выражается как «один интерфейс, несколько функций».
Полиморфизм может быть статическим или динамическим. В статическом полиморфизме ответ на функцию определяется во время компиляции. В динамическом полиморфизме он решается во время выполнения.
Статический полиморфизм
Мы обсудим перегрузку оператора в следующей главе.
Перегрузка функции
Вы можете иметь несколько определений для одного и того же имени функции в той же области. Определение функции должно отличаться друг от друга по типам и / или количеству аргументов в списке аргументов. Вы не можете перегружать объявления функций, которые отличаются только возвращаемым типом.
В следующем примере показано использование функции print () для печати различных типов данных:
Когда приведенный выше код компилируется и выполняется, он производит следующий результат:
Динамический полиморфизм
C # позволяет создавать абстрактные классы, которые используются для обеспечения частичной реализации класса интерфейса. Реализация завершается, когда производный класс наследуется от него. Абстрактные классы содержат абстрактные методы, которые реализуются производным классом. Производные классы имеют более специализированную функциональность.
Вот правила об абстрактных классах:
Следующая программа демонстрирует абстрактный класс:
Когда приведенный выше код компилируется и выполняется, он производит следующий результат:
Когда у вас есть функция, определенная в классе, который вы хотите реализовать в унаследованном классе (-ах), вы используете виртуальные функции. Виртуальные функции могут быть реализованы по-разному в разных унаследованных классах, и вызов этих функций будет решаться во время выполнения. Динамический полиморфизм реализуется абстрактными классами и виртуальными функциями.
Следующая программа демонстрирует это:
Когда приведенный выше код компилируется и выполняется, он производит следующий результат:
Полиморфизм в Java – подробно с примерами
Полиморфизм в Java – это концепция ООП, в которой одно имя может иметь много форм.
Например, у вас есть смартфон для общения. Режим связи, который вы выбираете, может быть любым. Это может быть звонок, текстовое сообщение, графическое сообщение, почта и т. д. Итак, общая цель – общение, но у них другой подход. Это называется полиморфизмом.
Объяснение полиморфизма
У нас есть один родительский класс, «Счет» с функцией пополнения и снятия. Учетная запись имеет 2 дочерних класса.
Операции ввода и вывода одинаковы для Сберегательного и Чекового счетов. Таким образом, унаследованные методы из класса Account будут работать.
Изменение требований к программному обеспечению
В спецификации требований произошли изменения, что так часто встречается в индустрии программного обеспечения. Вы должны добавить функциональность привилегированного банковского счета с помощью овердрафта.
Овердрафт – это средство, с помощью которого вы можете снять сумму, превышающую доступный остаток на вашем счете.
Итак, метод вывода для привилегированных нужд должен быть реализован заново. Но вы не меняете проверенный кусок кода в Сберегательном и Чековом счете. Это преимущество ООП.
Шаг 1) Такой, что при вызове «изъятого» метода для сохранения учетной записи выполняется метод из класса родительской учетной записи.
Шаг 2) Но когда вызывается метод «Снять» для привилегированной учетной записи (средство овердрафта), выполняется метод вывода, определенный в привилегированном классе. Это полиморфизм.
Переопределение метода
Переопределение метода – переопределение метода суперкласса в подклассе.
Правила для переопределения метода
Разница между перегрузкой и переопределением
Перегрузка метода находится в одном классе, где несколько методов имеют одно и то же имя, но разные подписи.
Переопределение метода – это когда один из методов суперкласса переопределяется в подклассе. В этом случае подпись метода остается неизменной.
Что такое динамический полиморфизм?
Динамический полиморфизм – это механизм, с помощью которого можно определить несколько методов с одинаковыми именами и сигнатурами в суперклассе и подклассе. Вызов переопределенного метода разрешается во время выполнения.
Пример динамического полиморфизма
Ссылочная переменная суперкласса может ссылаться на объект подкласса.
Здесь ссылочная переменная “obj” относится к родительскому классу, но объект, на который она указывает, принадлежит к дочернему классу (как показано на диаграмме).
obj.treatPatient() выполнит метод TreatPatient() для подкласса – Surgeon
Если для вызова метода используется ссылка на базовый класс, то вызываемый метод определяется JVM в зависимости от объекта, на который указывает ссылка
Например, хотя obj является ссылкой на Doctor, он вызывает метод Surgeon, так как он указывает на объект Surgeon.
Это определяется во время выполнения и, следовательно, называется динамическим или динамическим полиморфизмом.
super ключевое слово
Что, если метод TreatPatient в классе Surgeon хочет выполнить функциональность, определенную в классе Doctor, а затем выполнить свою собственную специфическую функциональность? В этом случае ключевое слово super может использоваться для доступа к методам родительского класса из дочернего класса. Метод TreatPatient в классе Surgeon может быть записан как:
Ключевое слово super может использоваться для доступа к любому члену данных или методам суперкласса в подклассе.
Шаг 1) Скопируйте следующий код в редактор
Шаг 2) Сохранение, компиляция Запустите код. Соблюдайте вывод.
Шаг 3) Раскомментируйте строки № 6-9. Сохранить, скомпилировать Запустите код. Соблюдайте вывод.
Шаг 4) Раскомментируйте строку # 10. Сохраните и Скомпилируйте код.
Шаг 5) Ошибка =? Это потому, что подкласс не может получить доступ к закрытым членам суперкласса.
Разница между статическим и динамическим полиморфизмом
Ошибки, если таковые имеются, устраняются во время компиляции. Поскольку код не выполняется во время компиляции, отсюда и название static.
В случае, если ссылочная переменная вызывает переопределенный метод, вызываемый метод определяется объектом, на который указывает ваша ссылочная переменная. Это может быть определено только во время выполнения, когда код находится в процессе выполнения, поэтому имя динамическое.
Energy
education
сайт для тех, кто хочет изучать энергетику
Информационные технологии
Visual Studio C#
19. Полиморфизм
Слово полиморфизм означает иметь много форм. В объектно-ориентированном программировании полиморфизмом часто понимается как «один интерфейс, множество функций».
Полиморфизм может быть статическим или динамическим. В статическом полиморфизме выбор определяется во время компиляции. В динамическом полиморфизме выбор определяется во время выполнения.
Статический полиморфизм
Механизм связывания функции с объектом во время компиляции называется ранним связыванием. Он также называется статическое связывание. C# использует два механизма для реализации статического полиморфизма. Это:
Перегрузка метода
Вы можете иметь несколько определений для одного имени метода в одной области видимости. Определенные методы должны отличаться друг от друга по видам и/или количеству аргументов в списке аргументов. Нельзя перегрузить объявление методов, которые отличаются только типом возвращаемого значения.
Ниже приведен пример, в котором те же методы print() используются для печати различных типов данных:
Если приведенный выше код скомпилировать и выполнить, это приведет к следующему результату:
Динамический полиморфизм
C# позволяет создавать абстрактные классы, которые используются для обеспечения частичной реализации интерфейса. Реализация завершается, когда производный класс наследует от него. Абстрактные классы содержат абстрактные методы, которые осуществляются в производном классе. Производные классы имеют более специализированные функциональные возможности.
Обратите внимание на следующие правила об абстрактных классах:
Следующая программа демонстрирует абстрактный класс:
Если приведенный выше код скомпилировать и выполнить, это приведет к следующему результату:
Если у вас есть метод, определенный в классе, который вы хотите реализовать в унаследованном классе, вы используете виртуальный метод. Виртуальные методы могут быть реализованы по-разному в разных унаследованных классах и вызов этих методов будет решаться во время выполнения.
Динамический полиморфизм реализуется абстрактными классами и виртуальными методами.
Следующая программа демонстрирует это:
Если приведенный выше код скомпилировать и выполнить, это приведет к следующему результату:
Администратор сайта: Колосов Михаил
email:
Copyright © 2011-2021. All rights reserved.
CRTP. Static polymorphism. MixIn. Размышления на тему
Введение
Как известно, С++ является мультипарадигмовым языком. На нем можно писать в процедурном стиле, использовать языковые конструкции, обеспечивающие поддержку объектно-ориентированного программирования, шаблоны делают возможным обобщенное программирование, STL и новые возможности языка (lambda, std::function, std::bind) позволяют при желании писать в функциональном стиле в рантайме, а метапрограммирование шаблонов представляет собой функциональное программирование в чистом виде в compile time.
Несмотря на то, что в любой реальной большой программе скорее всего можно встретить смесь всех этих техник, объектно-ориентированная парадигма, реализуемая с помощью концепции классов, открытого интерфейса и закрытой реализации (инкапсуляция), наследования, и динамического полиморфизма, реализуемого посредством виртуальных функций, несомненно, является наиболее широко используемой.
Однако, динамический полиморфизм не бесплатен. Несмотря на то, что временные затраты на вызов виртуальной функции не слишком большие, при определенных обстоятельствах, например, цикл, обрабатывающий множество полиморфных объектов, оверхэд такого решения по сравнению с обычными функциями становится заметным.
Статический полиморфизм
В то время как динамический полиморфизм является полиморфизмом времени выполнения и явных интерфейсов, статический полиморфизм является полиморфизмом времени компиляции и неявных интерфейсов. Давайте разберемся что это значит.
Глядя на следующий код
мы можем сказать следующее: переданный в функцию process() указатель, должен указывать на объект, реализующий интерфейс (наследующий) base, и выбор реализаций функций prepare() и work() будет осуществлен во время выполнения программы в зависимости от того на объект какого именно производного от base типа указывает b.
Если же мы рассмотрим следущий код:
то мы можем сказать, что во-первых у объекта типа T должны быть функции prepare() и work(), а во-вторых реализации этих функций будут выбраны во время компиляции, основываясь на выведенном реальном типе T.
Как видите, при всей разности подходов, главная (с практической точки зрения) общая особенность обоих видов полиморфизма заключается в том, что в клиентском коде не нужно ничего менять при работе с объектами разных типов, при условии что они удовлетворяют описанным выше требованиям.
Раз все так замечательно, код, в принципе, не усложняется, рантайм оверхед нивелируется, почему бы тогда полностью не заменить динамический полиморфизм статическим? К сожалению, как обычно это и бывает, все не так просто. Существует ряд как субъективных так и объективных недостатков статического полиморфизма. К субъективным можно отнести, например, то, что явный интерфейс часто упрощает жизнь разработчикам, особенно в больших проектах. Иметь перед глазами заголовочный файл с классом — интерфейсом, который тебе нужно реализовать, гораздо удобнее, чем исследовать код шаблонных функций на предмет того какие функции тебе нужно реализовать и как, чтобы этот код работал. Представьте к тому же, что этот код написан давно и сейчас уже не у кого спросить что имелось в виду в том или ином кусочке.
Объективные же причины можно так или иначе свести к тому, что после инстанциирования шаблонные классы (функции) имеют разные, часто никак не связанные друг с другом типы.
Почему это плохо? Объекты таких типов без дополнительных ухищрений (см. boost::variant, boost::tuple, boost::any, boost::fusion etc.) невозможно положить в один контейнер и следовательно пакетно обработать. Невозможно, например, во время исполнения подменить объект — член класса, объектом другого типа, в рамках реализации “Стратегии” или “Состояния”. И хотя и эти паттерны можно реализовать и другими способами без классовых иерархий, например используя std::function или просто указатели на функции, ограничение, тем не менее, на лицо.
Но никто не заставляет нас строго придерживаться какой-то одной парадигмы. Самые мощные, гибкие и интересные решения возникают на стыке этих двух подходов, на стыке ООП парадигмы и generic парадигмы. Идиома CRTP как раз и является одним из примеров такого слияния парадигм.
CRTP (Curiously Recurring Template Pattern) — это идиома проектирования, заключающаяся в том, что класс наследует от базового шаблонного класса с самим собой в качестве параметра шаблона базового класса. Звучит запутано, но в коде выглядит довольно просто.
Что это может нам дать? Такая конструкция делает возможным обращение к производному классу из базового.
А возможность такой коммуникации, в свою очередь, открывает несколько интересных возможностей.
Явный интерфейс
В главе про статический полиморфизм я назвал отсутствие явных интерфейсов субъективным недостатком статического полиморфизма. На эту тему можно спорить, но так или иначе, явный интерфейс несложно определить, используя CRTP. Действительно, мы можем определить набор обязательных функций интерфейса через вызовы этих функций из базового класса.
С помощью такой конструкции один разработчик (архитектор) может задать интерфейс некого набора классов, и остальным программистам будет на что ориентироваться при реализации этого интерфейса. Но этим возможности CRTP не ограничиваются.
MixIn
MixIn — это прием проектирования, при котором класс (интерфейс, модуль и т.п.) реализует некоторую функциональность, которую можно “подмешать”, внести в другой класс. Самостоятельно же MixIn класс обычно не используется. Этот прием не является специфическим для С++, и в некоторых других языках он поддерживается на уровне языковых конструкций.
В С++ нет нативной поддержки MixIn’ов, но тем не менее эту идиому вполне можно реализовать с помощью CRTP.
Например, MixIn класс может реализовывать функциональность синглтона или подсчета ссылок на объект. А для того чтобы использовать такой класс достаточно отнаследовать от него с “собой” в качестве параметра шаблона.
Зачем здесь CRTP? Почему бы просто не наследовать от класса, реализующую некую нужную нам функциональность?
Дело в том, что внутри MixIn’а нам нужен доступ к функциям наследуемого класса (в случае синглтона к конструктору) и здесь на помощь приходит CRTP. И если пример с синглтоном кажется надуманным (действительно, кто сегодня использует синглтон?), то ниже вы найдете два более близких к реальности примера.
Enable_shared_from_this
MixIn структура (boost)std::enable_shared_from_this позволяет получить shared_ptr на объект, не создавая новую группу владения.
В этом случае каждый shared_ptr, полученный с помощью функции bad::get(), открывает новую группу владения объектом, и когда настанет время уничтожения shared_ptr’ов, delete для нашего объекта вызовется больше чем один раз.
Правильно же делать вот так:
Устроена эта вспомогательная структура примерно так:
Как видите, здесь CRTP позволяет базовому классу “увидеть” тип производного класса и вернуть указатель именно на него.
MixIn функции
MixIn функциональность не обязательно должна быть включена внутрь некоторого класса. Иногда возможно ее реализовать в виде свободной функции. В качестве примера реализуем оператор “!=” для всех классов, у которых определен оператор “==”.
MixIn наоборот
Представьте, что мы пишем реализацию классов игровых космических кораблей. Наши корабли будут двигаться по одинаковому алгоритму, за исключением некоторых моментов, например, механизм подсчета оставшегося горючего и текущей скорости будут различаться от корабля к кораблю. Классическая реализация паттерна шаблонный метод (а это именно он) будет выглядеть следующим образом:
Теперь попробуем применить CRTP.
В этой реализации мы избавились от виртуальных функций да и сам код стал короче (не нужно описывать чисто виртуальные функции в базовом классе).
Концепция MixIn’а при таком подходе переворачивается с ног на голову. Основная работа делается в базовом классе, а дополнительную (различающуюся) функциональность мы “подмешиваем” из производных классов.
Хочу акцентировать ваше внимание на этом приеме проектирования и Mixin’ах в целом. Пусть вас не смущает искусственный пример с космическими кораблями или синглтоном. В реальных задачах этот подход позволяет строить очень гибкие архитектуры, избегать повторяющегося кода, локализовывать функциональность в небольших классах и впоследствии “микшировать” их в нужную в данный момент смесь. Особенно он начинает блистать в кооперации со средствами, позволяющими пакетно обрабатывать множество объектов разных типов (см. boost::fusion).
MixIn вариации
Главная теорема разработки программного обеспечения (FTSE) гласит: “Любую проблему можно решить, вводя дополнительные уровни косвенности”. Посмотрим, как это можно применить к CRTP MixIn’ам.
Возможно, вы заметили в предыдущих главах “Явный интерфейс” и “MixIn наоборот” я использовал открытые функции в производном классе. Вообще говоря, это не очень хорошо, так как нарушает инкапсуляцию. Получается, что наружу у нас “торчат” функции, которые не предназначены для того, что пользователь вызывал их напрямую.
Можно решить эту проблему, сделав базовые классы друзьями производного. После этого можно вносить эти функции в private секцию, но представьте, что вам нужно отнаследовать от нескольких базовых MixIn’ов. Придется делать друзьями все базовые классы. Для комплексного решения этой проблемы, а также для того, чтобы обеспечить компиляцию на некоторых старых компиляторах, можно ввести новый уровень косвенности. Он представляет из себя структуру, функции которой перенаправляют вызовы из базы в производный класс.
Теперь из базовых классов, мы вызываем не функции производного, а функции промежуточной структуры.
В производном же классе нам достаточно внести в друзья только структуру access.
К дополнительным плюсам такого подхода можно отнести то, что базовые классы перестают что либо “знать” о своих производных классах, в частности какие конкретные функции из них нужно вызвать, а слабосвязанная система, как правило более гибка, чем сильносвязанная, а также то, что все вызовы к производному классу собраны в одном месте (в структуре access), позволяя тем самым легче визуально отделить их от функций производного класса, выполняющих другую работу.
Минусом же, как это часто бывает, является усложнение проектного решения. Поэтому я ни в коем случае не призываю использовать такую схему и в хвост и в гриву, но иметь о ней представление, мне кажется, не будет лишним.
В чем разница между динамическим и статическим полиморфизмом в Java?
Может ли кто-нибудь привести простой пример, объясняющий разницу между динамическим и статическим полиморфизмом в Java?
14 ответов
В чем разница между статическим уведомлением и динамическим уведомлением? кто-нибудь может мне помочь
В чем разница между статическим и динамическим связыванием?
Полиморфизм
1. Статическая привязка binding/Compile-Time/Ранняя привязка/Перегрузка метода.(в том же классе)
2. Динамическая привязка binding/Run-Time/Поздняя привязка/Переопределение метода.(в разных классах)
пример перегрузки:
переопределяющий пример:
Перегрузка метода была бы примером статического полиморфизма
в то время как переопределение было бы примером динамического полиморфизма.
Потому что в случае перегрузки во время компиляции компилятор знает, какой метод связать с вызовом. Однако он определяется во время выполнения для динамического полиморфизма
Например,
Рассмотрим приложение, которое сериализует и десериализует различные типы документов.
Класс Document определит методы ‘ Serialize() ’ и ‘ De-serialize() ’ как виртуальные, и каждый производный класс будет реализовывать эти методы по-своему, основываясь на фактическом содержании документов.
Когда различные типы документов должны быть serialized/de-serialized, объекты документа будут ссылаться ссылкой на класс «Документ» (или указателем), а когда ‘ на нем вызывается метод Serialize() ’ или ‘ De-serialize()’, вызываются соответствующие версии виртуальных методов.
Например,
Объект employee может иметь два метода print(), один из которых не принимает аргументов, а другой принимает строку префикса, которая будет отображаться вместе с данными о сотруднике.
Для получения более подробной информации, пожалуйста, прочитайте «What is Polymorphism» (Google it).
В чем разница между динамическим типом, утиным типом, полиморфизмом и параметрическим полиморфизмом? Я спрашиваю, потому что Ruby имеет каждый из них ( согласно Википедии ), хотя меня интересует более общее.
Привязка относится к связи между вызовом метода и определением метода.
На этом рисунке четко показано, что является обязательным.
На этом рисунке вызов “a1.methodOne()” привязан к соответствующему определению methodOne(), а вызов “a1.methodTwo()” привязан к соответствующему определению methodTwo().
Для каждого вызова метода должно быть правильное определение метода. Это правило в java. Если компилятор не видит правильного определения метода для каждого вызова метода, он выдает ошибку.
Теперь перейдем к статической привязке и динамической привязке в java.
Статическая Привязка В Java :
Статическая привязка может быть продемонстрирована, как показано на рисунке ниже.
На этом рисунке » a1 «является ссылочной переменной типа класса A, указывающей на объект класса A.» a2 » также является ссылочной переменной типа класса A, но указывает на объект класса B.
Во время компиляции при привязке компилятор не проверяет тип объекта, на который указывает конкретная ссылочная переменная. Он просто проверяет тип ссылочной переменной, через которую вызывается метод, и проверяет, существует ли определение метода для него в этом типе.
Например, для вызова метода «a1.method()» на приведенном выше рисунке компилятор проверяет, существует ли определение метода для method() в классе A. Поскольку » a1 » является типом класса A. Аналогично, для вызова метода «a2.method()» он проверяет, существует ли определение метода для method() в классе A. Поскольку » a2 » также является типом класса A. Он не проверяет, на какой объект указывают » a1 » и «a2». Этот тип привязки называется статической привязкой.
Динамическая Привязка В Java :
Динамическая привязка-это привязка, которая происходит во время выполнения. Это также называется поздней привязкой, потому что привязка происходит, когда программа действительно запущена.
Во время выполнения для привязки используются фактические объекты. Например, для вызова “a1.method()” на приведенном выше рисунке будет вызван method() фактического объекта, на который указывает «a1». Для вызова “a2.method()” будет вызван method() фактического объекта, на который указывает «a2». Этот тип привязки называется динамической привязкой.
Динамическая привязка приведенного выше примера может быть продемонстрирована, как показано ниже.
В простых терминах :
Статический полиморфизм : Одно и то же имя метода перегружено другим типом или количеством параметров в одном классе (другая сигнатура). Целевой вызов метода разрешается во время компиляции.
Как правило, перегрузка не будет рассматриваться как полиморфизм.
Подклассы класса могут определять свое собственное уникальное поведение и в то же время совместно использовать некоторые из тех же функций родительского класса
перегрузка метода является примером полиморфизма времени компиляции/статики, поскольку привязка метода между вызовом метода и определением метода происходит во время компиляции и зависит от ссылки на класс (ссылка создается во время компиляции и отправляется в стек).
переопределение метода является примером полиморфизма во время выполнения/динамического полиморфизма, поскольку привязка метода между вызовом метода и определением метода происходит во время выполнения и зависит от объекта класса (объект создается во время выполнения и отправляется в кучу).
Полиморфизм: Полиморфизм-это способность объекта принимать множество форм. Наиболее распространенное использование полиморфизма в OOP происходит, когда ссылка на родительский класс используется для ссылки на объект дочернего класса.
Полиморфизм динамического связывания/времени выполнения :
Полиморфизм времени выполнения, также известный как переопределение метода. В этом механизме, с помощью которого вызов переопределенной функции разрешается во время выполнения.
Выход:
Способ внутреннего пуска автомобиля
Статическое связывание /compile-time полиморфизм:
Какой метод должен быть вызван, решается только во время компиляции.
Выход: Внутри коллекции сортировка мето
Чтобы понять, почему это так, давайте возьмем пример классов Mammal и Human
Я включил выходные данные, а также байт-код в нижеприведенных строках кода
Но байт-код для anyMammal.speak() и humanMammal.speak() одинаков, потому что, согласно компилятору, оба метода вызываются по ссылке, но выходные данные для обоих вызовов методов различны, потому что во время выполнения JVM знает, какой объект содержит ссылка, а JVM вызывает метод на объекте, и именно поэтому переопределение метода известно как динамический полиморфизм.
Таким образом, из приведенного выше кода и байт-кода ясно, что на этапе компиляции метод вызова рассматривается из ссылочного типа. Но во время выполнения метод будет вызван из объекта, на который ссылается ссылка.
Статический полиморфизм: это когда решение о том, какой метод выполнить, определяется во время компиляции. Примером этого может быть перегрузка метода.
Динамический полиморфизм: это когда решение о выборе метода для выполнения устанавливается во время выполнения. Примером этого может быть переопределение метода.
Полиморфизм относится к способности объекта вести себя по-разному для одного и того же триггера.
Статический полиморфизм (полиморфизм во время компиляции)
Динамический полиморфизм (полиморфизм времени выполнения)
Полиморфизм времени компиляции(статическое связывание/раннее связывание): В статическом полиморфизме, если мы вызываем метод в нашем коде, то определение того, какое определение этого метода должно быть вызвано, фактически решается только во время компиляции.
Во время компиляции Java знает, какой метод вызывать, проверяя сигнатуры методов. Таким образом, это называется полиморфизмом во время компиляции или статическим связыванием.
Динамический полиморфизм(поздний полиморфизм среды выполнения Binding/): Во время выполнения Java ожидает, пока среда выполнения определит, на какой объект на самом деле указывает ссылка. Разрешение метода было принято во время выполнения, поэтому мы называем его полиморфизмом времени выполнения.
Рассмотрим приведенный ниже код:
Теперь, глядя на код, вы никогда не сможете сказать, какая реализация methodA() будет выполнена, потому что это зависит от того, какое значение пользователь дает во время выполнения. Таким образом, только во время выполнения решается, какой метод будет вызван. Следовательно, полиморфизм времени выполнения.
Перегрузка метода-это полиморфизм времени компиляции, давайте возьмем пример, чтобы понять концепцию.
В этом примере у человека есть метод eat, который представляет, что он может есть пиццу или лапшу. Что метод eat перегружен, когда мы компилируем этот Person.java, компилятор разрешает вызов метода » e.eat(noodles) [который находится в строке 6] с определением метода, указанным в строке 8, то есть это метод, который принимает noodles в качестве параметра, и весь процесс выполняется компилятором, поэтому это полиморфизм времени компиляции. Процесс замены вызова метода определением метода называется привязкой, в этом случае он выполняется компилятором, поэтому он называется ранней привязкой.
Следуя ответу Нареша, динамический полиморфизм является только ‘dynamic’ в Java из-за присутствия виртуальной машины и ее способности интерпретировать код во время выполнения, а не код, запущенный изначально.
Похожие вопросы:
В чем разница между статическим и динамическим SQL? Я создал соединение с базой данных для карты Jvector. Код работает и устанавливает окно оповещения. Показывает все оповещения, название страны.
Время связывания можно разделить на два типа: статическое и динамическое. В чем разница между статическим и динамическим связыванием? Не могли бы вы привести краткий пример каждого из них, чтобы еще.
Привет может любое тело описать, в чем разница между статическим курсором и динамическим курсором с примерами.
В чем разница между статическим уведомлением и динамическим уведомлением? кто-нибудь может мне помочь
В чем разница между статическим и динамическим связыванием?
В чем разница между динамическим типом, утиным типом, полиморфизмом и параметрическим полиморфизмом? Я спрашиваю, потому что Ruby имеет каждый из них ( согласно Википедии ), хотя меня интересует.
Эта ссылка помогла мне понять разницу между статической привязкой и динамической привязкой? но я в замешательстве, что в чем разница между статическим связыванием и полиморфизмом времени компиляции.
Мне трудно найти хороший ответ на этот вопрос, но в чем разница между статическим и динамическим управлением в приложении ASP.NET webforms. Имеет ли выпадающий список, объявленный в html, но.
HDR-это высокий динамический диапазон, который широко используется в видеоустройствах для лучшего просмотра. В чем разница между статическим HDR и динамическим HDR?
В чем разница между статическим и динамическим анализом с точки зрения кибербезопасности?