06. Dziedziczenie i polimorfizm

06. Dziedziczenie i polimorfizm

 Paweł Kruczkowski
Paweł Kruczkowski
00:00
31.10.2006
207739 wyświetleń

Tematem niniejszego artykułu będzie dziedziczenie oraz polimorfizm. Oba te pojęcia są jednymi z najważniejszych z punktu widzenia programowania obiektowego. Bowiem prędzej czy później każdy z nas w swoich programach będzie musiał zdefiniować pewną ogólną klasę, która będzie definiować cechy wspólne dla zestawu pozostałych elementów. Co się za tym kryje? A no to, że klasę taką będzie mogła dziedziczyć inna klasa, która będzie bardziej specyficzna od tej odziedziczonej (ogólnej), i która z kolei będzie dodawać następne unikatowe cechy w swojej strukturze. Oczywiście tę nową klasę może dziedziczyć inna i proces dziedziczenia będzie się rozbudowywał tworząc prawidłową hierarchię w naszym kodzie. Z dziedziczeniem ściśle powiązany jest polimorfizm (poli oznacza wiele, zaś morf to forma), o którym dzisiaj będzie również kilka słów.

Po zdefiniowaniu powyższych nowych dla nas pojęć, postaramy się w oparciu o przykłady wprowadzić kolejne, takie jak metody: wirtualne i przysłaniające, czy słowo kluczowe: base, bez których to dziedziczenie oraz polimorfizm nie może żyć.

Zacznijmy więc od prawidłowego zdefiniowania dziedziczenia. Jak wiemy, programowanie obiektowe polega na rozbudowie istniejącego już kodu. Nie należy jednak nanosić poprawek do wcześniej zdefiniowanych klas (oczywiście, jeśli są dobrze zaprojektowane), tylko definiować kolejne klasy, które będą przejmować właściwości oraz cechy tych już istniejących. Takie postępowanie możliwe jest dzięki dziedziczeniu.

Załóżmy, że mamy klasę A, która dziedziczy po klasie B. W takiej sytuacji mówi się, że klasa B jest klasą bazową klasy A, natomiast klasa A jest klasą pochodną klasy B. W tym przypadku dziedziczenie polega na tym, że klasa A dziedziczy wszystkie cechy oraz zachowania klasy B, a także zawiera wyspecjalizowane składowe, dzięki którym można wykonać określone zadania.

W języku C# 2.0 klasę pochodną tworzy się w ten sposób, że po nazwie klasy pochodnej umieszczamy dwukropek, a po nim nazwę klasy bazowej. Na przykład:

public class PierwszaKlasa
{
     public int a;
     public int b;
 
     public void WyswietlAB()
     {
         System.Console.WriteLine("Wartości a i b wynoszą odpowiednio: {0} i {1}", a, b +".");
     }
}
 
public class DrugaKlasa : PierwszaKlasa
{
     public int c;
 
     public void WyswietlC()
     {
         System.Console.WriteLine("Wartość liczby c wynosi: {0}", c +".");
     }
 
     public void SumaLiczb()
     {
         int suma = a + b + c;
         System.Console.WriteLine("Suma liczb wynosi: {0}", suma +".");
     }
 }
 
 class Glowna
 {
     public static void Main(string[] args)
     {
         PierwszaKlasa pr = new PierwszaKlasa();
         DrugaKlasa dr = new DrugaKlasa();
        
//przypisanie wartosci zmiennym w obiekcie pr typu PierwszaKlasa i wywolanie        
metody pobierajacej te wartosci
         pr.a = 3;
         pr.b = 7;
           
         pr.WyswietlAB();
 
//klasa pochodna ma dostep do wszystkich skladowych publicznych pochodzacych z klasy, od ktorej je dziedziczy
         dr.a = 2;
         dr.b = 8;
         dr.c = 5;
 
         dr.WyswietlAB();
         dr.WyswietlC();
         dr.SumaLiczb();
     }
 }

