Что такое полиморфизм, для чего он нужен и как он используется?

StackOverflow https://stackoverflow.com/questions/1031273

Вопрос

Что такое полиморфизм, для чего он нужен и как он используется?

Это было полезно?

Решение

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

  • Поли = много:многоугольник = многогранный, полистирол = множество стиролов (а), полиглот = множество языков и так далее.
  • Morph = изменение или форма:морфология = изучение биологической формы, Морфеус = греческий бог сновидений, способный принимать любую форму.

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

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

Но, таким же образом, класс, подобный BigDecimal или Rational или Imaginary может также предоставлять эти операции, даже если они работают с разными типами данных.

Классическим примером является Shape класс и все классы, которые могут наследоваться от него (квадрат, круг, додекаэдр, неправильный многоугольник, splat и так далее).

При полиморфизме каждый из этих классов будет иметь разные базовые данные.Точечной форме нужны только две координаты (при условии, конечно, что она находится в двумерном пространстве).У круга должен быть центр и радиус.Квадрату или прямоугольнику нужны две координаты для верхнего левого и нижнего правого углов и (возможно) поворот.Неправильный многоугольник нуждается в наборе линий.

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

shape.Draw()

чтобы получить правильное поведение для любой фигуры.

Это контрастирует со старым способом выполнения задач, при котором код был отделен от данных, и у вас были бы такие функции, как drawSquare() и drawCircle().

Объектная ориентация, полиморфизм и наследование - все это тесно связанные понятия, и их жизненно важно знать.За мою долгую карьеру было много "серебряных пуль", которые, по сути, просто выдыхались, но парадигма OO оказалась хорошей.Изучите это, поймите, полюбите - вы будете рады, что сделали :-)

(а) Изначально я написал это в шутку, но это оказалось правильным и, следовательно, не таким смешным.Момомер стирола состоит из углерода и водорода, C8H8, а полистирол изготавливается из групп этого, (C8H8)n.

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

Иногда вам следует просто уволиться, пока вы отстаете :-)

Другие советы

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

Вот пример на C #. Создайте четыре класса в консольном приложении: 

public abstract class Vehicle
{
    public abstract int Wheels;
}

public class Bicycle : Vehicle
{
    public override int Wheels()
    {
        return 2;
    }
}

public class Car : Vehicle
{
    public override int Wheels()
    {
        return 4;
    }
}

public class Truck : Vehicle
{
    public override int Wheels()
    {
        return 18;
    }
}

Теперь создайте следующее в Main () модуля для консольного приложения: 

public void Main()
{
    List<Vehicle> vehicles = new List<Vehicle>();

    vehicles.Add(new Bicycle());
    vehicles.Add(new Car());
    vehicles.Add(new Truck());

    foreach (Vehicle v in vehicles)
    {
        Console.WriteLine(
            string.Format("A {0} has {1} wheels.",
                v.GetType().Name, v.Wheels));
    }
}

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

Затем мы добавляем в список велосипед, легковой и грузовой автомобиль.

Затем мы можем циклически проходить по каждому Транспортному средству в списке и обрабатывать их все одинаково, однако, когда мы получаем доступ к свойству каждого Транспортного средства "Колеса", класс Vehicle передает делегирование выполнения этого кода соответствующему подклассу.

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

Я надеюсь, что это поможет вам.

Из Понимания и применения полиморфизма в PHP , спасибо Стиву Гидетти

  

Полиморфизм - это длинное слово для очень простого понятия.

     

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

     

Прелесть полиморфизма в том, что коду, работающему с разными классами, не нужно знать, какой класс он использует, поскольку все они используются одинаково.   Реальная аналогия полиморфизма - это кнопка. Все знают, как использовать кнопку: вы просто нажимаете на нее. Что делает кнопка & # 8221; однако зависит от того, с чем он связан, и от контекста, в котором он используется & # 8212; но результат не влияет на то, как он используется. Если ваш начальник скажет вам нажать кнопку, у вас уже есть вся информация, необходимая для выполнения задачи.

     

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

Если кто-нибудь скажет, ЧТО нужно ПРЕКРАТИТЬ общение с этими людьми

  1. Хирург
  2. Парикмахер -Стилист
  3. Актер

Что же произойдет?

  • Хирург начинал делать разрез.
  • Парикмахер начинал подстригать кому-нибудь волосы.
  • Актер внезапно прекращал играть вне текущей сцены, ожидая указаний режиссера.

