Vad är metodöverbelastning i C #?

När du vill implementera funktionen polymorfism görs det med hjälp av Method Overloading. I en lekman, om vi vill använda en funktion för mer än en form, använder vi metodöverbelastning. Eftersom C # är OOP-baserat språk stöder det fullständigt polymorfism.

En programmerare kan använda en klass flera gånger med samma namn med olika parametrar. Vid användning av polymorfism kan två klasser eller metoder använda samma namn.

Låt oss prata om de olika metoderna för att använda parametrar i klasserna och metoderna för c #.

  1. Vi kan överbelasta metoden baserat på flera passerade parametrar. I metoder bör parametrar ges som argument.
  2. Två metoder kan inte definieras med samma namn med samma typ och ordning på de passerade parametrarna. Det skulle ge dig ett fel.
  3. Även om returtypen inte beaktas av kompilatorn, kan två metoder inte deklareras med samma namn, typ eller signatur.

Vad är användningen av metodöverbelastning?

När du inte vill förklara mer än en metod för en liknande typ av metod för liknande uppgifter som ska utföras och vill använda samma metod på olika sätt. Till exempel, olika ingångar, olika ordning, olika antal ingångar för samma metoder, bör du använda metodöverbelastning.

Låt oss ta ett verkligt exempel. Vi kodar för en räknare där du får kod för summan av räknaren. Alla siffror som anges av användaren ska läggas till varandra och returnera summan av allt inmatat nummer.

Det finns en begränsning. Användare kan inte lägga till fler än tre nummer på en gång.

Så här gör du det enkelt:

  1. Förklara en metod som ska summera alla siffror som passeras i parametrar
  2. Metodöverbelastning skulle göras med antalet passerade parametrar.
  3. Metoden ska returnera summan av alla angivna nummer.

Syntax

Här är syntaxen för överbelastning av metoden.

//declare the parameters in method
public void method1 (parameter1, parameter2)
(
//some statement
)
public void method1(parameter2, parameter1)
(
//some statement to be executed
)
//in main method pass the parameters while declaring these methods
public static void Main(Strings() args)
(
class object=new class();
object.method(2, 3) //value of parameter
object.method(3, 2) //value of parameter by changing the order
)
)

Exempel på överbelastning av metoder

Metodöverbelastning i C # kan göras genom att ändra nedanstående saker.

  1. Du kan ändra antalet parametrar som skickats i metoden
  2. Du kan ändra typen av parametrar som skickats i metoden
  3. Du kan ändra ordningen på parametrar som skickats i metoden.

Om samma typ av signatur och parametrar skickas på samma metod, kommer det att ge dig ett sammanställningsfel. Signaturen bör vara annorlunda om du använder funktionen polymorfism eller försöker överbelasta en metod i C #

Låt oss ta ett exempel på var och en.

1. Ändra antalet parametrar

using System;
public class methodOverloadfirst
(
//declaring two integers x and y.
public int sum(int x, int y)
(
int result=x+y;
return result;
)
//Let's add three integers in same method
public int sum(int x, int y, int z)
(
int result=x+y+z;
return result;
)
//Declare main method
public static void Main(String() args)
(
methodOverloadfirst obj=new methodOverloadfirst();
int result1=obj.sum(2, 3);
Console.WriteLine("The Sum of the two integer value is : " + result1);
int result2=obj.sum(2, 3, 4);
Console.WriteLine("The Sum of the three integer value is : " + result2);
)
)

Produktion:

2. Ändra parametrarnas datatyper

// Vårt program för att visa funktionen för metodöverbelastning
// Vi kommer att ändra parametertypen här.

using System;
public class methodOverloadfirst
(
//declaring two integers x and y.
public int sum(int x, int y)
(
int result=x+y;
return result;
)
//Let's add three doubles in same method
public double sum(double x, double y, double z)
(
double result=x+y+z;
return result;
)
//Declare main method
public static void Main(String() args)
(
methodOverloadfirst obj=new methodOverloadfirst();
int result1=obj.sum(2, 3);
Console.WriteLine("The Sum of the two integer value is : " + result1);
double result2=obj.sum(2.1, 3.2, 4.5);
Console.WriteLine("The Sum of the three double value is : " + result2);
)
)

Produktion:

3. Ändra parametrarnas datatyper.

// Vårt program för att visa funktionen för metodöverbelastning
// Vi kommer att ändra parametertypen här.

using System;
class methodOverloadfirst
(
//declaring one integer and one String
public void displayinfo(string fname, int empID)(
Console.WriteLine("Your name is: " + fname + ", " + "Your Employee ID is: " + empID);
)
//Let's change the order of the parameters
public void displayinfo(int empID, string fname)
(
Console.WriteLine("Your Employee ID is: " + empID + ", " + "Your name is: " + fname);
)
//Declare main method
public static void Main(String() args)
(
methodOverloadfirst obj=new methodOverloadfirst();
obj.displayinfo("Kumar", 121);
obj.displayinfo("Anand", 123);
)
)

Produktion:

Slutsats

Metodöverbelastning är en fantastisk funktion i OOP-baserade koncept och kan spara dig från mycket krångel om du är programmerare. Metodöverbelastning är en av polymorfismens funktioner. Om den används korrekt kan det hindra dig från att deklarera mer än en metod och förklara den varje gång för en liknande uppgift.

När du använder den här funktionen är det typ av signatur. Detta bör vara annorlunda varje gång metoden används antingen av flera parametrar och ordning efter parametrar eller per typ av parametrar som visas ovan i exemplen.

Rekommenderade artiklar

Detta är en guide till överbelastning av metoder i C #. Här diskuterar vi användningen av metodöverbelastning med exemplen och utgångarna. Du kan också titta på följande artikel för att lära dig mer-

  1. Destruktor i C #
  2. Överbelastning i C #
  3. C # Compilers
  4. C # ELLER Operatör
  5. Polymorfism i Java
  6. Överbelastning i Java
  7. C ++ Datatyper
  8. Python överbelastning
  9. Överbelastning och överbestyrning i C #
  10. Destructor i PHP | exempel

Kategori:

Mjukvaruutveckling