Polimorfismo del tempo di compilazione rispetto al polimorfismo del tempo di esecuzione

Perché il sovraccarico chiamato polimorfismo del tempo di compilazione e il polimorfismo del tempo di esecuzione Overriding in C #?

Le funzioni sovrascritte sono funzioni che hanno la stessa firma, ma sono implementate in diverse classi derivate. In fase di compilazione, in genere il tipo di class base viene utilizzato per fare riferimento a un object, sebbene in fase di esecuzione questo object possa essere di tipo derivato, quindi quando viene chiamato un metodo sottoposto a override, l’implementazione chiamata dipende dal tipo di object facendo la chiamata (base contro un tipo derivato) che è sconosciuto al momento della compilazione.

Il sovraccarico (non proprio il polimorfismo) è semplicemente più funzioni che hanno lo stesso nome ma diverse firme (si pensi a più costruttori per un object che assume diversi numeri di argomenti). Il metodo chiamato è noto al momento della compilazione, poiché gli argomenti sono specificati in questo momento.

Bene, le decisioni di sovraccarico (che vengono utilizzate le firme del metodo, basate sugli argomenti 1 ) vengono eseguite dal compilatore, mentre le decisioni prevalenti (quali implementazioni del metodo vengono utilizzate, in base al tipo di target del metodo) vengono eseguite dal CLR in tempo di esecuzione.

Di solito non chiamerei il “polimorfismo” sovraccarico. Nella mia esperienza la parola di solito si riferisce alla sovrascrittura. Suppongo che l’overloading ti permetta di trattare un object di un tipo come un altro, sebbene l’overloading di per sé non debba essere coinvolto lì – sono solo normali conversioni di tipo.

Ecco un esempio che mostra che la scelta del sovraccarico viene eseguita al momento della compilazione:

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

Qui viene chiamato il sovraccarico di Foo(object) perché x è di tipo object in fase di compilazione – è solo in fase di esecuzione che è noto fare riferimento a una stringa.

Confronta questo con questo esempio:

 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(); } } 

Qui il tipo di x fase di compilazione è Base , ma è ancora il metodo di sovrascrittura della class derivata che viene chiamato, poiché il tipo di tempo di esecuzione dell’object a cui si riferisce x è Derived .


1 È leggermente più complicato di così, a causa del metodo che si nasconde, ecc., Ma in casi semplici si può pensare ad esso semplicemente selezionando la firma.

Polimorfismo

Tramite l’ereditarietà, una class può essere utilizzata come più di un tipo; può essere usato come un proprio tipo, qualsiasi tipo di base o qualsiasi tipo di interfaccia se implementa interfacce. Questo è chiamato polimorfismo.

Polimorfismo significa avere più di una forma. Il sovraccarico e l’override vengono utilizzati per implementare il polimorfismo. Il polimorfismo è classificato nel polimorfismo del tempo di compilazione o nella legatura anticipata o nel legame statico e nel polimorfismo di runtime o nel legame tardivo o nel legame dinamico.

Sovrascrittura: stessi nomi di metodi con gli stessi argomenti e gli stessi tipi di ritorno associati a una class e alla sua sottoclass. L’override in C # fa uso della parola chiave “override”. Sostituire un metodo significa sostituirlo con un nuovo modo di gestire i dati.

Sovraccarico – stesso nome del metodo con argomenti diversi, può o non può essere lo stesso tipo di ritorno scritto nella stessa class stessa.

Polymorphism o Early Binding del tempo di compilazione

Il polimorfismo in cui il compilatore identifica quale forma polimorfica deve eseguire al momento della compilazione, viene chiamato polimorfismo del tempo di compilazione o associazione anticipata.

Vantaggio del legame anticipato è l’esecuzione sarà veloce. Poiché ogni cosa sul metodo è nota al compilatore durante la compilazione, lo svantaggio è la mancanza di flessibilità.

Esempi di associazioni anticipate sono metodi sovraccaricati, operatori sovraccaricati e metodi sottoposti a override chiamati direttamente utilizzando oggetti derivati.

Runtime Polymorphism o Late Binding

Il polimorfismo in cui il compilatore identifica quale forma polimorfica da eseguire in fase di esecuzione ma non in fase di compilazione viene chiamato come polimorfismo di runtime o associazione tardiva.

Il vantaggio del binding tardivo è la flessibilità e lo svantaggio è che l’esecuzione sarà lenta dato che il compilatore deve ottenere le informazioni sul metodo da eseguire in fase di esecuzione.

L’esempio di associazione tardiva è metodi sovrascritti che vengono chiamati utilizzando l’object della class base.

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

Esempio di sovraccarico

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

In altre parole, “Molte forms di un singolo object si chiamano Polymorphism.”

Per esempio:

Un caposquadra si comporta come sub ordinata. Un caposquadra si comporta con i suoi anziani. Un caposquadra si comporta con gli altri capigruppo.

Qui Team Leader è un object ma l’atteggiamento è diverso nelle diverse situazioni.

Differenza tra metodo Overriding e Method hiding

