Áttekintés a túlterhelésről C # -ben
A C # túlterhelésnél a polimorfizmus az objektum-orientált programozás fogalma, amely meghatározza egy objektum, egy változó vagy egy módszer képességét arra, hogy több formát vállaljon az fordítási / futási idő alatt. A valós idejű tényezők, például adatok, paraméterek, objektum visszaadása stb. Határozzák meg, hogy az objektum / módszer / változó milyen formát fog venni. Ez lehetővé teszi a programozó számára, hogy inkább általános, mint specifikus kódolást végezzen. Pl. Gyümölcsöt eszik. Az, hogy hogyan eszik gyümölcsöt, attól függ, hogy milyen gyümölcsöt valós időben kapsz az Ön számára. Azonnal megesz egy almát, miközben étkezés előtt meghámoz egy banánt. Egyszerű.
Mi az a módszer túlterhelése a C # -ben?
A módszer a túlterhelés a polimorfizmus fogalmának fordítási idejű megvalósítása. A fejlesztők meghatározhatnak hasonló módszereket ugyanazon a néven, különbözhetnek az érvek számában, az érvek sorrendjében vagy az érvek típusában. A gyümölcsök példájában nem kell különféle módszereket meghatároznia az egyes gyümölcsök számára (eatApple, megeszi a banánt stb.). Ugyanazt a nevet használhatja gyümölcs fogyasztására és különböző paraméterek átadására is. A fordító automatikusan meghívja a megfelelő módszert.
Nézzük most a C # perspektíváját. A legegyszerűbben a C # módszerterhelés az, ha két vagy több módszer van azonos névvel, de különböző aláírásokkal. Ezt többféle módon lehet elérni:
- A paraméterek különböző száma.
- Különböző típusú paraméterek.
- A paraméterek eltérő sorrendje.
- Opcionális paraméterek.
- Nevezett érvek.
Hogyan működik a módszer túlterhelése a C # -ben?
Szóval, hogyan hívják fel a megfelelő módszert az argumentumok / paraméterek alapján? Nos, a fordító ellenőrzi az egyes metódusdefiníciókat a fordítás során, és összekapcsolja a metódushívásokat a megfelelő definíciókkal. Ha két azonos nevû módszer létezik, akkor a fordító ellenõrzi a metódusok aláírását, és a híváshoz megfelelõ definíciót köt. Még ha az aláírások sem tudják megoldani a kétértelműséget, a fordító az érvek hallgatólagos átalakítását keresi az aláírásokhoz igazodva. Ha egy implicit konverzió eredményeként aláírás-egyezést eredményez, akkor a kötés megtörténik. Ha nem, a fordító hibát generál.
Megvizsgáljuk a cikk különböző példáit, hogy megértsük a fordító működését a módszer túlterhelésének különféle típusaiban.
Módszertípusok túlterhelése C # -ben
Az alábbiakban bemutatjuk a C # -ben megadott módszer-túlterhelés különféle típusait:
1. Különböző számú paraméter
A módszer túlterhelésének első és legegyszerűbb kategóriája az, amikor a metódusok paramétereinek eltérő száma van az aláírásukban.
Kód
Az alábbi példa meglehetősen egyenes vonalú, és nincs értelme.
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");
)
)
Kimenet:
2. Különböző típusú paraméterek
Ha a metódusaláírásnak paramétere (i) vannak, amelyek típustól különböznek. A paraméterek száma lehet azonos vagy nem.
1. példa
Az alábbi példában mindkét módszer egyetlen érvre számít. Tehát a metódushívás során átadott argumentum típusa alapján a fordító kötelezi a megfelelő metódusdefiníciót.
Kód
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");
)
)
Kimenet:
2. példa
Adjunk valami elgondolást a fordítónak. Túlterhelnénk egy dupla és úszó típusú módszert. Tudjuk, hogy egy egész szám implicit módon átalakítható úszó és kettős típusba.
Egy egész argumentum átadásakor a fordító ellenőrzi az implicit konverziót és megállapítja, hogy a lehető legjobb konvertálás lebegő egész szám. Ezért az úszási módszert nevezzük.
Kód
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");
)
)
Kimenet:
3. A paraméterek eltérő sorrendje
Ha az argumentumok száma és típusa azonos, de az átadási sorrend eltérő.
1. példa
Az alábbi példa nagyon egyenes.
Kód
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");
)
)
Kimenet:
2. példa
Mi történne, ha két egész érvet átadunk a fenti példában? Találjuk ki.
Kód
Func(10, 1);
Kimenet:
4. Opcionális paraméterek
Amikor egy opcionális paramétert definiálunk a metódus aláírásában, akkor a fordító metódus túlterhelésként kezeli.
Megjegyzés: Ez elsőbbséget élvez az implicit konverzióval szemben.
Megértjük ezt egy példával.
Példa
Az alábbi példában a fordítónak két választási lehetőséget adunk. Vagy implicit módon átalakíthatja az argumentumot, hogy megfeleljen a metódus aláírásának. Vagy átadhatja az opcionális argumentum alapértelmezett értékét. A fordító az utóbbi megközelítést részesíti előnyben.
Kód
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");
)
)
Kimenet:
5. Argumentumok
A C # másik tulajdonsága, hogy megadja az argumentumok nevét a metódus meghívása közben. Ez elősegíti a módszer túlterhelését is. A fejlesztők dönthetnek úgy, hogy egy adott módszert meghívnak, még akkor is, ha a továbbított argumentumot alapértelmezés szerint egy másik módszernek nevezik. Ennek ellenére a túlterhelt módszereknek különbözniük kell az aláírásban.
Példa
Az alábbi példában arra utasítjuk a fordítót, hogy hívjon meg egy adott módszert a paraméter nevének átadásával. A fordító ezután felfüggeszti a legmegfelelőbb módszer meghatározásának logikáját.
Kód
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");
)
)
Kimenet:
A módszer túlterhelésének szabályai C # -ben
A C # alkalmazás módszereinek túlterhelésekor szem előtt kell tartani a következő szabályokat.
- A módszer aláírásának különbözõnek kell lennie. Vagy az érvek számának, az érvek típusának vagy az érvek sorrendjének különböznie kell.
- A módszerek visszatérési típusa nem játszik szerepet a módszer túlterhelésében.
- Az opcionális paraméterek elsőbbséget élveznek az implicit típuskonverzióval szemben, amikor eldöntik, melyik módszerdefiníciót kell kötni.
- Az implicit típuskonverzió elsőbbséget élvez a szülő osztály módszerével szemben.
Gyakorlat - Ennek megértéséhez itt van egy kis gyakorlat az Ön számára. Hozzon létre egy szülőosztályt olyan módszerrel, amely várhatóan egy egész szám öröklheti a gyermekosztályt. Töltse túl a módszert a szülőosztályból a gyermek osztályban úgy, hogy a gyermek osztály módszer kettős típusú argumentumot várjon el. Hozzon létre egy gyermekkori objektumot, és hívja meg a túlterhelt módszert egy egész szám megadásával. Meglátjuk mi lesz.
Következtetés
A módszer túlterhelése meglehetősen erős koncepció. Nagyon hasznos az elegáns kód megírásában. Ennek ellenére bizonyos mértékig túlságosan terhelt metódust jelenthet, és a fejlesztőnek hivatkoznia kell a metódusdefiníciókra, miközben hibaelhárítja a hibás hívásokat. Ennek elkerülése érdekében gyakran javasoljuk, hogy más módon nevezze meg a módszereit, ha a túlterhelés magasabb szintre hajlik.
Ajánlott cikkek
Ez egy útmutató a C # túlterheléshez. Itt megvitatjuk annak módszerét, működését, példákat és szabályokat. A további javasolt cikkeken keresztül további információkat is megtudhat -
- C # Míg a hurok
- C # ha nyilatkozat
- C # Funkciók
- A C # felhasználása
- Útmutató a C ++ túlterheléshez
- Túlterhelés a Java-ban
- Python túlterhelés
- Túlterhelés és felülbírálás a C # -ben
- Típuskonverzió Java-ban típusokkal és példákkal