Klasy

Piszc program mamy do dyspozycji rne typy danych. Najbardziej podstawowym z nich s rnego
rodzaju liczby, jak na przykad liczba cakowita czy te liczba zmiennoprzecinkowa.

/-----\
| int |
\-----/

/-------\
| float |
\-------/

Operacje na danych nazywamy funkcjami.

/---------\
| funkcja |
\---------/
Do funkcji moemy przekazywa dane (argumenty), a funkcja moe nam si odwdziczy zwracajc
inne dane w odpowiedzi.

/---------\ przekazanie /---------\ zwrcenie

| zmienna | ------------> | funkcja | -------->
\---------/ jako argument \---------/ wartoci
Z czasem jednak pisane przez nas programy staj si coraz bardziej skomplikowane. Przekazywanie
wielu rnych argumentw do funkcji moe by problematyczne, poniewa zawsze trzeba
zachowywa ich kolejno.
Dlatego te programici wpadli na bardzo sprytny pomys: a moe by tak zrobi jaki pojemnik, w
ktrym bd przechowywane rne dane? Dziki temu do funkcji moglibymy przekazywa cao,
zamiast wszystko osobno.
Ten tok rozumowania doprowadzi do powstania typw strukturalnych, czyli zmiennych, ktre
zawieraj w sobie inne, mniej zoone zmienne.

/---------------\
|
|
|
Struktura
|
|
|
|
/-------\
|
|
| float |
|
|
\-------/
|
|
|
|
/-----\
|
|
| int |
|
|
\-----/
|
|
|
\---------------/
Majc do dyspozycji takie pojemniki nie musimy si martwi o kolejno zmiennych ani o
przekazywanie duej liczby danych do funkcji jednoczenie.

/---------------\
|
|
|
Struktura
|
|
|
|
/-------\
|
|
| float |
| przekazanie /---------\ zwrcenie
|
\-------/
| ------------> | funkcja | -------->
|
| jako argument \---------/ wartoci
|
/-----\
|
|
| int |
|
|
\-----/
|
|
|
\---------------/
Opakowywanie zmiennych w takie pojemniki okazao si trafionym pomysem. Poprzednio rozsypane
po caym programie zmienne byy teraz dostpne z jednego miejsca. Jednak programici zauwayli, e
nie wszystko zostao uprztnite. Zmienne zostay opanowane, ale funkcje odnoszce si do tych
samych danych (struktur) nadal patay si w rnych miejscach kodu.
Tak powstay klasy, czyli struktury zawierajce w sobie funkcje.

/---------------\
|
|
|
Klasa
|
|
|
|
/-------\
|
|
| float |
|
|
\-------/
|
|
|
|
/-----\
|
|
| int |
|
|
\-----/
|
|
|
| /---------\ |
| | funkcja | |
| \---------/ |
|
|
\---------------/
Do funkcji w klasie moemy odwoa si jak do zwykej zmiennej w strukturze (pamitajc jednak o
licie argumentw). Funkcja w klasie ma dostp do wszystkich skadowych klasy, dziki czemu nie
musimy ju ich do niej przekazywa.
Dla klasy moemy zdefiniowa kilka specjalnych funkcji:
- konstruktor funkcja, ktrej nazwa jest taka sama jak nazwa klasy, nadaje wartoci zmiennym,
- konstruktor kopiujcy tego chyba nie trzeba tumaczy,
- operator przypisania funkcja, ktra przepisuje skadowe z jednego obiektu do drugiego,
- destruktor funkcja, ktra jest wywoywana przy usuwaniu obiektu klasy z pamici.
Niektre klasy mog by do siebie bardzo podobne zawiera te same zmienne i te same funkcje.
Mdry programista wie, e nie musi dla kadej nowej, podobnej klasy definiowa od pocztku
wszystkich zmiennych. Stosowany jest tutaj mechanizm dziedziczenia.
Dziedziczenie polega na tym, e gdy kilka klas ma takie same zmienne i wykonuje na nich te same
operacje to mona utworzy jedn klas bazow, na podstawie ktrej bd tworzone podklasy.

/---------------\
|
|
| Klasa bazowa |
|
|
|
/-------\
|
/--------------------\
|
| float |
|
|
|
|
\-------/
|
| Klasa dziedziczca |
|
| dziedziczenie |
|
|
/-----\
| ------------> |
/--------\
|
|
| int |
|
|
| double |
|
|
\-----/
|
|
\--------/
|
|
|
|
|
| /---------\ |
\--------------------/
| | funkcja | |
| \---------/ |
|
|
\---------------/
Klasa dziedziczca bdzie od teraz zawieraa te wszystkie skadowe klasy bazowej.

/--------------------\
|
|
| Klasa dziedziczca |
|
|
|
/--------\
|
|
| double |
|
|
\--------/
|
|
|
|
/-------\
|
|
| float |
|
|
\-------/
|
|
|
|
/-----\
|
|
| int |
|
|
\-----/
|
|
|
|
/---------\
|
|
| funkcja |
|
|
\---------/
|
|
|
\--------------------/
Czasem zdarza si, e niektre skadowe klasy chcemy ukry przed osob jej uywajc czy to ze
wzgldu na ochron programu przed bdami, czy te dla uproszczenia sposobu uytkowania.
Do tego celu su poziomy dostpu. Zawarto klasy moe wic by:
- prywatna dostpna tylko dla funkcji klasy,
- chroniona dostpna dla funkcji klasy oraz dla klas dziedziczcych,
- publiczna dostpna wszdzie.

/---------------\
|
|
|
Klasa
|
|
|
|-prywatne:-----|
|
|
|
/-------\
|
|
| float |
|
|
\-------/
|
|
|
|
/-----\
|
|
| int |
|
|
\-----/
|
|
|
|-publiczne:----|
|
|
| /---------\ |
| | funkcja | |
| \---------/ |
|
|
\---------------/
Niekiedy chcemy stworzy funkcj poza klas, ale tak, ktra bdzie moga dziaa na prywatnych
skadowych tej klasy. Moemy to osign poprzez zaprzyjanienie klasy z funkcj.

/-----------------\
|
|
|
Klasa
|
|
|
|-prywatne:-------|
|
|
|
/-------\
|
|
| float |
|
|
\-------/
|
|
|
|
/-----\
|
|
| int |
|
|
\-----/
|
|
|
|-publiczne:------|
|
|
|
funkcja
|
| zaprzyjaniona |
|
|
|
/---------\
|
|
| funkcja |
|
|
\---------/
|
|
|
\-----------------/

/------------------------\
| funkcja zaprzyjaniona |
\------------------------/

Jak wida funkcja zaprzyjaniona nie jest skadow klasy. Jej ciao moemy wprawdzie zdefiniowa
wewntrz klasy, ale nie moe by ona z niej wywoywana.
Zaprzyjania moemy nie tylko funkcje, ale rwnie inne klasy.