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

Question

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

Answer 1

Что ж, решения о перегрузке (какой метод подписи используется на основе аргументов ¹ ) принимаются компилятором, тогда как решения о переопределении (метод реализации * 1006) * используются, основываясь на типе цели метода), выполняются 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.

---

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

Answer 2

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

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

Answer 3

Полиморфизм

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

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

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

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

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

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

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

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

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

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

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

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

 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)
   {
   }
 }

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

Например:

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

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

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

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

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

Answer 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 имеет тип шимпанзе . Несмотря на то, что компилятор считает, что собирается вызвать метод walk в chimp; но это не то, что на самом деле происходит . Поскольку это зависит от CLR (времени выполнения), этот тип полиморфизма называется полиморфизмом времени выполнения.

Answer 5

Полиморфизм

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

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

В полиморфизме у нас есть 2 разных типа

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

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

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

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

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

Для более подробной информации, проверьте эту ссылку полиморфизм в C #

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

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

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

Answer 6

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

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

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

Answer 7

Пример выполнения полиморфизма во время c #.

using System;
public class demo{
public static void Main(String[] args){

cal cal ;

add a = new add();
cal = a;
Console.WriteLine("Addition is" + cal.calculate(20, 20));   

sub s = new sub();
cal = s;
Console.WriteLine("Substraction is" + cal.calculate(20, 20));

mul m = new mul();
cal = m;
Console.WriteLine("Multiplication is" + cal.calculate(20, 20));


div d = new div();
cal = d;
Console.WriteLine("Division is" + cal.calculate(20, 20));

Console.ReadLine();
}
}

public abstract class cal{
       public abstract int calculate(int a, int b);
}


public class add : cal {
      public override int calculate(int a ,int b){
        return a+b;
      }
 }

public class sub : cal{
      public override int calculate(int a, int b){
        return a-b;
      }     
}

public class mul : cal{
      public override int calculate(int a, int b){
        return a*b;
      }
 }

 public class div : cal{
       public override int calculate(int a, int b){
            return a/b;
       }
 }

Answer 8

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

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

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

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

Answer 9

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

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

Answer 10

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