Итак, приведенное выше представление показывает, что такое полиморфизм (то же имя, другое поведение) в ООП.

Если вы идете на собеседование, и интервьюер просит вас рассказать / показать живой пример полиморфизма в той же комнате, где мы сидим, скажите-

Ответ - Дверь / Окна

Интересно, как это сделать?

Через дверь / окно - может прийти человек, может прийти воздух, может прийти свет, может пойти дождь и т.д.

Чтобы понять это лучше и проще, я использовал приведенный выше пример..Если вам нужна ссылка на код, следуйте приведенным выше ответам.

Простое объяснение по аналогии

Президент Соединенных Штатов использует полиморфизм.Каким образом?Что ж, у него много советников:

  1. Военные советники
  2. Юридические консультанты
  3. Физики-ядерщики (в качестве консультантов)
  4. Медицинские консультанты
  5. и т.д. и т.п.

Каждый должен нести ответственность только за что-то одно:Пример:

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

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

Почему это плохая идея для президента - знать все эти конкретные вещи?

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

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

Есть ли лучший подход?

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

Он может использовать полиморфный подход к управлению страной.

Пример использования полиморфного подхода:

Все, что делает президент, это просит людей дать ему совет - и это то, что он на самом деле делает в реальной жизни, - и это то, что должен делать хороший президент.все его советники реагируют по-разному, но все они знают, что президент имеет в виду под:Посоветуйте ().В его офис стекаются сотни людей.На самом деле не имеет значения, кто они такие. Все, что знает президент, - это то, что, когда он просит их "Посоветовать", они знают, как реагировать соответствующим образом:

public class MisterPresident
{
    public void RunTheCountry()
    {
        // assume the Petraeus and Condi classes etc are instantiated.
        petraeus.Advise(); // # Petraeus says send 100,000 troops to Fallujah
        condolezza.Advise(); // # she says negotiate trade deal with Iran
        healthOfficials.Advise(); // # they say we need to spend $50 billion on ObamaCare
    }
}

Такой подход позволяет президенту буквально управлять страной, ничего не зная о военном деле, здравоохранении или международной дипломатии:подробности оставлены на усмотрение экспертов.Единственное, что президенту нужно знать, это следующее:"Посоветуйте()".

То, чего ты не хочешь:

public class MisterPresident
{
    public void RunTheCountry()
    {
        // people walk into the Presidents office and he tells them what to do
        // depending on who they are.

        // Fallujah Advice - Mr Prez tells his military exactly what to do.
        petraeus.IncreaseTroopNumbers();
        petraeus.ImproveSecurity();
        petraeus.PayContractors();

        // Condi diplomacy advice - Prez tells Condi how to negotiate

        condi.StallNegotiations();
        condi.LowBallFigure();
        condi.FireDemocraticallyElectedIraqiLeaderBecauseIDontLikeHim();

        // Health care

        healthOfficial.IncreasePremiums();
        healthOfficial.AddPreexistingConditions();
    }
}

НЕТ!НЕТ!НЕТ!В приведенном выше сценарии всю работу выполняет президент:он знает об увеличении численности войск и ранее существовавших условиях.Это означает, что если политика на Ближнем Востоке изменится, то президенту придется изменить свои приказы, а также и класс Петреуса тоже.Нам нужно всего лишь изменить класс Петреуса, потому что президент не должен увязать в такого рода деталях.Ему не нужно знать о деталях.Все, что ему нужно знать, - это то, что если он сделает один заказ, обо всем позаботятся.Все детали следует оставить на усмотрение экспертов.

Это позволяет президенту делать то, что у него получается лучше всего:устанавливайте общие правила, хорошо выглядите и играйте в гольф: P.

Как это на самом деле реализовано - через базовый класс или общий интерфейс

По сути, это и есть полиморфизм, в двух словах.Как именно это делается?Через "реализацию общего интерфейса" или используя базовый класс (наследование) - смотрите приведенные выше ответы, в которых это более подробно описано.(Чтобы более четко понять эту концепцию, вам нужно знать, что такое интерфейс, и вам нужно будет понять, что такое наследование.Без этого вам могло бы быть трудно.)

