1-Mavzu: Rekursiv va qayta yuklanuvchi metodlar

2. Qayta yuklanuvchi metodlar
Ba'zan bir xil usulni yaratish kerak bo'ladi, lekin boshqa parametrlar to'plami bilan. Mavjud parametrlarga qarab, usulning ma'lum bir versiyasini qo'llang. Bu xususiyat, shuningdek, usulning qayta yuklanishi (method overloading) deb ataladi.
C# da biz bir xil nomga ega, ammo signaturalari har xil bo'lgan sinfda bir nechta usullarni yaratishimiz mumkin. Signatura nima? Signatura quyidagi jihatlardan iborat:

• 
  Usul nomi
  
• 
  Parametrlar soni
  
• 
  Parametr turlari
  
• 
  Parametr tartibi
  
• 
  Parametr o'zgartiruvchilar
  

Ammo parametrlarning nomlari signaturaga kiritilmagan. Masalan, quyidagi usulni olamiz:

public int Sum(int x, int y)
{
return x + y;
}
Ushbu usul uchun signatura quyidagicha ko'rinadi: Sum(int, int)
Bu usulning qayta yuklanishi shunchaki usullarning turli xil signaturalariga ega bo'lib, unda faqat usulning nomi bir xil bo'ladi. Ya'ni, usullar bir-biridan farq qilishi kerak:

• 
  Parametrlar soni
  
• 
  Parametr turi
  
• 
  Parametrlar tartibi
  
• 
  Parametr modifikatorlar
  

Masalan, bizda quyidagi sinf bor deylik:

class Calculator
{
public void Add(int a, int b)
{
int result = a + b;
Console.WriteLine($"Result is {result}");
}
public void Add(int a, int b, int c)
{
int result = a + b + c;
Console.WriteLine($"Result is {result}");
}
public int Add(int a, int b, int c, int d)
{
int result = a + b + c + d;
Console.WriteLine($"Result is {result}");
return result;
}
public void Add(double a, double b)
{
double result = a + b;
Console.WriteLine($"Result is {result}");
}
}

Add usulining to'rt xil versiyasi mavjud, ya'ni bu usulning to'rtta ortiqcha yuklanishi aniqlangan.

Usulning dastlabki uchta versiyasi parametrlar soni bo'yicha farqlanadi. To'rtinchi versiya parametrlar soni bo'yicha birinchisiga to'g'ri keladi, lekin ularning turi bo'yicha farqlanadi. Bunday holda, kamida bitta parametr turi bo'yicha farq qilishi kifoya. Shuning uchun, bu ham Add usulining haqiqiy qayta yuklanishdir.

Ya'ni, biz ushbu usullarning signaturalarini quyidagicha ifodalashimiz mumkin:

Add(int, int)
Add(int, int, int)
Add(int, int, int, int)
Add(double, double)

Qayta yuklangan versiyalarni aniqlagandan so'ng, biz ulardan dasturda foydalanishimiz mumkin:

Calculator calc = new Calculator();
calc.Add(1, 2); // 3
calc.Add(1, 2, 3); // 6
calc.Add(1, 2, 3, 4); // 10
calc.Add(1.4, 2.5); // 3.9

Konsol chiqishi:

Result is 3
Result is 6
Result is 10
Result is 3.9

Bundan tashqari, qayta yuklangan usullar ishlatilgan modifikatorlarda farq qilishi mumkin. Masalan:

void Increment(ref int val)
{
val++;
Console.WriteLine(val);
}
void Increment(int val)
{
val++;
Console.WriteLine(val);
}

Bunday holda, Increment usulining ikkala versiyasi ham bir xil turdagi parametrlar to'plamiga ega, lekin birinchi holda, parametr ref modifikatoriga ega. Shuning uchun, usulning ikkala versiyasi ham Increment usulining qayta yuklanishi bo'ladi.

Qaytarish turidagi yoki parametrlar nomidagi usullar orasidagi farq qayta yuklanish uchun sabab emas. Masalan, quyidagi usullar to'plamini oling:
int Sum(int x, int y)
{
return x + y;
}
int Sum(int number1, int number2)
{
return number1 + number2;
}
void Sum(int x, int y)
{
Console.WriteLine(x + y);
}

Ushbu usullarning barchasi bir xil signaturaga ega bo'ladi:

Sum(int, int)
Shuning uchun, ushbu usullar to'plami Sum usulining to'g'ri qayta yuklanishini anglatmaydi va ishlamaydi.