Introduzione al polimorfismo in C #
Il polimorfismo è uno dei principi della programmazione orientata agli oggetti. Poly significa multiplo e morphing significa subire una trasformazione, polimorfismo significa quindi la capacità di assumere forme multiple.
L'output degli operatori varia a seconda dei tipi di operandi, che è una forma di polimorfismo noto come sovraccarico dell'operatore. Qui l'operatore può assumere più forme per produrre output diversi. L'output delle funzioni varia in base a diversi tipi e parametri di ritorno, che è un'altra forma di polimorfismo nota come sovraccarico di funzioni. Qui, la funzione assume più forme per produrre più output.
Il polimorfismo è ampiamente utilizzato per implementare l'ereditarietà. Gli oggetti che hanno una struttura interna diversa possono implementare un'interfaccia comune attraverso il polimorfismo. Il seguente diagramma illustra il funzionamento del polimorfismo:
Questa figura spiega che l'argilla è l'oggetto principale da cui sono fatti gli oggetti vaso, ciotola e giocattolo. Tutti questi oggetti sono diversi l'uno dall'altro ma hanno le proprietà dell'argilla. Questi tre oggetti hanno forme diverse e vengono utilizzati in modi diversi anche quando sono realizzati con lo stesso materiale argilla.
Forme di polimorfismo
Di seguito sono le 2 forme di polimorfismo:
1. Sovraccarico dell'operatore
Un operatore può fornire diverse uscite in base al tipo di operandi su cui sta operando. Questo si chiama sovraccarico dell'operatore. Ad esempio, l'operatore '+' può eseguire l'aggiunta su due numeri interi, mentre può concatenare due stringhe. Pertanto, lo stesso operatore può essere utilizzato in 2 modi diversi. L'operatore addizione aggiunge generalmente due numeri. Tuttavia, nel caso di numeri complessi, l'aggiunta è leggermente diversa, in cui le parti reali corrispondenti e le parti immaginarie vengono aggiunte separatamente. Ecco un codice di esempio che mostra come l'operatore '+' può essere sovraccaricato per aggiungere numeri complessi:
Codice:
using System;
namespace Overload (
class Complex
(
public double x;
public double y;
// no-argument constructor
public Complex() ()
// parameterized constructor
public Complex(double real, double img)
(
x = real;
y = img;
)
// Overloading of Binary "+" operator
public static Complex operator + (Complex c1,
Complex c2)
(
Complex c3 = new Complex();
c3.x = c1.x + c2.x;
c3.y = c1.y + c2.y;
return c3;
)
// function to display result
public void display()
(
Console.WriteLine("(0) + (1)i", x, y);
)
)
class CalNum (
// Driver Code
static void Main(string() args)
(
Complex num1 = new Complex(2.5, 3.5);
Complex num2 = new Complex(1.2, 6.5);
Complex num3 = num1 + num2;
Console.Write("c1 = ");
num1.display();
Console.Write("c2 = ");
num2.display();
Console.Write("c3 = ");
num3.display();
)
)
)
Produzione:
Questa uscita illustra il sovraccarico dell'operatore per aggiungere due numeri complessi. Il codice mostra il sovraccarico dell'operatore e il sovraccarico della funzione.
2. Funzione di sovraccarico
Una funzione può fornire output diversi in base al numero di parametri, ai relativi tipi di ritorno e al tipo di ritorno della funzione. Il codice sopra menzionato copre anche il sovraccarico delle funzioni usando un costruttore. Ci sono 2 costruttori nel codice; uno è il costruttore predefinito che viene lasciato vuoto mentre l'altro è un costruttore parametrizzato che viene utilizzato per inizializzare il numero complesso con i valori indicati come parametri.
Prendendo l'esempio illustrato nella figura, la funzione sta modellando l'argilla e la direzione della corsa è l'elemento fornito per modellare l'argilla. Sulla base di diverse direzioni della corsa, l'argilla viene trasformata rispettivamente nella pentola, nella ciotola e nel giocattolo.
Codice:
using System;
using System.Collections.Generic;
public class Clay
(
// A few example members
public int Height ( get; set; )
public int strokeDirection ( get; set; )
// Virtual method
public virtual void Mould()
(
Console.WriteLine("Beginning to mould the clay");
)
)
class Pot : Clay
(
public override void Mould()
(
// Code to make a pot Console.WriteLine("Making a pot");
base.Mould();
)
)
class Bowl : Clay
(
public override void Mould()
(
// Code to make a bowl
Console.WriteLine("Making a bowl");
base.Mould();
)
)
class Toy : Clay
(
public override void Mould()
(
// Code to make a toy
Console.WriteLine("Making a toy");
base.Mould();
)
)
class Program
(
static void Main(string() args)
(
// Illustrating Polymorphism #1: a Pot, Bowl and Toy
// can all be used wherever Clay is expected. No cast is
// needed because an implicit conversion exists from a derived
// class to its base class.
var items = new List
(
new Pot(),
new Bowl(),
new Toy()
);
// Polymorphism at work #2: the virtual method Mould is
// invoked on each of the derived classes, not the base class.
foreach (var item in items)
(
item.Mould();
)
)
)
Produzione:
Come avrai notato nel codice, la classe clay è la classe genitore le cui classi figlio sono classi pot, toy e bowl. Il metodo 'Mold' è definito nella classe genitore e nella classe figlio con la stessa firma della funzione. Quindi, quando viene creato un oggetto della classe figlio e chiama il metodo Mold, il metodo della classe base viene sovrascritto dal metodo della classe figlio. Quindi, vediamo l'output del metodo di classe figlio. Il codice sopra mostra l'override del metodo e non il sovraccarico per illustrare il polimorfismo.
Punti da tenere a mente per il polimorfismo in c #
- Il sovraccarico è diverso dall'override. Il sovraccarico ha firme di funzioni diverse mentre l'override ha le stesse firme di funzione
- Il polimorfismo si riferisce al cambiamento del comportamento di una superclasse nella sottoclasse.
- L'ereditarietà si riferisce all'utilizzo della struttura e del comportamento di una superclasse in una sottoclasse.
Di seguito sono riportati i pochi punti chiave da asporto:
- Il polimorfismo è uno dei principali paradigmi della programmazione orientata agli oggetti.
- Il sovraccarico della funzione modifica la funzione secondo i tipi e i parametri di ritorno della funzione nella classe ereditata.
- Il sovraccarico dell'operatore modifica la definizione dell'operatore in base a determinati parametri.
- Il polimorfismo viene utilizzato per implementare decide in fase di esecuzione di chiamare il metodo di classe figlio utilizzando il metodo di sostituzione.
Articoli consigliati
Questa è una guida al polimorfismo in C #. Qui discutiamo le due forme di polimorfismo in C #, ovvero il sovraccarico dell'operatore e il sovraccarico delle funzioni con codice di esempio. Puoi anche leggere il seguente articolo per saperne di più -
- Cosa è StringBuilder in C #
- Copia costruttore in C #
- Che cos'è il multithreading in C #?
- Cos'è Design Pattern in C #?
- Tipi di costruttore in C # con implementazione del codice
- Guida completa al multithreading in C #