Introduzione al sovraccarico e override in C #
Il polimorfismo è uno dei concetti importanti in C #. Esistono due tipi di polimorfismo, tempo di compilazione e tempo di esecuzione. I concetti di sovraccarico e override vengono utilizzati per raggiungere questo obiettivo rispettivamente. Nel sovrascrivere, una classe figlio può implementare il metodo della classe genitore in un modo diverso ma il metodo della classe figlio ha lo stesso nome e la stessa firma del metodo del genitore mentre nel sovraccarico ci sono più metodi in una classe con lo stesso nome e parametri diversi.
Come funziona l'override e il sovraccarico in C #?
Le operazioni di override e overload in C # sono spiegate di seguito con esempi:
Override
Ci sono alcune parole chiave che usiamo per eseguire l'override come virtuale, override e base.
Sintassi:
class Parent
(
public virtual void Example() // base class
(
Console.WriteLine(“ parent class”);
)
)
class Child: Parent
(
public override void Example() // derived class
(
base.Example();
Console.WriteLine(“Child class”);
)
)
In questo, vengono utilizzate parole chiave virtuali e di override, il che significa che la classe di base è virtuale e la classe child può implementare questa classe e override significa che questa classe child ha lo stesso nome e la stessa firma del metodo della classe parent.
Esempio 1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverridingExample
(
class Subject // base class
(
public virtual void study() // base class method
(
Console.WriteLine("Study all the subjects");
)
)
class Mathematics: Subject // derived class
(
public override void study() // derived class method
(
Console.WriteLine("Study Mathematics");
)
)
class Program
(
// main method
static void Main(string() args)
(
Subject s = new Mathematics();
s.study();
Console.ReadLine();
)
)
)
Nell'esempio sopra, il nome dei metodi è lo stesso ma la loro implementazione è diversa. La classe base ha virtuale e grazie a quella classe figlio può implementare il metodo della classe genitore a modo suo. Il metodo di classe figlio ha l'override di parole chiave che mostra che questo metodo è un metodo di override.
Produzione:
Esempio n. 2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverridingExample
(
class Subject // base class
(
public virtual void study() // base class method
(
Console.WriteLine("Study all the subjects");
)
)
class Mathematics: Subject // derived class
(
public override void study() // derived class method
(
base.study();
Console.WriteLine("Study Mathematics");
)
)
class Program
(
// main method
static void Main(string() args)
(
Mathematics m = new Mathematics();
m.study();
Console.ReadLine();
)
)
)
Produzione:
In questo esempio, la classe derivata ha una parola chiave base che viene utilizzata per chiamare il metodo della classe base. Quindi, in quel caso, il metodo derivato viene chiamato dopo il metodo della classe base.
Punti da ricordare:
- Nel concetto prevalente, il nome del metodo, la firma del metodo e il modificatore di accesso sono sempre gli stessi della classe genitore e figlio.
- Il metodo della classe genitore non può essere statico.
Sovraccarico
In sovraccarico, ci sono più metodi con firma del metodo diverso. Di seguito sono riportati alcuni esempi che mostrano come possiamo ottenere un sovraccarico variando il numero di parametri, l'ordine dei parametri e i tipi di dati dei parametri.
Esempio 1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
(
class Demo
(
public int Sum(int x, int y)
(
int value = x + y;
return value;
)
public int Sum(int x, int y, int z)
(
int value = x + y + z;
return value;
)
public static void Main(string() args) // main method
(
Demo d = new Demo();
int sum1 = d.Sum(24, 28);
Console.WriteLine("sum of the two "
+ "integer value : " + sum1);
int sum2 = d.Sum(10, 20, 30);
Console.WriteLine("sum of the three "
+ "integer value : " + sum2);
Console.ReadLine();
)
)
)
Nell'esempio sopra, ci sono due metodi con lo stesso nome ma un numero diverso di parametri. Il primo metodo consiste di due parametri mentre il secondo ha tre parametri. Questo si chiama metodo di sovraccarico.
Produzione:
Esempio n. 2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
(
class Demo
(
public int Sum(int x, int y, int z)
(
int value = x + y + z;
return value;
)
public double Sum(double x, double y, double z)
(
double value = x + y + z;
return value;
)
public static void Main(string() args) // main method
(
Demo d = new Demo();
int sum1 = d.Sum(24, 28, 7);
Console.WriteLine("sum of the two "
+ "integer value : " + sum1);
double sum2 = d.Sum(10.0, 20.0, 30.0);
Console.WriteLine("sum of the three "
+ "integer value : " + sum2);
Console.ReadLine();
)
)
)
Nell'esempio sopra, ci sono due metodi con lo stesso nome ma i loro tipi di dati sono diversi. Il primo metodo ha un tipo di dati intero mentre il secondo ha un doppio tipo di dati. Quindi in questo caso i parametri variano a causa del diverso tipo di dati.
Produzione:
Esempio n. 3
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
(
class Demo
(
public void Details(String name, int id)
(
Console.WriteLine("Name " + name + ", "
+ "Id " + id); ;
)
public void Details(int id, string name)
(
Console.WriteLine("Name " + name + ", "
+ "Id " + id);
)
public static void Main(string() args) // main method
(
Demo d = new Demo();
d.Details("John", 10);
d.Details("Joe", 20);
Console.ReadLine();
)
)
)
Nell'esempio sopra, il nome dei metodi è lo stesso ma l'ordine dei parametri è diverso. Il primo metodo ha un nome e un id resp. mentre il secondo ha rispettivamente id e nome.
Produzione:
Punti da ricordare:
- In un concetto di sovraccarico, non è possibile definire più di un metodo con gli stessi parametri in caso di ordine, tipo e numero.
- Non è possibile sovraccaricare un metodo in base ai diversi tipi di ritorno.
Vantaggi del sovraccarico e dell'override in C #
- Il sovraccarico è uno dei modi per ottenere statico e l'override è uno dei modi in cui C # raggiunge il polimorfismo dinamico.
- Offre flessibilità all'utente e pulizia del codice.
Conclusione
Il sovraccarico e l'override svolgono un ruolo importante nel raggiungimento del polimorfismo. L'override consente alla classe derivata di implementarsi a modo suo e d'altro canto il sovraccarico riguarda metodi con lo stesso nome e vari tipi di implementazioni di parametri.
Articoli consigliati
Questa è una guida per sovraccarico e override in C #. Qui discutiamo del funzionamento, della sintassi, dei vantaggi del sovraccarico e dell'override in C # con esempi e implementazione del codice. Puoi anche consultare i seguenti articoli per saperne di più -
- Oggetti in C #
- Matrici 2D in C #
- Sostituzione in C #
- Scambiare in C #
- Polimorfismo in Java
- Grafica 2D in Java
- 3 diversi tipi di array in PHP (esempi)