Полиморфизм времени компиляции и полиморфизм времени выполнения

Почему перегрузка называется полиморфизмом времени компиляции и переопределением полиморфизма времени выполнения в С#?

Ответы

Ответ 1

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

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

Ответ 2

Ну, перегрузочные решения (используемые подписи методов, основанные на аргументах ¹), выполняются компилятором, тогда как переопределение решений (какие реализации метода используются в зависимости от типа целевой метода) создаются CLR во время выполнения.

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

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

using System;

class Test
{
    static void Foo(object a)
    {
        Console.WriteLine("Object overload called");
    }

    static void Foo(string a)
    {
        Console.WriteLine("String overload called");
    }

    static void Main()
    {
        object x = "hello";
        Foo(x);
    }
}

Здесь перегрузка Foo(object) вызывается, потому что x имеет тип object во время компиляции - это только во время выполнения, которое, как известно, ссылается на строку.

Сравните это с этим примером:

using System;

class Base
{
    public virtual void Foo()
    {
        Console.WriteLine("Base.Foo called");
    }
}

class Derived : Base
{
    public override void Foo()
    {
        Console.WriteLine("Derived.Foo called");
    }
}

class Test
{
    static void Main()
    {
        Base x = new Derived();
        x.Foo();
    }
}

Здесь тип времени компиляции x равен Base, но он все еще является методом переопределения производного класса, который вызывается, поскольку тип времени выполнения объекта, на который ссылается x, равен Derived.

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

Ответ 3

Полиморфизм

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

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

Переопределение - те же имена методов с одинаковыми аргументами и одинаковыми типами возвращаемых значений, связанные с классом и его подклассом. Переопределение в С# использует ключевое слово "переопределить". Чтобы переопределить метод, необходимо заменить его новым способом обработки данных.

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

Время компиляции Полиморфизм или раннее связывание

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

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

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

Полиморфизм времени выполнения или поздняя привязка

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

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

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

 class A
 {
    public virtual void Leg(string Name)
    {

    }
 }

 class B:A
 {
    public override void Leg(string Name)
    {

    }
 }

Пример для дополнительной загрузки

 class A
 {
  void a()
   {
   }
  void a(string Name)
   {
   }
 }

Другими словами: "Многие формы одного объекта называются полиморфизмом".

Например:

Лидер команды ведет себя к Sub Ordinate. Руководитель группы ведет себя к своим старшим. Руководитель группы ведет себя с другими руководителями команд.

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

Разница между переопределением метода и скрытием метода

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

Скрытие метода не имеет отношения между методами в базовом классе и производном классе. Метод в производном классе скрывает метод в базовом классе.

Ответ 4

полиморфизм времени компиляции

Предположим, что у вас есть 2 метода: поскольку метод имеет одинаковое имя, но имеет разные параметры; он называется "перегруженным" методом. Ешьте (кормушка); Ешьте (корм для струн, струна SpoonOrFork);

и вы используете это в своем классе

public class Man
{
 public bool Eat (string food)
 {
  //implementation
 }

 public bool Eat (string food, string SpoonOrFork)
 {
  //implementation
 }

}
public class dinner
{
  public bool Start()
  {
   string food = "course1";
   Man.Eat ( food);
  }
}

Теперь, когда вы компилируете эту программу, компилятор точно знает, какую версию метода Eat вызывать во время самой компиляции (из-за разницы в параметрах).

Вот почему он называется полиморфизмом времени компиляции.

Полиморфизм времени выполнения

public class chimp
    {
        public virtual void walk()
        {
            Console.WriteLine("I am walking using 4 legs");
        }

    }

    public class neanderthals : chimp
    {
        public override void walk()
        {
            Console.WriteLine("I am walking using 2 legs");
        }

    }



    class Program
    {
        static void Main(string[] args)
        {
            chimp x = new neanderthals();
            x.walk();
            Console.ReadLine(); // this will give an output of "I am walking using 2 legs"
        }
    }

В приведенном выше коде x имеет тип шимпанзе. Несмотря на то, что компилятор думает, что он будет называть метод ходьбы в шимпанзе; но это не то, что на самом деле происходит. Поскольку это зависит от CLR (время выполнения), этот вид полиморфизма называется полиморфизмом "время выполнения".

Ответ 5

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

Когда вы вызываете метод, подобный objectVariable.Method(), какой метод будет вызывать ваш компьютер, будет зависеть от того, какой экземпляр класса присутствует в объекте Variable, и который решил после того, как вы назначили ему экземпляр класса. Это произойдет во время выполнения, а не во время компиляции. И, следовательно, имя "полиморфизм времени выполнения".

Вы можете узнать больше: В чем разница между временем компиляции и полиморфизмом во время выполнения

Ответ 6

Полиморфизм

Полиморфизм означает много форм (способность принимать более одной формы). В полиморфизме поли означает "множественный", а морф означает "формы", поэтому полиморфизм означает много форм.

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

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

 -  Compile Time Polymorphism (Called as Early Binding or Overloading or static binding)

 -  Run Time Polymorphism (Called as Late Binding or Overriding or dynamic binding)

Полиморфизм времени компиляции

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

Метод Перегрузка или полиморфизм времени компиляции означает те же имена методов с разными сигнатурами (разные параметры)

Подробнее см. полиморфизм этой ссылки в С#

Полиморфизм времени выполнения

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

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

Ответ 7

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

Ответ 8

Классические примеры статического полиморфизма основаны на метапрограммирование шаблона или Duck Typing, но не при перегрузке метода.

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

Ответ 9

Время полимеризации

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

Время выполнения Полиморфизм

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