W powyższym przykładzie zdefiniowaliśmy sobie dwie klasy: PierwszaKlasa, w której zadeklarowaliśmy sobie 2 zmienne składowe (a i b), których wartości będziemy wyświetlać za pomocą metody: WyswietlAB() oraz klasę DrugaKlasa, w której zdefiniowaliśmy zmienną składową c, której wartość będziemy pobierać za pomocą metody WyswietlC(). Klasa DrugaKlasa dziedziczy wszystkie cechy oraz właściwości od klasy PierwszaKlasa. W ten sposób w klasie: DrugaKlasa, będziemy mieli dostęp zarówno do zmiennych a i b pierwszej klasy jak i do metody WyswietlAB(), którą również zainicjalizowaliśmy w klasie: PierwszaKlasa.

Po uruchomieniu otrzymamy następujące wyniki:

Poznaliśmy więc w ten sposób pojęcie dziedziczenia, z którym to wiążą się dwie istotne rzeczy. Po pierwsze, dziedziczenie to po prostu wielokrotne wykorzystywanie kodu. Bowiem w klasie: DrugaKlasa możemy powtórnie wykorzystać elementy pochodzące z klasy bazowej: PierwszaKlasa. Po drugie – co jest na pewno istotniejszym aspektem dziedziczenia – wiąże się z polimorfizmem, o którym w tym miejscu będzie kilka słów.

Jak już wyżej zostało napisane, polimorfizm to używanie danego typu w wielu formach niezależnie od klas, jakie dostarczają te typy.

Aby lepiej zrozumieć powyższą, książkową definicję polimorfizmu, wyobraźmy sobie nadajnik telewizyjny, który wysyła do użytkowników sygnał. Nadajnik ten nie wie, jakiego rodzaju jest antena użytkownika znajdująca się na końcu linii. Może to być jakaś antena szerokopasmowa, może to być antena wielokanałowa, a może zwykła standardowa naziemna, czy po prostu domowa. Nadajnik zna jedynie „typ bazowy”, czyli w naszym przypadku antenę i oczekuje, że każdy „egzemplarz” tego typu będzie potrafił odebrać jego sygnał i dostarczyć do telewizora znajdującego się u użytkownika. W ten sposób nadajnik traktuje anteny polimorficznie.

Po zdefiniowaniu sobie pojęcia polimorfizmu, pokażmy sobie w jaki sposób tworzy się metody polimorficzne. Metody takie definiujemy w klasie bazowej (jak już wiemy jest to klasa, po której dziedziczymy) i oznaczamy je jako metody wirtualne. Aby utworzyć takie metody, należy dodać do ich deklaracji słowo kluczowe: virtual, np.:

public class A
{

                public virtual void MojaWirtualna()
                { }

}

Gdy deklaracja metody zawiera modyfikator virtual, to taką metodę nazywamy wirtualną, natomiast gdy taki modyfikator nie występuje, wówczas daną metodę nazywamy po prostu niewirtualną.

W deklaracji metody wirtualnej nie jest możliwe umieszczenie takich modyfikatorów jak: static, abstract oraz override. O metodach statycznych (słowo kluczowe static w deklaracji takich metod) była już mowa na łamach portalu CentrumXP. Przypomnę jedynie, że takie metody działają na klasach, a nie na obiektach tych klas. Przykładem takiej metody jest dobrze nam znana metoda Main() z naszych przykładów. Modyfikator abstract pojawi się za tydzień w naszym kursie, natomiast o słowie kluczowym: override będzie jeszcze mowa w niniejszym artykule.

Po prawidłowym zadeklarowaniu metody wirtualnej w klasie bazowej, w każdej klasie pochodnej może znaleźć się nowa wersja tej metody. Aby utworzyć nową wersję metody MojaWirtualna() należy ją przesłonić w klasie pochodnej, używając do tego nowego modyfikatora: override:

public class B : A
{
    public override void MojaWirtualna()
                {
                //wywolanie metody klasy bazowej
                base.MojaWirtualna();
                //miejsce na nowy kod w przeslonietej metodzie
                 
          }
      }

W powyższym fragmencie kodu, modyfikator override informuje kompilator o tym, że dana metoda w klasie pochodnej (jak już wiemy, możemy przesłaniać metody wirtualne z klas bazowych jedynie w klasach pochodnych) została celowo przesłonięta. Bardzo często metody przesłaniające wywołują metody bazowe w swojej strukturze (w końcu przesłaniamy przecież metodę, którą dziedziczymy i często chcemy ją wywołać w nowej metodzie). Aby tak zrobić, należy wykorzystać słowo kluczowe base. W powyższym kodzie:

                               base.MojaWirtualna();