Другими словами, Petraeus, Condi и HealthOfficials были бы классами, которые "реализуют интерфейс" - давайте назовем это IAdvisor интерфейс, который содержит только один метод: Advise().Но теперь мы переходим к конкретике.

Это было бы идеально

    public class MisterPresident
    {
            // You can pass in any advisor: Condi, HealthOfficials,
            //  Petraeus etc. The president has no idea who it will 
            // be. But he does know that he can ask them to "advise" 
            // and that's all Mr Prez cares for.

        public void RunTheCountry(IAdvisor governmentOfficer)
        {             
            governmentOfficer.Advise();              
        }
    }


    public class USA
    {
        MisterPresident president;

        public USA(MisterPresident president)
        {
            this.president = president;
        }

        public void ImplementPolicy()
        {
            IAdvisor governmentOfficer = getAdvisor(); // Returns an advisor: could be condi, or petraus etc.
            president.RunTheCountry(governmentOfficer);
        }
    }

Краткие сведения

Все, что вам действительно нужно знать, это следующее:

  • Президенту не нужно знать подробностей - это предоставлено другим.
  • Все, что президенту нужно знать, это спросить, кто когда-либо войдет в дверь, чтобы дать ему совет, - и мы знаем, что они абсолютно точно будут знать, что делать, когда их попросят дать совет (потому что все они на самом деле советники (или IAdvisors :) )

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

Полиморфизм - это способность обрабатывать класс объекта как родительский класс.

Например, предположим, что есть класс с именем Animal и класс Dog с наследованием от Animal. Полиморфизм - это способность обрабатывать любой объект Dog как объект Animal следующим образом: 

Dog* dog = new Dog;
Animal* animal = dog;

Полиморфизм:

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

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

  • Точно так же, как поля структуры C находятся в защищенном пространстве имен, являются переменными экземпляра объекта.

  • Имена методов также защищены.В отличие от имен функций C, имена методов не являются глобальными символами.Имя метода в одном классе не может конфликтовать с именами методов в других классах;два очень разных класса могут реализовывать методы с одинаковыми именами.

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

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

Примеры:

Пример-1: Вот простой пример, написанный на Python 2.x.

class Animal:
    def __init__(self, name):    # Constructor of the class
        self.name = name
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        return 'Meow!'

class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'

animals = [Cat('Missy'),
           Dog('Lassie')]

for animal in animals:
    print animal.name + ': ' + animal.talk()

Пример-2: Полиморфизм реализован в Java метод использования перегрузка и способ переопределяющий концепции.

Давайте рассмотрим пример Car для обсуждения полиморфизма.Возьмите любую марку, такую как Ford, Honda, Toyota, BMW, Benz и т.д., Все относится к типу Car.

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

Теперь давайте создадим автомобиль базового типа

Car.java

public class Car {

    int price;
    String name;
    String color;

    public void move(){
    System.out.println("Basic Car move");
    }

}

Давайте рассмотрим пример с автомобилем Ford.

Ford расширяет тип Car, чтобы наследовать все его элементы (свойства и методы).

Ford.java

public class Ford extends Car{
  public void move(){
    System.out.println("Moving with V engine");
  }
}

Приведенный выше класс Ford расширяет класс Car, а также реализует метод move().Несмотря на то, что метод move уже доступен Ford через наследование, Ford все еще реализовал этот метод по-своему.Это называется переопределением метода.

Honda.java

public class Honda extends Car{
  public void move(){
    System.out.println("Move with i-VTEC engine");
  }
}

Как и Ford, Honda также расширила тип автомобиля и по-своему внедрила метод перемещения.

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

PolymorphismExample.java

public class PolymorphismExample {
  public static void main(String[] args) {
    Car car = new Car();
    Car f = new Ford();
    Car h = new Honda();

    car.move();
    f.move();
    h.move();

  }
}

Вывод примера полиморфизма:

В основном методе класса PolymorphismExample я создал три объекта - Car, Ford и Honda.Все три объекта обозначаются типом автомобиля.

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

Итак, для ссылок car,f и h в примере POLYMORPHISM существует метод move из типа Car.Таким образом, компилятор передает процесс компиляции без каких-либо проблем.

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

Итак, все объекты имеют тип Car, но во время выполнения выполнение зависит от объекта, на котором происходит вызов.Это называется полиморфизмом.

Обычно это относится к способности объекта типа A вести себя как объект типа B.В объектно-ориентированном программировании это обычно достигается путем наследования.Некоторые ссылки на википедию, чтобы прочитать больше:

Редактировать:исправлены неработающие ссылки.

Полиморфизм это: 

class Cup {
   int capacity
}

class TeaCup : Cup {
   string flavour
}

class CoffeeCup : Cup {
   string brand
}

Cup c = new CoffeeCup();

public int measure(Cup c) {
    return c.capacity
}

вы можете передать только кубок вместо конкретного экземпляра. Это помогает в целом, потому что вам не нужно указывать конкретный экземпляр measure () для каждого типа чашки

Я знаю, что это старый вопрос с множеством хороших ответов, но я бы хотел включить ответ из одного предложения:

  

Обработка производного типа, как если бы он был базовым типом.

Выше приведено множество примеров, демонстрирующих это в действии, но я считаю, что это хороший лаконичный ответ.

(Я просматривал другую статью о чем-то совершенно ином ... и всплыл полиморфизм ... Теперь я подумал, что знаю, что такое полиморфизм .... но, видимо, не так красиво объяснил ... Хотел записать это где-то .. лучше еще поделюсь ...)

http: //www.eioba. ком / а / 1htn / как-я-объяснил, остальные к моей жене

Продолжайте читать из этой части:

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

Термин полиморфизм происходит от:

poly = many

морфизм = способность меняться

В программировании полиморфизм - это «техника». это позволяет вам «выглядеть» на объекте, как на более чем один тип вещи. Например:

Объект студента - это также объект человека. Если вы " смотрите " (например, актерский состав) у студента, вы, вероятно, можете попросить студенческий билет. Вы не можете всегда делать это с человеком, верно? (человек не обязательно является студентом, поэтому может не иметь студенческого билета). Однако у человека, вероятно, есть имя. Студент тоже.

Итог " смотрящий " у одного и того же объекта с разных «углов» может дать вам различные "перспективы" (т.е. разные свойства или методы)

Таким образом, этот метод позволяет создавать вещи, которые могут быть "выглядели" под разными углами.

Почему мы используем полиморфизм? Для начала ... абстракция. На данный момент должно быть достаточно информации:)

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

  • Перегрузка функций:определение нескольких функций с одинаковым именем и разными типами параметров, такими как sqrt (float), sqrt (double) и sqrt (complex).В большинстве языков, которые допускают это, компилятор автоматически выберет правильный для типа передаваемого в него аргумента, таким образом, это полиморфизм во время компиляции.

  • Виртуальные методы в ООП:метод класса может иметь различные реализации, адаптированные к специфике его подклассов;говорят, что каждый из них переопределяет реализацию, данную в базовом классе.Учитывая объект, который может принадлежать к базовому классу или любому из его подклассов, правильная реализация выбирается "на лету", таким образом, это полиморфизм во время выполнения.

  • Шаблоны:особенность некоторых OO-языков, при которой функция, класс и т.д.может быть параметризован типом.Например, вы можете определить общий класс шаблона "list", а затем создать его экземпляр как "список целых чисел", "список строк", возможно, даже "список списков строк" или тому подобное.Как правило, вы пишете код один раз для структуры данных произвольного типа элемента, и компилятор генерирует его версии для различных типов элементов.

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

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

Если вы слушаете музыкальное произведение, у вас есть ссылка на сценарий, например, 'Fuga and Tocata' Баха и каждый музыкант, который исполняет его, делает это полиморфно по-своему.

Это всего лишь пример возможного дизайна (на Java): 

public interface Musician {
  public void play(Work work);
}

public interface Work {
  public String getScript();
}

public class FugaAndToccata implements Work {
  public String getScript() {
    return Bach.getFugaAndToccataScript();
  }
}

public class AnnHalloway implements Musician {
  public void play(Work work) {
    // plays in her own style, strict, disciplined
    String script = work.getScript()
  }
}

public class VictorBorga implements Musician {
  public void play(Work work) {
    // goofing while playing with superb style
    String script = work.getScript()
  }
}

