Dziedziczenie

From Obrona

Dziedziczenie (ang. inheritance) to w programowaniu obiektowym operacja polegająca na stworzeniu nowej klasy na bazie klasy już istniejącej.

Na przykład, jeśli mamy klasę (w C++):

class Punkt
{ 
public: 
   float x,y; 
   Punkt(float _x, float _y); 
   virtual void wypisz(); 
   virtual void przesuń(float przesuniecie_x, float przesuniecie_y); 
}; 

Załóżmy, że w naszym programie wynikła potrzeba użycia dodatkowej klasy, która różni się od tej jedynie w kilku szczegółach. Dzięki dziedziczeniu nie musimy tworzyć takiej klasy od zera, a możemy zamiast tego wprowadzić jedynie konieczne modyfikacje do klasy już istniejącej.

Przykładowo chcemy, by nowa klasa miała dodatkowy składnik:

string nazwa;

a także odpowiednio zmieniona metodę wypisz.

Dziedziczona klasa może zostać zdefiniowana w następujący sposób:

class NazwanyPunkt: public Punkt
{ 
public: 
   string nazwa;
   NazwanyPunkt(float _x=0,float _y=0,string _nazwa=NULL); 
   virtual void wypisz(); 
}; 

W ten sposób powstała nowa klasa o nazwie NazwanyPunkt (klasa pochodna, podklasa, potomek) wywodząca się od klasy Punkt (klasa podstawowa, nadklasa, rodzic).

Bardzo ważna w naszej klasie pochodnej jest pierwsza linijka:

class NazwanyPunkt: public Punkt

Wyrażenie znajdujące się po dwukropku nazywa się listą pochodzenia. W składni języka C++ informuje ona od czego wywodzi się klasa pochodna.

W C++ klasie pochodnej możemy zdefiniować:

• dodatkowe dane składowe (w naszym przykładzie: string nazwa;)
• dodatkowe funkcje składowe (w naszym przykładzie zmieniliśmy funkcję wypisz())
• nową treść funkcji wirtualnej

W innych językach szczegóły dziedziczenia mogą wyglądać odmiennie, np. w CLOS klasa pochodna może wpływać na metody odziedziczone po klasie podstawowej, ogólna zasada dziedziczenia pozostaje jednak taka sama.

Contents 1 Dziedziczenie wielokrotne 2 Wielokrotne dziedziczenie a interfejsy 3 Źródła 4 Pochodzenie tekstu

[edit] Dziedziczenie wielokrotne

Dziedziczenie wielokrotne (ang. multiple inheritance) to operacja polegająca na dziedziczeniu po więcej niż jednej klasie bazowej. Dziedziczenie wielokrotne stosowane jest na przykład w języku C++. W innych językach programowania (np. w Javie) dopuszczalne jest wyłącznie dziedziczenie jednokrotne, zaś do uzyskania efektu, który w C++ osiąga się poprzez dziedziczenie wielokrotne używa się interfejsów.

Przeanalizujmy przykład (w C++):

class Samochod {
  public:
    int iloscKol;
    void jedz() { /* ciało metody */ }
};

class Lodz {
  public:
    float wypornosc;
    void plyn() { /* ciało metody */ }
};

class Amfibia : public Samochod , public Lodz {
  public:
    string nrRejestracyjny;
};

W efekcie wielokrotnego dziedziczenia Klasa Amfibia posiada wszystkie pola i metody swoich klas bazowych.

Dzięki zastosowaniu wielokrotnego dziedziczenia, stworzony obiekt danej klasy jest wielotypowy. W odniesieniu do powyższczego przykładu możliwe są następujące operacje:

...
void napompujKolo( Samochod& samochod ) { /* ciało metody */ }
void naprawKadlub( Lodz& lodz ) { /* ciało metody */ }

int main() {
  Amfibia amfibia;
  napompujKolo( amfibia );
  naprawKadlub( amfibia );
  return 0;
}

Widzimy, że obiekt amfibia jest jednocześnie typu Samochod i Lodz.

[edit] Wielokrotne dziedziczenie a interfejsy

Zarówno dziedziczenie wielokrotne, jak i interfejsy pozwalają na uzyskanie równoważnego efektu -- możliwości traktowania obiektu polimorficznie ze względu na wiele, niespokrewnionych ze sobą typów. Wielodziedziczenie jednakże jest techniką znacznie bardziej niebezpieczną, gdyż w przeciwieństwie do interfejsów, łączy w sobie środki do współdzielenia implementacji ze środkami współdzielenia zewnętrznego kontraktu klasy, a zatem dwie funkcje o radykalnie różnych zastosowaniach. Dlatego też użycie wielokrotnego dziedziczenia wymaga znacznej wiedzy o mechanizmach języka i ścisłej dyscypliny od stosującego je programisty, w przeciwnym wypadku bowiem istnieje niebezpieczeństwo stworzenia hierarchii klas w której zmiana szczegółów implementacyjnych może pociągnąć za sobą konieczność zmiany kontraktu, lub też sytuacji w której nie będzie możliwe stworzenie hierarchii o pożądanym kształcie bez wprowadzania nieprawidłowego zachowania obiektów.

Dla kontrastu, w przypadku użycia interfejsów, czynności dziedziczenia (współdzielenia implementacji) i dzielenia interfejsu (czyli zewnętrznego kontraktu) są celowo rozdzielone. W ten sposób nie jest możliwe przypadkowe pomylenie tych dwóch pojęć, co miałoby opłakane skutki.

Argumentem podnoszonym na rzecz wielokrotnego dziedziczenia bywa fakt, że umożliwia ono proste wykorzystanie istniejącej implementacji z więcej niż jednej klasy bazowej. Jest to prawda, jednak w rzeczywistości bardzo rzadko ten właśnie efekt jest tym co naprawdę ma zastosowanie w danej sytuacji, często zaś istnieje fałszywe wrażenie iż jest to potrzebne. Jeśli istotnie zachodzi potrzeba wykorzystania więcej niż jednej implementacji, w przypadku użycia interfejsów można wykorzystać techniki osadzania i delegacji; powoduje to konieczność większej pracy ze strony programisty, jednak zazwyczaj jest to pożądane, gdyż zmusza do głębszego zastanowienia się nad pomysłem łączenia niespokrewnionych klas, a dodatkowo powoduje, że nowa klasa zachowuje się dokładnie tak jak oczekuje tego programista, a nie tak jak stanowi definicja języka (która rzadko pokrywa się z intuicją w bardziej skomplikowanych obszarach, a wielodziedziczenie należy do najbardziej skomplikowanych).

Należy również pamiętać, że powyższe argumenty odnoszą się głównie do "tradycyjnych" języków o statycznym systemie typów, takich jak C++. W innych językach, takich jak Python, również istnieje mechanizm wielodziedziczenia, jednakże konstrukcja systemu typów i mechanizmu klas jest radykalnie odmienna, co powoduje że powyższa dyskusja traci swoją aktualność.

[edit] Źródła

• Scott Meyers, More Effective C++

[edit] Pochodzenie tekstu

Tekst pochodzi z polskiej Wikipedii i udostępnionu jest na licencji GFDL.

• Co to GFDL? - artykuł na pl.wikipedia.org
• GFDL - lokalna kopia treści licencji GFDL
• GFDL - kopia licencji GFDL w witrynie gnu.org