Oversikt over overbelastning i C #
I Overbelastning i C # er Polymorphism et begrep med objektorientert programmering som definerer evnen til et objekt, en variabel eller en metode til å anta flere former i løpet av kompilering / kjøretid. Faktumene i sanntid som data, parametere, returnering av et objekt osv. Bestemmer hvilken form objektet / metoden / variabelen har. Dette gjør at programmereren kan kode mer generisk i stedet for spesifikk. Eg spiser frukt. Hvordan du spiser frukt, avhenger av frukten som du får i sanntid. Du spiser et eple med en gang mens du skreller en banan før du spiser. Enkel.
Hva er metodeoverbelastning i C #?
Metode Overbelastning er implementering av kompileringstiden av begrepet Polymorfisme. Utviklere kan definere lignende metoder med samme navn, avvikende enten i antall argumenter, rekkefølge på argumenter eller type argumenter. I eksemplet med frukt trenger du ikke definere separate metoder for hver frukt (eatApple, spis banan, etc.). Du kan bruke samme navn til å spise frukt og sende forskjellige parametere til det. Kompilatoren vil automatisk kalle riktig metode.
La oss ta perspektivet til C # nå. På enkleste måte er metodeoverbelastning i C # når du har to eller flere metoder med samme navn, men forskjellige signaturer. Dette kan oppnås på forskjellige måter:
- Det forskjellige antall parametere.
- Ulike parametertyper.
- Forskjellig rekkefølge av parametere.
- Valgfrie parametere.
- Navngivne argumenter.
Hvordan fungerer metodeoverbelastning i C #?
Så, hvordan kalles passende metode basert på argumenter / parametere? Vel, kompilatoren sjekker etter hver metodedefinisjon under kompilering og binder metodeanropene til respektive definisjoner. I tilfelle det er to metoder med samme navn, kontrollerer kompilatoren deretter signaturen til metodene og binder den riktige definisjonen til samtalen. Selv om signaturene ikke kan løse tvetydigheten, ser kompilatoren etter den implisitte konvertering av argumenter for å matche signaturene. Hvis en implisitt konvertering resulterer i en signaturkamp, blir bindingen gjort. Hvis ikke genererer kompilatoren en feil.
Vi skal se på forskjellige eksempler i hele denne artikkelen for å forstå hvordan kompilatoren fungerer i forskjellige typer metodeoverbelastning.
Typer metodeoverbelastning i C #
Her diskuterer vi de forskjellige typene metodebelastning i C # nedenfor:
1. Ulike antall parametere
Den første og enkleste kategorien med overbelastning av metoder er når metodene har et annet antall parametere i signaturene sine.
Kode
Eksemplet nedenfor er ganske rett frem og er en ikke-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");
)
)
Produksjon:
2. Forskjellig type parametere
Når metodesignaturene har en parameter (er) som er forskjellige i typene. Antall parametere kan være eller ikke være det samme.
Eksempel 1
I eksemplet nedenfor forventer begge metodene et enkelt argument. Så basert på typen argument som ble gitt under metodeanropet, binder kompilatoren den riktige metodedefinisjonen.
Kode
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");
)
)
Produksjon:
Eksempel 2
La oss gi kompilatoren noe å tenke på. Vi ville overbelaste en dobbel og en flytemetode. Vi vet at et helt tall alltid implisitt kan konverteres til en flytetype og en dobbel type.
Når vi passerer et heltallargument, sjekker kompilatoren for implisitt konvertering og finner ut at den best mulige konverteringen er et heltall å flyte. Derfor kalles float-metoden.
Kode
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");
)
)
Produksjon:
3. Forskjellig rekkefølge av parametere
Når antall og type argumenter er de samme, men rekkefølgen de sendes forskjellig.
Eksempel 1
Eksemplet nedenfor er ganske rett frem.
Kode
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");
)
)
Produksjon:
Eksempel 2
Hva ville skje når vi passerer to heltallargumenter i eksemplet over? La oss finne det ut.
Kode
Func(10, 1);
Produksjon:
4. Valgfrie parametere
Når vi definerer en valgfri parameter i metodesignaturen, behandler kompilatoren den som metodeoverbelastning.
Merk: Dette har forrang fremfor implisitt konvertering.
La oss forstå dette med et eksempel.
Eksempel
I eksemplet nedenfor gir vi kompilatoren to valg. Enten kan det implisitt konvertere argumentet slik at det samsvarer med metodesignaturen. Eller det kan passere standardverdien for det valgfrie argumentet. Kompilatoren foretrekker sistnevnte tilnærming.
Kode
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");
)
)
Produksjon:
5. Navngivne argumenter
C # har en annen funksjon ved å gi navnet på argumentene mens du kaller metoden. Dette hjelper i metodeoverbelastning også. Utviklere kan velge å kalle en bestemt metode selv om argumentet som ble gitt, som standard ville ha kalt en annen metode. Skjønt må de overbelastede metodene være forskjellige i signaturen.
Eksempel
I eksemplet nedenfor instruerer vi kompilatoren til å kalle en bestemt metode ved å gi navnet på parameteren. Kompilatoren suspenderer deretter logikken sin for å bestemme den best egnede metoden.
Kode
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");
)
)
Produksjon:
Regler for metodeoverbelastning i C #
Følgende regler må huskes når metodene er overbelastet i C # -programmet.
- Metodesignaturen må være annerledes. Enten må antall argumenter, type argumenter eller rekkefølge av argumenter være forskjellig.
- Returtypen for metodene spiller ingen rolle i overbelastning av metoder.
- Valgfrie parametere har forrang for implisitt konvertering når du bestemmer hvilken metodedefinisjon som skal bindes.
- Implisitt typekonvertering har forrang fremfor foreldreklasse-metoden.
Trening - For å forstå dette, her er en liten øvelse for deg. Lag en foreldreklasse med en metode som forventer at et heltall arver en barneklasse. Overbelast metoden fra foreldreklassen i barneklassen slik at barneklasse-metoden forventer et dobbelt type argument. Lag et objekt av barneklasse og ring den overbelastede metoden som passerer et heltall. Se hva som skjer.
Konklusjon
Overbelastning av metoden er et ganske kraftig konsept. Det er veldig nyttig når du skriver elegant kode. Likevel kan det gå i en grad når titalls metoder er overbelastet, og utvikleren må henvise til metodedefinisjonene mens de feilsøker feilaktige samtaler. For å unngå dette anbefales det ofte å navngi metodene dine på en annen måte når overbelastning har en tendens til å skalere til et høyere nivå.
Anbefalte artikler
Dette er en guide til overbelastning i C #. Her diskuterer vi Metoden, hvordan fungerer den, typer med eksempel og regler. Du kan også gå gjennom andre foreslåtte artikler for å lære mer -
- C # Mens sløyfe
- C # hvis uttalelse
- C # Funksjoner
- Bruk av C #
- Veiledning for overbelastning i C ++
- Overbelastning i Java
- Python-overbelastning
- Overbelastning og overstyring i C #
- Skriv konvertering i Java med typer og eksempler