w klasie B wywołuje metodę: MojaWirtualna(), którą zadeklarowaliśmy w klasie A. Taki dostęp bazowy wyłącza mechanizm wywołania wirtualnego i traktuje taką metodę jako metodę niewirtualną.

Gdybyśmy w klasie B wywołali metodę MojaWirtualna() w następujący sposób:

                             ((A)this).MojaWirtualna();

to rekurencyjnie zostałaby wywołana metoda MojaWirtualna() zadeklarowana w klasie B, a nie w klasie A.

Napiszmy przykład, który będzie prezentował nowo poznane przez nas pojęcie polimorfizmu.

public class PierwszaKlasa
{
     public int a;
     public int b;
 
     //konstruktor klasy A, ktory przyjmuje dwie liczby calkowite
     public PierwszaKlasa(int a, int b)
     {
         this.a = a;
         this.b = b;
     }
 
     //metoda wirtualna
     public virtual void Wyswietl()
     {
         System.Console.WriteLine("Wartości a i b wynoszą odpowiednio: {0} i {1}", a, b +".");
     }
}
 
public class DrugaKlasa : PierwszaKlasa
{
    public int c;
 
   //dodatkowy parametr w konstruktorze, wywolujemy rowniez konstruktor klasy bazowej
   public DrugaKlasa(int a, int b, int c) : base(a, b)
   {
      this.c = c;
   }
       
   //przeslaniamy metode klasy bazowej
   public override void Wyswietl()
   {
       base.Wyswietl();
       System.Console.WriteLine("Wartość liczby c wynosi: {0}", c +".");
   }
}
 
public class TrzeciaKlasa : DrugaKlasa
{
    int d;
    int suma;
    //dodatkowy parametr w konstruktorze oraz wywolanie konstruktora klasy bazowej
    public TrzeciaKlasa(int a, int b, int c, int d) : base(a, b, c)
    {
        this.d = d;
    }
    //przeslaniamy metode klasy DrugaKlasa
    public override void Wyswietl()
    {
        base.Wyswietl();
        System.Console.WriteLine("Wartość liczby d wynosi: {0}", d + ".");
        suma = a + b + c + d;
        System.Console.WriteLine("Suma czterech kolejnych liczb wynosi: {0}", suma +".");
    }
}
 
class Glowna
{
    public static void Main(string[] args)
    {
       //deklaracja obiektu typu PierwszaKlasa wraz z wartosciami zmiennych
       PierwszaKlasa pr = new PierwszaKlasa(1, 2);
       //deklaracja obiektu typu DrugaKlasa wraz z wartosciami zmiennych w tym obiekcie
       DrugaKlasa dr = new DrugaKlasa(3, 4, 5);
       //deklaracja obiektu typu TrzeciaKlasa
       TrzeciaKlasa tr = new TrzeciaKlasa(6, 7, 8, 9);
       //wywolanie metody Wyswietl() z klasy PierwszaKlasa
       pr.Wyswietl();
       //wywolanie metody Wyswietl() z klasy DrugaKlasa
       dr.Wyswietl();
       //wywolanie metody Wyswietl() z klasy TrzeciaKlasa
       tr.Wyswietl();
    }
}

Powyższy przkład – wbrew pozorom - jest bardzo łatwym programem prezentującym dziedziczenie wraz z polimorfizmem. Przedstawia bowiem wszystkie apsekty programistyczne, o których była mowa dzisiaj, bądź w poprzednich odcinkach kursu programowania w języku C# 2.0. Jedyną rzeczą godną uwagi oraz komentarza w powyższym kodzie jest sposób wywoływania konstruktorów klasy bazowej.

Klasa DrugaKlasa dziedziczy po klasie: PierwszaKlasa i zawiera własny konstruktor, który przyjmuje 3 parametry (wszystkie są liczbami całkowitymi). Po liście parametrów, jakie ten konstruktor przyjmuje mamy dwukropek, a więc znak, że wywołamy coś z klasy bazowej. W ten właśnie sposób wywołujemy konstruktor klasy bazowej (a więc klasy: PierwszaKlasa).

