Na początku wprowadźmy sobie pojęcie sygnatury. Sygnatura jest to nazwa metody oraz lista parametrów, jakie ta metoda przyjmuje. Mówimy więc, że dwie metody mają różne sygnatury, gdy nazywają się inaczej, bądź mają różną listę parametrów (co do liczby lub ich nazwy). Spójrzmy na poniższy fragment kodu:
public int
MojaMetoda(int param1);
public int MojaMetoda(int
param1, int param2);
public int MojaMetoda(int
param1, int param2, int
param3);
public int
MojaMetoda(int param1, double
param2, string param3);
Pierwsze trzy metody mają taka samą nazwę oraz zwracają ten sam typ, ale różnią się ilością parametrów jakie przyjmują. Natomiast trzecia metoda różni się od czwartej typem dwóch parametrów, jakie ta czwarta metoda przyjmuje (double param2, string param3).
A więc przeciążenie metody (ang. Method overloading) – czyli innymi słowy utworzenie nowej wersji metody, polega na zmianie sygnatury tej metody (zmianie nazwy metody lub liczby parametrów jaką ta metoda przyjmuje, lub zmianie typu parametrów metody).
Napiszmy więc pierwszy przykład, który będzie ilustrował przeciążanie metod:
class Przeciazenie
{
public void MojaMetoda()
{
System.Console.WriteLine("Brak parametrów w metodzie.");
}
//przeciazenie
metody mojaMetoda() - dodanie jednego parametru
public void MojaMetoda(int
param1)
{
System.Console.WriteLine("Jeden parametr w metodzie, którego wartość wynosi:
{0}", param1 + ".");
}
//przeciazenie
metody mojaMetoda() - dodanie dwoch parametrow
public void MojaMetoda(int
param1, int param2)
{
System.Console.WriteLine("Dwa parametry w metodzie. Parametr pierwszy to: {0},
a parametr drugi to: {1}", param1,param2 + ".");
}
//przeciazenie
metody mojaMetoda() - parametr typu string
public string
MojaMetoda(string param1)
{
return param1;
}
}
class Glowna
{
static void Main ()
{
string
napis;
//obiket
klasy Program
Przeciazenie
prz = new Przeciazenie();
//wywolanie
przeciazonych metod z klasy Przeciazenie
prz.MojaMetoda();
prz.MojaMetoda(8);
prz.MojaMetoda(8, 23);
napis = prz.MojaMetoda("CentrumXP.pl");
System.Console.WriteLine("Nasz napis to: {0}", napis + ".");
}
}
W wyniku uruchomienia powyższego przykładu otrzymamy następujące wyniki:
Jak widać, metoda MojaMetoda() jest przeciążana 4-krotnie. Pierwsza wersja tej metody nie przyjmuje żadnego parametru. Druga wersja przyjmuje jeden parametr (jest to liczba całkowita). Natomiast trzecia wersja metody MojaMetoda() przyjmuje dwa parametry, które również są liczbami całkowitymi.
Wreszcie czwarta wersja przyjmuje jeden parametr, który jest typu string. A więc przeciążenie tutaj polega na zmianie typu parametru tej metody. Ta wersja metody różni się od swoich poprzedniczek również typem jaki zwraca (pierwsze trzy metody MojaMetoda() zwracają typ intiger, natomiast ta - czwarta jest typu string).Wprowadzona przez nas definicja przeciążania mówi o różnicach sygnatur między kolejnymi wersjami metod (wersja czwarta niewątpliwie spełnia ten wymóg), natomiast nic nie mówi o typach zwracanych przez poszczególne metody. Czy zmiana tylko typów zwracanych przez dwie metody przy niezmiennej sygnaturze tych metod sprawi, że obie metody będziemy uważać za przeciążone?
Jak się pewnie domyślamy, zmiana samego typu zwracanego nie tworzy nowej wersji metody, a samo utworzenie dwóch metod o tej samej sygnaturze, ale innym typie zwracanym, spowoduje, że w trakcie kompilacji otrzymamy błąd (można spróbować napisać sobie w ramach pracy domowej przykład takiej sytuacji i upewnić się, że tak naprawdę jest).
W poniższym przykładzie natomiast, przeciążymy dwukrotnie metodę, której druga wersja przyjmie inny typ parametru (nazwy parametrów będą w obu metodach te same) oraz zwróci inny typ niż jej poprzedniczka (pierwsza metoda będzie zwracać intiger, natomiast druga: typ o nazwie long).
Oto przykład:
class Przeciazenie
{
public int MojaMetoda(int
liczba1)
{
return 10 + liczba1;
}
public long
MojaMetoda(long liczba1)
{
return 20 + liczba1;
}
}
class Glowna
{
static void Main ()
{
int a;
int b;
Przeciazenie
prz = new Przeciazenie();
a = prz.MojaMetoda(10);
b = prz.MojaMetoda(30);
System.Console.WriteLine("Wynik po wywołaniu pierwszej metody wynosi: {0}",
a);
System.Console.WriteLine("Wynik po wywołaniu drugiej metody wynosi: {0}",
b);
}
}
Po uruchomieniu będziemy mieli następujące wyniki:
A więc jak widzimy, taki sposób przeciążania metody jest jak najbardziej prawidłowy i dozwolony. Pomimo faktu, że sposób ten nie jest najczęściej wykorzystywany przez programistów to pamiętajmy, że można i tak przeciążać metody.
Podsumowując przeciążanie metod w języku C#, powiemy, że polega ono po prostu na tworzeniu nowych wersji tych metod poprzez zmianę ich sygnatur (czyli nazwy i listy parametrów metody przeciążanej). Klasa może zawierać dowolną liczbę metod, o ile każda metoda ma inną, unikalną sygnaturę. Każda inna sytuacja spowoduje, że podczas przeciążania metod, nasz kompilator wyświetli komunikat o błędzie.
Na koniec przejdźmy do przeciążanie konstruktorów.Podobnie jak w metodach, tak i w konstruktorach możemy używać mechanizmu przeciążania. Mechanizm ten nie będzie różnił się niczym szczególnym w stosunku do zwykłego przeciążania metod.
Napiszmy program, który będzie w zupełności przedstawiał mechanizm przeciążania konstruktorów. Program ten będzie obliczał pole kwadratu (gdy podamy jeden wymiar), pole prostokąta (gdy podamy 2 wymiary). Oto przykładowy program:
public class Figura
{
int a;
int b;
//pierwszy
konstruktor, ktory używany jest, gdy nie podamy żadnego wymiaru
public
Figura()
{
a = 0;
b = 0;
}
//drugi
konstruktor, który używany jest, gdy tworzony jest kwadrat
public
Figura(int bok)
{
a = b = bok;
}
//trzeci
konstruktor, ktory uzywany jest, gdy tworzony jest prostokat
public
Figura(int bok1, int
bok2)
{
a = bok1;
b = bok2;
}
//metoda, ktora
oblicza pole odpowiedniej figury
public int Oblicz()
{
return a * b;
}
}
class Glowna
{
public static void Main (string[] args)
{
int
wynik;
//tworzymy
figury, uzywajac roznych konstruktorow
Figura figura1 = new Figura();
Figura figura2 = new Figura(5);
Figura
figura3 = new Figura(6);
//podaje pole
pierwszej figury
wynik = figura1.Oblicz();
System.Console.WriteLine("Pole pierwszej figury wynosi: {0}",
wynik);
//podaje pole
drugiej figury
wynik = figura2.Oblicz();
System.Console.WriteLine("Pole drugiej figury wynosi: {0}",
wynik);
//podaje pole
trzeciej figury
wynik = figura3.Oblicz();
System.Console.WriteLine("Pole trzeciej figury wynosi: {0}", wynik);
}
}
Po skompilowaniu, otrzymujemy następujące wyniki:
W powyższym przykładzie klasa Figura posiada 3 konstruktory: pierwszy używany jest w programie przy inicjalizacji obiektu: figura1, gdy nie podamy żadnego wymiaru boku. W ten sposób w konstruktorze tym, odpowiednim zmiennym przypisywana jest wartość 0, stąd metoda Oblicz() (metoda ta oblicza pole na podstawie podanych wymiarów) zwraca dla tego przypadku pole równe 0.
Drugi konstruktor używany jest przy inicjalizacji obiektu: figura2, gdy podamy jeden wymiar boku. W ten sposób metoda Oblicz() zwróci pole równe 25 (podaliśmy jeden wymiar, więc zbudowaliśmy kwadrat). Natomiast trzeci konstruktor używany jest przy tworzeniu obiektu: figura3. Jest to przypadek, gdy w konstruktorze podaliśmy 2 wymiary i metoda Oblicz() zwróci nam pole dla prostokąta (pole w naszym programie wynosi: 36).
Dzisiaj opowiedzieliśmy sobie o przeciążaniu metod oraz konstruktorów. Są to mechanizmy bardzo często wykorzystywane przez programistów i na pewno stanowią regułę, a nie wyjątek.
Za tydzień opowiemy sobie o hermetyzacji danych w języku C# 2.0.
341f31d.png)