Come usare il polimorfismo in C#
Sommario
- Cos'è il polimorfismo in c#
- Tipi di polimorfismo in C#
- Metodo sovraccarico
- Metodo prevalente
- Esempi di polimorfismo in C#
- Come usare il polimorfismo in C#
- Conclusione
Cos'è il polimorfismo in c#
Il polimorfismo proviene da due parole greche: poli E Morph. La parola poli Qui sta per molti, e Morph sta per le forme. È la capacità dell'oggetto nella programmazione di acquisire forme diverse.
Il polimorfismo consente di trattare oggetti di classi distinte come provenivano dalla stessa classe. Questo può essere fatto usando il concetto di eredità, in quanto consente alle classi derivate di prendere o ereditare le proprietà della classe base.
Tipi di polimorfismo in C#
Il polimorfismo può essere classificato in due tipi in base a quando si verifica:
- Compile Time [Method Overloading]
- Runtime [Metodo Prevalente]
Metodo sovraccarico
Il sovraccarico del metodo può definire più metodi con lo stesso nome ma contenere parametri diversi. Il compilatore decide il metodo che verrà chiamato in base agli argomenti forniti al metodo. Usando il sovraccarico del metodo, possiamo svolgere attività simili ma hanno parametri di input diversi.
Metodo prevalente
Metodo Prevalere in C# è una tecnica che consente a una classe derivata di fornire la propria implementazione di un metodo già fornito dalla sua classe di base. Il metodo prevalente è proprio come la funzione virtuale di c++. Quando un metodo in una classe derivata ha lo stesso nome, lo stesso tipo di ritorno e gli stessi parametri di un metodo nella sua classe base, si dice che il metodo nella classe derivata sovrascrive il metodo nella classe base.
Nel polimorfismo, il metodo di base sovrascritto dovrebbe essere virtuale, astratto o sovraccarico. I metodi di sovraccarico implementano i membri della classe base esistenti in un modo nuovo. Il metodo di prevalenza si ottiene utilizzando le parole chiave virtuali e sovraccarichi.
Esempi di polimorfismo in C#
Di seguito è riportato un codice di esempio che spiega entrambi i metodi prevalere e sovraccarico in C#:
Esempio 1: sovraccarico del metodo
Qui, nell'esempio seguente, abbiamo definito più metodi in una singola classe. Tutti questi metodi condividono lo stesso nome ma contengono parametri diversi.
usando il sistema;Programma di classe
void calculatesum (int num1, int num2)
Console.WriteLine ($ "La somma di num1 e num2 è num1 + num2");
void calculatesum (doppio num1, doppio num2)
Console.WriteLine ($ "La somma di num1 e num2 è num1 + num2");
statico void main (string [] args)
Programma programma = nuovo programma ();
int intnum1 = 1;
int intnum2 = 2;
Double Doublelenum1 = 12.5;
Double Doublelenum2 = 7.5;
programma.Calculatesum (intnum1, intnum2);
programma.Calculatesum (Doublelenum1, Doublelenum2);
Il codice sopra fornisce due numeri da sommare e dimostra Metodo sovraccarico in c#. IL Calculatesum Il metodo è sovraccarico per accettare due parametri interi e due doppi parametri, rispettivamente.
Il metodo principale crea un'istanza della classe del programma e chiama il metodo Calculatesum due volte, una volta con due argomenti interi e una volta con due doppi argomenti.
Quando il programma è eseguito, stampare la somma dei due numeri passati al Calculatesum Metodo usando l'interpolazione della stringa per creare il messaggio di output. Il seguente output può essere visto sulla console:
Esempio 2: metodo prevalente
Questo esempio dimostra il concetto di metodo prevalente, in cui una classe derivata può fornire la propria implementazione di un metodo ereditato dalla sua classe base.
usando il sistema;forma di classe pubblica
Public Virtual Void Draw ()
Console.WriteLine ("disegnare una forma");
Rettangolo di classe pubblica: forma
PUBBLICA OVERRIDE void Draw ()
Console.WriteLine ("Disegnare un rettangolo");
Programma di classe pubblica
public static void main (string [] args)
Forma forma = nuovo forma ();
forma.Disegno();
Rettangolo rettangolo = nuovo rettangolo ();
rettangolo.Disegno();
Ecco una classe di base che si chiama Classe di forma. La classe di forma contiene un metodo virtuale chiamato Disegno. Qui, una parola chiave virtuale è un'indicazione che una classe derivata può sovrascrivere il metodo definito.
La classe rettangolare sovrascrive il file Disegno metodo ed è derivato dalla classe di forma. La classe rettangolare ha il proprio set di proprietà per l'implementazione. In questo caso, il metodo di disegno delle stampe di classe rettangolare Disegnare un rettangolo invece di Disegnare una forma.
Successivamente, in Principale(), Viene creata un'istanza della classe di forma e il suo metodo di disegno è chiamato. Quindi viene creata un'istanza della classe rettangolare e il suo metodo di disegno viene chiamato.
Poiché la classe rettangolare sovrascrive il metodo di disegno della classe di forma, quando chiamiamo il metodo di disegno sull'oggetto rettangolo, viene chiamata l'implementazione della classe rettangolare e Disegnare un rettangolo è stampato sulla console. Quando il programma è eseguito, emetterà:
Come usare il polimorfismo in C#
Dopo aver conosciuto il concetto di polimorfismo in C#, ora tratteremo i passaggi per usarlo nella programmazione C#.
Passaggio 1: definire la classe di base
Il primo passo è definire la classe base che contiene i metodi o le proprietà che saranno condivise da tutte le classi derivate. La classe base è definita usando il classe parola chiave:
animale di classe pubblicail vuoto virtuale pubblico makeound ()
Console.WriteLine ("L'animale fa un suono");
Il codice sopra contiene una classe di base Animale Questo ha un metodo virtuale Makeound. La parola chiave virtuale mostra che la classe derivata sovrascriverà il metodo definito.
Passaggio 2: definire le classi derivate
Il prossimo passo è definire le classi derivate che provengono dalla classe base. In C#, possiamo definire una classe derivata usando il ":" operatore.
cane di classe pubblica: animalePublic Override void Makeound ()
Console.WriteLine ("The Dog Barks");
gatto di classe pubblica: animale
Public Override void Makeound ()
Console.WriteLine ("The Cat Meows");
L'esempio sopra contiene due classi di unità Cane E Gatto, ed entrambe queste classi prendono proprietà dalla classe di base che si chiama animale. Entrambe le classi sovrascrivono il file Makeound Metodo con la loro implementazione.
Passaggio 3: usa il polimorfismo
Il passaggio finale è usare il polimorfismo nel codice. Ora definiremo istanze delle classi derivate e chiameremo i loro metodi usando il riferimento della classe base.
Animale myanimal = new animale ();Animale mydog = new dog ();
Animale mycat = new cat ();
Myanimal.Makeound ();
il mio cane.Makeound ();
il mio gatto.Makeound ();
Qui abbiamo creato istanze delle classi di animali, cani e gatti. Dopodiché, il Makeound Il metodo è chiamato su ogni istanza. Dal Makeound Il metodo è virtuale, l'implementazione effettiva che viene chiamata dipende dal tipo effettivo dell'istanza. Ciò significa che quando chiamiamo mydog.Makeound () o mycat.Makeound (), il Makeound Il metodo verrà chiamato rispettivamente nella classe di cane o gatto.
Codice di esempio
Di seguito è riportato il codice combinato dei passaggi sopra spiegati:
usando il sistema;animale di classe pubblica
il vuoto virtuale pubblico makeound ()
Console.WriteLine ("L'animale fa un suono");
cane di classe pubblica: animale
Public Override void Makeound ()
Console.WriteLine ("The Dog Barks");
gatto di classe pubblica: animale
Public Override void Makeound ()
Console.WriteLine ("The Cat Meows");
Programma di classe pubblica
Public Static Void Main ()
Animale myanimal = new animale ();
Animale mydog = new dog ();
Animale mycat = new cat ();
Myanimal.Makeound ();
il mio cane.Makeound ();
il mio gatto.Makeound ();
Dopo aver eseguito il codice sopra, la seguente output può essere visualizzata sulla console:
Conclusione
L'uso del polimorfismo in C# A Codice può essere scritto che gestisce più tipi di oggetti. In C#, possiamo usare il polimorfismo definendo una classe di base, creando classi derivate che ereditano dalla classe base e usando il riferimento della classe base per chiamare i metodi delle classi derivate. Seguendo i passaggi descritti nell'articolo sopra, chiunque può utilizzare il concetto di polimorfismo in C#.