public class Listener {
  public void main(String[] args) {
    Musician musician;
    if (args!=null && args.length > 0 && args[0].equals("C")) {
      musician = new AnnHalloway();
    } else {
      musician = new TerryGilliam();
    }
    musician.play(new FugaAndToccata());
}

Я предоставил общий обзор полиморфизма для другого вопроса:

Полиморфизм в c ++

Надеюсь, это поможет. Выписка ...

  

... это помогает начать с простого теста и определения [полиморфизма]. Рассмотрим код: 

Type1 x;
Type2 y;

f(x);
f(y);
  

Здесь f () должен выполнить некоторую операцию, и ему в качестве входных данных даются значения x и y . Чтобы быть полиморфным, f () должен иметь возможность работать со значениями как минимум двух разных типов (например, int и double ), находить и выполнение кода, соответствующего типу.

(продолжение на Полиморфизм в c ++ )

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

Полиморфизм - это способность объекта принимать различные формы. Наиболее распространенное использование полиморфизма в ООП происходит, когда ссылка на родительский класс используется для ссылки на объект дочернего класса. В этом примере, написанном на Java, у нас есть три типа транспортных средств. Мы создаем три разных объекта и пытаемся запустить метод их колес: 

public class PolymorphismExample {

    public static abstract class Vehicle
    {
        public int wheels(){
            return 0;
        }
    }

    public static class Bike extends Vehicle
    {
        @Override
        public int wheels()
        {
            return 2;
        }
    }

    public static class Car extends Vehicle
    {
        @Override
        public int wheels()
        {
            return 4;
        }
    }

    public static class Truck extends Vehicle
    {
        @Override
        public int wheels()
        {
            return 18;
        }
    }

    public static void main(String[] args)
    {
        Vehicle bike = new Bike();
        Vehicle car = new Car();
        Vehicle truck = new Truck();

        System.out.println("Bike has "+bike.wheels()+" wheels");
        System.out.println("Car has "+car.wheels()+" wheels");
        System.out.println("Truck has "+truck.wheels()+" wheels");
    }

}

Результат:

Результат

Для получения дополнительной информации посетите https: // github.com/m-vahidalizadeh/java_advanced/blob/master/src/files/PolymorphismExample.java . Я надеюсь, что это помогает.

Полиморфизм - это способность программиста писать методы с одним и тем же именем, которые выполняют разные действия для разных типов объектов, в зависимости от потребностей этих объектов.Например, если вы разрабатывали класс под названием Fraction и класс под названием ComplexNumber, оба они могут включать в себя метод , называемый display(), но каждый из них будет реализовывать этот метод по-разному.В PHP, например, вы могли бы реализовать это следующим образом:

//  Class definitions

class Fraction
{
    public $numerator;
    public $denominator;

    public function __construct($n, $d)
    {
        //  In real life, you'd do some type checking, making sure $d != 0, etc.
        $this->numerator = $n;
        $this->denominator = $d;
    }

    public function display()
    {
        echo $this->numerator . '/' . $this->denominator;
    }
}

class ComplexNumber
{
    public $real;
    public $imaginary;

    public function __construct($a, $b)
    {
        $this->real = $a;
        $this->imaginary = $b;
    }

