Översikt över överbelastning i C #
Vid överbelastning i C # är Polymorphism ett begrepp med objektorienterad programmering som definierar förmågan hos ett objekt, en variabel eller en metod att anta flera former under kompilering / körningstid. Faktum i realtid som data, parametrar, returnera ett objekt etc. bestämmer vilken form objektet / metoden / variabeln kommer att ta. Detta gör att programmeraren kan koda mer generiskt snarare än specifikt. Till exempel äter du frukt. Hur du äter frukt beror på frukt som tillhandahålls i realtid. Du äter ett äpple direkt medan du skalar en banan innan du äter. Enkel.
Vad är metodöverbelastning i C #?
Metodöverbelastning är kompileringstidens implementering av begreppet polymorfism. Utvecklare kan definiera liknande metoder med samma namn, avvikande antingen i antalet argument, ordningsordning eller typ av argument. I exemplet med frukter behöver du inte definiera separata metoder för varje frukt (eatApple, ät banan, etc.). Du kan använda samma namn för att äta frukt och skicka olika parametrar till den. Kompilatorn kommer automatiskt att anropa lämplig metod.
Låt oss ta perspektivet på C # nu. På de mest enkla termerna är metodöverbelastning i C # när du har två eller flera metoder med samma namn men olika signaturer. Detta kan uppnås på olika sätt:
- Det olika antalet parametrar.
- Olika typer av parametrar.
- Olika parametrar.
- Valfria parametrar.
- Namngivna argument.
Hur fungerar metodöverbelastning i C #?
Så, hur kallas lämplig metod baserat på argumenten / parametrarna? Tja, kompilatorn kontrollerar för varje metoddefinition under sammanställningen och binder metodsamtal till respektive definitioner. Om det finns två metoder med samma namn, kontrollerar kompilatorn sedan metodernas signatur och binder rätt definition till samtalet. Även om signaturerna inte kan lösa tvetydigheten letar kompilatorn efter implicit konvertering av argument för att matcha signaturerna. Om en implicit konvertering resulterar i en signaturmatchning görs bindningen. Om inte genererar kompilatorn ett fel.
Vi ska titta på olika exempel i hela denna artikel för att förstå hur kompilatorn fungerar i olika typer av överbelastning av metoder.
Typer av metodöverbelastning i C #
Här diskuterar vi de olika typerna av överbelastning av metoder i C # nedan:
1. Olika antal parametrar
Den första och enklaste kategorin av metodöverbelastning är när metoderna har ett annat antal parametrar i sina signaturer.
Koda
Exemplet nedan är ganska rak och är en no-brainer.
using System;
public class Program
(
public static void Main()
(
Func(10);)
public static void Func(int a)
(
Console.WriteLine("Single Parameter");
)public static void Func(int a, int b)
(
Console.WriteLine("Multiple Parameters");
)
)
Produktion:
2. Olika typer av parametrar
När metodsignaturerna har en parameter som skiljer sig åt i olika typer. Antalet parametrar kan vara eller inte vara detsamma.
Exempel 1
I exemplet nedan förväntar sig båda metoderna ett enda argument. Så, baserat på typen av argument som skickades under metodsamtalet, binder kompilatorn rätt metoddefinition.
Koda
using System;
public class Program
(
public static void Main()
(
Func("Hello World");
)
public static void Func(int a)
(
Console.WriteLine("Integer Parameter");
)
public static void Func(string b)
(Console.WriteLine("String Parameter");
)
)
Produktion:
Exempel 2
Låt oss nu ge kompilatorn något att tänka på. Vi skulle överbelasta en dubbel- och en flytmetod. Vi vet att ett heltal alltid implicit kan konverteras till en flottörtyp och en dubbeltyp.
När vi passerar ett heltalargument kontrollerar kompilatorn efter implicit konvertering och finner att den bästa möjliga konverteringen är ett heltal att flyta. Därför kallas flytmetoden.
Koda
using System;
public class Program
(
public static void Main()
(
Func(10);
)
public static void Func(double a)
(
Console.WriteLine("Double Parameter");
)
public static void Func(float b)
(
Console.WriteLine("Floating Point Parameter");
)
)
Produktion:
3. Olika parametrar
När antalet och typen av argument är desamma, men i vilken ordning de skickas olika.
Exempel 1
Exemplet nedan är ganska rak.
Koda
using System;
public class Program
(
public static void Main()
(
Func(10, 0.1);
)
public static void Func(int a, double b)
(
Console.WriteLine("Int-Double Parameters");
)
public static void Func(double a, int b)
(
Console.WriteLine("Double-Int Parameter");
)
)
Produktion:
Exempel 2
Vad skulle hända när vi passerar två heltalargument i exemplet ovan? Låt oss ta reda på.
Koda
Func(10, 1);
Produktion:
4. Valfria parametrar
När vi definierar en valfri parameter i metodsignaturen behandlar kompilatorn den som metodöverbelastning.
Obs: Detta har företräde framför Implicit konvertering.
Låt oss förstå detta med ett exempel.
Exempel
I exemplet nedan ger vi kompilatorn två val. Antingen kan det implicit konvertera argumentet så att det matchar metodsignaturen. Eller så kan det passera standardvärdet för det valfria argumentet. Kompilatorn föredrar det senare tillvägagångssättet.
Koda
using System;
public class Program
(
public static void Main()
(
Func(10);
)
public static void Func(int a, int b = 1)
(
Console.WriteLine("Int-Int Parameters");
)
public static void Func(double a)
(
Console.WriteLine("Double Parameter");
)
)
Produktion:
5. Namngivna argument
C # har en annan funktion för att lämna in namnet på argumenten medan du kallar metoden. Detta hjälper också till överbelastning av metoden. Utvecklare kan välja att anropa en viss metod även om det valda argumentet som standard skulle ha kallat en annan metod. Även om de överbelastade metoderna måste skilja sig åt i signaturen.
Exempel
I exemplet nedan instruerar vi kompilatorn att anropa en viss metod genom att lämna parameterns namn. Kompilatorn avbryter sedan sin logik för att bestämma den bäst lämpade metoden.
Koda
using System;
public class Program
(
public static void Main()
(
Func(b: 10);
)
public static void Func(int a)
(
Console.WriteLine("Int-Int Parameters");
)
public static void Func(double b)
(
Console.WriteLine("Double Parameter");
)
)
Produktion:
Regler för överbelastning av metoden i C #
Följande regler måste ha i åtanke när du överbelastar metoder i din C # -applikation.
- Metodsignaturen måste vara annorlunda. Antingen antalet argument, typ av argument eller ordning av argument måste vara annorlunda.
- Metodens returtyp spelar ingen roll i metodens överbelastning.
- Valfria parametrar har företräde framför Implicit typkonvertering när man bestämmer vilken metoddefinition att binda.
- Implicit typkonvertering har företräde framför moderklassmetoden.
Motion - För att förstå detta, här är en liten övning för dig. Skapa en förälderklass med en metod som förväntar sig att ett heltal ärver en barnklass. Överbelasta metoden från förälderklassen i barnklassen så att metod för barnklass förväntar sig ett argument av dubbel typ. Skapa ett objekt i barnklass och ring den överbelastade metoden som passerar ett heltal. Se vad som händer.
Slutsats
Metodöverbelastning är ett ganska kraftfullt koncept. Det är till stor hjälp när du skriver elegant kod. Ändå kan det gå i en utsträckning när tiotals metoder är överbelastade, och utvecklaren måste hänvisa till metoddefinitionerna medan de felsöker felaktiga samtal. För att undvika detta föreslås det ofta att namnge dina metoder på olika sätt när överbelastning tenderar att skala till en högre nivå.
Rekommenderade artiklar
Detta är en guide till överbelastning i C #. Här diskuterar vi dess metod, hur fungerar den, typer med exempel och regler. Du kan också gå igenom våra andra föreslagna artiklar för att lära dig mer -
- C # medan slingan
- C # om uttalande
- C # funktioner
- Användningar av C #
- Guide till överbelastning i C ++
- Överbelastning i Java
- Python överbelastning
- Överbelastning och överbestyrning i C #
- Skriv konvertering i Java med typer och exempel