Ważną informacją jest fakt, że klasy nie dziedziczą konstruktorów. W takim przypadku w klasie pochodnej musimy zdefiniować własny konstruktor, który może korzystać z konstruktora klasy bazowej tylko poprzez jawne jego wywołanie.

A co się dzieje, gdy w klasie bazowej znajduje się konstruktor domyślny? W takim przypadku w konstruktorze klasy pochodnej nie jest potrzebne jawne wywoływanie konstruktora z klasy bazowej, ponieważ za nas uczyni to kompilator. Jeśli jednak w klasie bazowej nie ma konstruktora domyślnego, to każdy konstruktor w klasie pochodnej musi jawnie wywoływać jakiś konstruktor z klasy bazowej wykorzystując przy tym słówko: base.

Bardzo często o tym zapominają programiści, dlatego warto zapamietać powyższe informacje na temat dziedziczenia konstruktorów, aby nie popełniać podobnych błędów.

Po skompilowaniu powyższego przykładu otrzymamy następujące wyniki:>

Prześledźmy następujący przykład:

public class A
{
    public virtual void MojaWirtualna()
    {
       System.Console.WriteLine("To jest metoda wirtualna w klasie A");
    }
}
 
public class B : A
{
    public virtual void MojaWirtualna()
    {
       base.MojaWirtualna();
       System.Console.WriteLine("To jest metoda wirtualna w klasie B");
    }
}
 
class Glowna
{
    public static void Main()
    {
       B b = new B();
       b.MojaWirtualna();
    }

}

W klasie A zadeklarowaliśmy wirtualną metodę o nazwie: MojaMetoda(). Klasa B, która dziedziczy po klasie bazowej A, definiuje również wirtualną metodę MojaMetoda() o takiej samej sygnaturze jak jej poprzedniczka. Czy taka sytuacja jest dozwolona? Skompilujmy i spójrzmy na wyniki:

Okazuje się, że nasz przykład skompilował się i otrzymaliśmy satysfakcjonujące nas wyniki. Wszystko byłoby dobrze, gdyby nie komunikat naszego kompilatora w momencie uruchomienia powyższego kodu:

Otrzymaliśmy więc ostrzeżenie, które informuje nas, że w klasie B ukryto dziedziczoną z klasy A metodę MojaWirtualna(). Klasa B nie zawiera bowiem modyfikatora override, dlatego też metoda MojaWirtualna() klasy A nie została przesłonięta.

Aby uniknąć powyższego ostrzeżenia, musimy użyć słowa kluczowego: new przy deklaracji metody wirtualnej w klasie B:

public class A
{
    public virtual void MojaWirtualna()
    {
       System.Console.WriteLine("To jest metoda wirtualna w klasie A");
    }
}
 
public class B : A
{
    new public virtual void MojaWirtualna()
    {
       base.MojaWirtualna();
       System.Console.WriteLine("To jest metoda wirtualna w klasie B");
    }
}
 
class Glowna
{
    public static void Main()
    {
       B b = new B();
       b.MojaWirtualna();
    }
}

W ten sposób kompilator wie, że nie przesłaniamy dziedziczonej wirtualnej metody, a jedynie ją ukrywamy.

W dzisiejszym artykule wprowadzliśmy sobie nowe pojęcia takie jak: dziedziczenie i polimorfizm. Są to mechanizmy, bez których nasz program nie istniałby. Poznaliśmy też takie pojęcia jak: klasa bazowa i pochodna, oraz metoda wirtualna i przesłaniająca. Nauczyliśmy się również używać nowego słowa kluczowego: base.

Jednak to nie wszystko, jeśli chodzi o to zagadnienie programistyczne. Musimy opowiedzieć sobie jeszcze o klasach i metodach abstrakcyjnych, które są niejawnymi metodami wirtualnymi.


Spodobał Ci się ten artykuł? Podziel się z innymi!

Źródło:

Polecamy również w kategorii Kurs C#, cz. II