    public function display()
    {
        echo $this->real . '+' . $this->imaginary . 'i';
    }
}


//  Main program

$fraction = new Fraction(1, 2);
$complex = new ComplexNumber(1, 2);

echo 'This is a fraction: '
$fraction->display();
echo "\n";

echo 'This is a complex number: '
$complex->display();
echo "\n";

Результаты:

This is a fraction: 1/2
This is a complex number: 1 + 2i

Некоторые из других ответов, по-видимому, подразумевают, что полиморфизм используется только в сочетании с наследованием;например, может быть Fraction и ComplexNumber оба реализуют абстрактный класс, называемый Number у этого есть метод display(), которые Fraction и ComplexNumber затем оба обязаны реализовать.Но ты этого не делаешь потребность наследование, позволяющее воспользоваться преимуществами полиморфизма.

По крайней мере, в динамически типизированных языках, таких как PHP (я не знаю о C ++ или Java), полиморфизм позволяет разработчику вызывать метод, не обязательно заранее зная тип объекта, и полагаясь на то, что будет вызвана правильная реализация метода.Например, допустим, пользователь выбирает тип Number созданный:

$userNumberChoice = $_GET['userNumberChoice'];

switch ($userNumberChoice) {
    case 'fraction':
        $userNumber = new Fraction(1, 2);
        break;
    case 'complex':
        $userNumber = new ComplexNumber(1, 2);
        break;
}

echo "The user's number is: ";
$userNumber->display();
echo "\n";

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

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

Полиморфизм буквально означает, несколько форм. (или многие формы): Объект из разных классов и один и тот же метод имени, но рабочие процессы разные. Простой пример:

Рассмотрим человека X.

Он всего лишь один человек, но он действует как многие. Вы можете спросить, как:

Он сын своей матери. Друг своим друзьям. Брат его сестре.

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

например, форма является интерфейсом, он имеет подтипы квадрат , круг , алмаз . теперь у вас есть объект Square, вы можете автоматически переместить квадрат в форму, потому что квадрат - это форма. Но когда вы пытаетесь уменьшить Shape to Square, вы должны выполнить явное приведение типов, потому что вы не можете сказать, что Shape is Square, это может быть и Circle. поэтому вам нужно вручную привести его с кодом, подобным Square s = (Square) shape , что если форма имеет тип Circle, вы получите java.lang.ClassCastException , потому что Circle является не квадратный.

Полиморфизм:

  

Разное исполнение в зависимости от экземпляра класса, а не от типа ссылочной переменной.

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

Полиморфизм - это возможность использовать объект в данном классе, где все компоненты, составляющие объект, наследуются подклассами данного класса. Это означает, что, как только этот объект объявлен классом, все подклассы ниже его (и их подклассы, и так далее, пока вы не достигнете самого дальнего / самого нижнего подкласса) наследуют объект и его компоненты (косметику).

Помните, что каждый класс должен быть сохранен в отдельных файлах.

Следующий код иллюстрирует полиморфизм:

Суперкласс: 

public class Parent {
    //Define things that all classes share
    String maidenName;
    String familyTree;

    //Give the top class a default method
    public void speak(){
         System.out.println("We are all Parents");
    }
}

Отец, подкласс: 

public class Father extends Parent{
    //Can use maidenName and familyTree here
    String name="Joe";
    String called="dad";

    //Give the top class a default method
    public void speak(){
        System.out.println("I am "+name+", the father.");
    }
}

Дочерний элемент, другой подкласс: 

public class Child extends Father {
    //Can use maidenName, familyTree, called and name here

    //Give the top class a default method
    public void speak(){
        System.out.println("Hi "+called+". What are we going to do today?");
    }
}

Метод выполнения ссылается на родительский класс для запуска: 

public class Parenting{
    public static void main(String[] args) {
        Parent parents = new Parent();
        Parent parent = new Father();
        Parent child = new Child();

        parents.speak();
        parent.speak();
        child.speak();
    }
}

Обратите внимание, что каждый класс должен быть объявлен в отдельных файлах * .java. Код должен скомпилироваться. Также обратите внимание, что вы можете постоянно использовать maidenName и familyTree дальше вниз. Это понятие полиморфизма. Концепция наследования также рассматривается здесь, где может использоваться один класс или он определяется подклассом.

Надеюсь, это поможет и прояснит ситуацию. Я опубликую результаты, когда найду компьютер, который смогу использовать для проверки кода. Спасибо за терпение!

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

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

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

Смотрите также:

http://wiki.c2.com /?КатегориЯполиморфизм

https://en.wikipedia.org/wiki/Polymorphism_ (компьютерная наука)

В объектно-ориентированных языках полиморфизм позволяет обрабатывать и обрабатывать различные типы данных через один и тот же интерфейс. Например, рассмотрим наследование в C ++: Класс B является производным от класса A. Указатель типа A * (указатель на класс A) может использоваться для обработки как объекта класса A, так и объекта класса B.

Полиморфизм в терминах кодирования - это когда ваш объект может существовать в виде нескольких типов посредством наследования и т. д. Если вы создаете класс с именем " Shape " который определяет количество сторон вашего объекта, затем вы можете создать новый класс, который наследует его, такой как "Квадрат". Когда вы впоследствии сделаете экземпляр «Квадрата» затем вы можете привести его назад и вперед из «Shape» на "Квадрат" как требуется.

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

При использовании полиморфизма модуль высокого уровня не зависит от модуля низкого уровня. Оба зависят от абстракций. Это помогает нам применять принцип инверсии зависимостей ( https://en.wikipedia.org/wiki/Dependency_inversion_principle ).

Здесь я нашел приведенное выше определение. Примерно через 50 минут видео инструктор объясняет вышеизложенное. https://www.youtube.com/watch?v=TMuno5RZNeE >

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top