Suprasarcinarea metodelor

Uneori apare necesitatea de a crea aceeași metodă, dar cu seturi diferite de parametri. Și în funcție de parametrii disponibili să se aplice o anumită versiune a metodei. Această posibilitate se numește suprasarcinarea metodelor (method overloading).

În limbajul C# putem crea în clasă mai multe metode cu același nume, dar cu semnături diferite. Ce este o semnătură? Semnătura este formată din următoarele aspecte:

• Numele metodei
• Numărul parametrilor
• Tipurile parametrilor
• Ordinea parametrilor
• Modificatorii parametrilor

Însă denumirile parametrilor nu fac parte din semnătură. De exemplu, să luăm următoarea metodă:

public int Sum(int x, int y)
{
   return x + y;
}

Semnătura acestei metode va arăta astfel: Sum(int, int)

Suprasarcinarea metodei constă în faptul că metodele au semnături diferite, în care se potrivește doar numele metodei. Adică metodele trebuie să difere în:

• Numărul parametrilor
• Tipul parametrilor
• Ordinea parametrilor
• Modificatorii parametrilor

De exemplu, să avem următoarea clasă:

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}");
   }
}

Aici sunt prezentate patru versiuni diferite ale metodei Add, adică sunt definite patru suprasarcinări ale acestei metode.

Primele trei versiuni ale metodei diferă prin numărul de parametri. A patra versiune coincide cu prima prin numărul de parametri, dar diferă prin tipul acestora. Este suficient ca cel puțin un parametru să difere prin tip.

Prin urmare, aceasta este o suprasarcinare validă a metodei Add.

Putem reprezenta semnăturile acestor metode astfel:

Add(int, int)

Add(int, int, int)

Add(int, int, int, int)

Add(double, double)

După definirea versiunilor suprasarcinate, le putem folosi în program:

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

Consola va afișa:

Result is 3

Result is 6

Result is 10

Result is 3.9

De asemenea, metodele suprasarcinate pot diferi prin modificatorii utilizați. De exemplu:

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

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

În acest caz, ambele versiuni ale metodei Increment au același set de parametri de același tip, dar în primul caz parametrul are modificatorul ref. Prin urmare, ambele versiuni ale metodei vor fi suprasarcinări valide ale metodei Increment.

Diferențele între metodele prin tipul returnat sau prin denumirile parametrilor nu constituie un temei pentru suprasarcinare. De exemplu, să luăm următorul set de metode:

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);
}

Semnătura tuturor acestor metode va fi aceeași:

Sum(int, int)

De aceea, acest set de metode nu reprezintă suprasarcinări valide ale metodei Sum și nu va funcționa.