Преглед на претоварването в C #
При претоварване в C #, полиморфизмът е концепция за обектно-ориентирано програмиране, която определя способността на обект, променлива или метод да приема множество форми по време на компилиране / изпълнение. Факторите в реално време като данни, параметри, връщане на обект и т.н. определят каква форма ще приема обект / метод / променлива. Това позволява на програмиста да кодира по-общо, отколкото специфично. Например, ядете плодове. Как ще ядете плодове зависи от плодовете, които ви се предоставят в реално време. Ядете ябълка веднага, докато обелвате банан преди ядене. Simple.
Какво е претоварване на метод в C #?
Метод Претоварването е време за компилиране на концепцията за полиморфизъм. Разработчиците могат да дефинират подобни методи с едно и също име, като се различават или по броя на аргументите, поредността на аргументите или вида на аргументите. В примера с плодове не е необходимо да дефинирате отделни методи за всеки плод (ядетеApple, яжте банан и т.н.). Можете да използвате едно и също име, за да ядете плод и да му предадете различни параметри. Компилаторът автоматично ще извика подходящия метод.
Нека сега да вземем перспективата на C #. В най-прости думи, методът Overloading в C # е когато имате два или повече метода със същото име, но различни подписи. Това може да се постигне по различни начини:
- Различният брой параметри.
- Различни видове параметри.
- Различен ред на параметрите.
- Незадължителни параметри.
- Наименовани аргументи.
Как работи претоварването на метод в C #?
И така, как се нарича подходящият метод, базиран на аргументите / параметрите? Е, компилаторът проверява за всяка дефиниция на метод по време на компилация и обвързва обажданията на метода със съответните дефиниции. В случай, че има два метода с едно и също име, компилаторът проверява подписа на методите и обвързва съответното определение с повикването. Дори ако подписите не могат да разрешат неяснотата, компилаторът търси неявното преобразуване на аргументи, за да съответства на подписите. Ако неявното преобразуване доведе до съвпадение на подпис, свързването се извършва. Ако не, компилаторът генерира грешка.
Ще разгледаме различни примери в тази статия, за да разберем работата на съставителя в различни видове претоварване на методи.
Видове метод Претоварване в C #
Тук обсъждаме различните видове методи за претоварване в C # са дадени по-долу:
1. Различен брой параметри
Първата и най-простата категория на претоварване на метод е, когато методите имат различен брой параметри в подписите си.
код
Примерът по-долу е доста прав и не може да се използва.
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");
)
)
изход:
2. Различен тип параметри
Когато подписите на метода имат параметър (и), които се различават в типовете. Броят на параметрите може или не може да бъде един и същ.
Пример 1
В примера по-долу и двата метода очакват един аргумент. И така, въз основа на типа на аргумента, предаден по време на извикването на метод, компилаторът обвързва определението на подходящия метод.
код
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");
)
)
изход:
Пример 2
Сега, нека да дадем на компилатора нещо за мислене. Бихме претоварили метод с двоен и поплавък тип. Знаем, че цяло число винаги може да бъде имплицитно преобразувано в тип float, както и в двоен тип.
Когато предаваме целочислен аргумент, компилаторът проверява за неявно преобразуване и установява, че най-доброто възможно преобразуване е цяло число, което да плава. Следователно методът float се нарича.
код
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");
)
)
изход:
3. Различен ред на параметрите
Когато броят и видът на аргументите са еднакви, но редът, в който те се предават, се различава.
Пример 1
Примерът по-долу е доста прав.
код
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");
)
)
изход:
Пример 2
Какво би станало, когато предадем два цели числа в горния пример? Нека разберем.
код
Func(10, 1);
изход:
4. Незадължителни параметри
Когато определим незадължителен параметър в подписа на метода, компилаторът го третира като претоварване на метод.
Забележка: Това има предимство пред имплицитното преобразуване.
Нека разберем това с пример.
пример
В примера по-долу даваме на компилатора два варианта. Или може косвено да преобразува аргумента, за да съответства на подписа на метода. Или може да предаде стойността по подразбиране на незадължителния аргумент. Компилаторът предпочита последния подход.
код
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");
)
)
изход:
5. Именни аргументи
C # има още една функция за предаване на името на аргументите, докато извиква метода. Това помага и при претоварването на методите. Разработчиците могат да изберат да извикат определен метод, дори ако предаваният аргумент по подразбиране би се наричал друг метод. Въпреки това, претоварените методи трябва да се различават в подписа.
пример
В примера по-долу, инструктираме компилатора да извика определен метод, като предаде името на параметъра. След това компилаторът спира логиката си за определяне на най-подходящия метод.
код
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");
)
)
изход:
Правила за претоварване на методи в C #
Следните правила трябва да се имат предвид при претоварване на методите във вашето C # приложение.
- Подписът на метода трябва да е различен. Или броят на аргументите, типът аргумент или редът на аргументите трябва да са различни.
- Типът на връщане на методите не играе никаква роля в претоварването на метода.
- Незадължителните параметри имат предимство пред имплицитното преобразуване на типа, когато решават кое определение на метода да се обвърже.
- Преобразуването на неизразен тип има предимство пред метода на родителския клас.
Упражнение - За да разберете това, ето ви малко упражнение. Създайте родителски клас с метод, който очаква целочислено Наследяване на детски клас. Претоварвайте метода от родителския клас в детския клас, така че методът на клас на деца очаква аргумент с двоен тип. Създайте обект от детски клас и извикайте претоварения метод, като премине цяло число. Вижте какво се случва.
заключение
Претоварването с методи е доста мощна концепция. Много е полезно при писането на елегантен код. И все пак, това може да стигне до степен, когато десетки методи са претоварени и разработчикът трябва да се позове на дефинициите на метода, докато отстранява грешките извиквания. За да избегнете това, често се предлага да назовете методите си по различен начин, когато претоварването има тенденция да се мащабира до по-високо ниво.
Препоръчителни статии
Това е ръководство за претоварване в C #. Тук обсъждаме неговия метод, как работи, типове с пример и правила. Можете да разгледате и другите ни предложени статии, за да научите повече -
- C # Докато цикъл
- C # ако изявление
- C # функции
- Използване на C #
- Ръководство за претоварване в C ++
- Претоварване в Java
- Python Overloading
- Претоварване и отмяна в C #
- Преобразуване на типове в Java с типове и примери