L’override del metodo consente a una sottoclass di fornire un’implementazione specifica di un metodo che è già fornito dalla class base. L’implementazione nella sottoclass sovrascrive (sostituisce) l’implementazione nella class base. La cosa importante da ricordare sull’override è che il metodo che esegue l’override è correlato al metodo nella class base. Quando un metodo virtuale viene chiamato su un riferimento, viene utilizzato il tipo effettivo dell’object a cui fa riferimento il riferimento per determinare quale implementazione del metodo deve essere utilizzata. Quando un metodo di una class base viene sovrascritto in una class derivata (sottoclass), viene utilizzata la versione definita nella class derivata. Questo è così anche se l’applicazione chiamante non è consapevole del fatto che l’object è un’istanza della class derivata.

Il metodo hiding non ha una relazione tra i metodi nella class base e la class derivata. Il metodo nella class derivata nasconde il metodo nella class base.

polimorfismo del tempo di compilazione

Supponiamo che diciamo di avere 2 metodi come segue; poiché il metodo condivide lo stesso nome ma ha parametri diversi; è chiamato come metodo “sovraccarico”. Mangiare (cibo per archi); Mangiare (string cibo, stringa SpoonOrFork);

e tu stai usando così nel tuo corso serale

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

Ora, quando si compila questo programma, il compilatore sa esattamente quale versione del metodo Eat richiamare durante la compilazione stessa (a causa della differenza nei parametri).

Ecco perché è chiamato polimorfismo del tempo di compilazione.

Polimorfismo run time

 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" } } 

Nel codice precedente x è di tipo scimpanzé . Anche se il compilatore pensa che chiamerà il metodo walk nello scimpanzè; ma non è quello che succede realmente . Poiché dipende da CLR (tempo di esecuzione) questo tipo di polimorfismo è chiamato polimorfismo “run-time”.

Polimorfismo

Polimorfismo significa molte forms (capacità di assumere più di una forma). In Polymorphism poly significa “multiplo” e metamorfosi significa “forms”, quindi il polimorfismo significa molte forms.

Nel polimorfismo dichiareremo metodi con lo stesso nome e parametri diversi nella stessa class o metodi con lo stesso nome e gli stessi parametri in classi diverse. Il polimorfismo ha la capacità di fornire differenti implementazioni di metodi implementati con lo stesso nome.

In Polymorphism abbiamo 2 tipi diversi che sono

  - Compile Time Polymorphism (Called as Early Binding or Overloading or static binding) - Run Time Polymorphism (Called as Late Binding or Overriding or dynamic binding) 

Compilare il tempo polimorfismo

Il polimorfismo del tempo di compilazione significa che dichiareremo metodi con lo stesso nome ma firme diverse, per questo eseguiremo compiti diversi con lo stesso nome di metodo. Questo polimorfismo del tempo di compilazione viene anche definito come associazione anticipata o sovraccarico del metodo.

Metodo Sovraccarico o polimorfismo del tempo di compilazione indica gli stessi nomi dei metodi con diverse firme (diversi parametri)

Per maggiori dettagli controlla questo polimorfismo del link in c #

Run Time Polymorphism

Polimorfismo run time chiamato anche come late binding o metodo overriding o dynamic polymorphism. Il polimorfismo run time o override del metodo indica lo stesso nome di metodo con le stesse firme.

In questo polimorfismo o metodo che esegue l’override di questo metodo, è ansible sovrascrivere un metodo nella class base creando una funzione simile nella class derivata che può essere ottenuta utilizzando il principio di ereditarietà e utilizzando le parole chiave “virtuale e override”.

Si chiama polimorfismo runtime perché il comportamento è deciso in fase di runtime, non in fase di compilazione.

Quando chiamate un metodo come objectVariable.Method (), il metodo che la vostra macchina chiamerà dipenderà da quale istanza di class è presente nell’objectVariable e da quello deciso dopo aver assegnato un’istanza della class ad esso. Ciò avverrà in fase di esecuzione e non in fase di compilazione. E da qui il nome “runtime polymorphism”.

Puoi leggere di più su: Qual è la differenza tra il tempo di compilazione e il polimorfismo di runtime

Esempio di polimorfismo in fase di esecuzione in 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 ab; } } 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; } } 

Perché è noto al momento della compilazione quale delle tue funzioni sovraccariche viene chiamata, ma non è sempre il caso di una funzione sovrascritta.

Esempi classici di polimorfismo statico si basano sulla metaprogrammazione del modello o Duck Typing, ma non sul sovraccarico del metodo.

Il polimorfismo statico significa che la desicion è fatta dal compilier (staticamente), e il polimorfismo dinamico significa che la desition è fatta solo in runtime (dynamicmente).

Compilare il tempo Polymorphism

Tempo di compilazione Il polimorfismo è anche noto come sovraccarico del metodo. Sovraccarico del metodo significa avere due o più metodi con lo stesso nome ma con diverse firme.

Polimorfismo a tempo di esecuzione

Tempo di esecuzione Il polimorfismo è anche noto come metodo prioritario. L’override del metodo significa avere due o più metodi con lo stesso nome e la stessa firma, ma con un’implementazione diversa