ABC Delphi 7
-
Upload
wydawnictwo-helion -
Category
Documents
-
view
1.051 -
download
1
description
Transcript of ABC Delphi 7
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: [email protected]
PRZYK£ADOWY ROZDZIA£PRZYK£ADOWY ROZDZIA£
IDZ DOIDZ DO
ZAMÓW DRUKOWANY KATALOGZAMÓW DRUKOWANY KATALOG
KATALOG KSI¥¯EKKATALOG KSI¥¯EK
TWÓJ KOSZYKTWÓJ KOSZYK
CENNIK I INFORMACJECENNIK I INFORMACJE
ZAMÓW INFORMACJEO NOWO�CIACH
ZAMÓW INFORMACJEO NOWO�CIACH
ZAMÓW CENNIKZAMÓW CENNIK
CZYTELNIACZYTELNIA
FRAGMENTY KSI¥¯EK ONLINEFRAGMENTY KSI¥¯EK ONLINE
SPIS TRE�CISPIS TRE�CI
DODAJ DO KOSZYKADODAJ DO KOSZYKA
KATALOG ONLINEKATALOG ONLINE
ABC Delphi 7
Autor: Andrzej Daniluk
ISBN: 83-7361-269-6
Format: B5, stron: oko³o 168
Delphi 7 jest kolejn¹ wersj¹ najpopularniejszego zintegrowanego �rodowiska
programowania typu RAD dla platformy Windows. Delphi 7, wspó³pracuj¹c z Kyliksem
firmy Borland - pierwszym �rodowiskiem programistycznym RAD dla Linuksa - sprawia,
¿e mo¿liwo�ci wykorzystania Delphi przez osoby znaj¹ce jêzyk Object Pascal znacznie
wzrastaj¹. Dziêki prostocie obs³ugi i zaletom wzorowanego na Pascalu jêzyka Object
Pascal, Delphi jest doskona³ym narzêdziem dla pocz¹tkuj¹cych programistów, tak¿e
dla tych, którzy nie mieli wcze�niej wiele wspólnego z programowaniem obiektowym.
Ksi¹¿ka omawia:
• Podstawy programowania w jêzyku Object Pascal
• Projektowanie zorientowane obiektowo (OOD)
• Zintegrowane �rodowisko programistyczne Delphi
• Object Pascal w wydaniu Delphi 6
• Biblioteki VCL i CLX
• Tworzenie i instalowanie w³asnych komponentów
W porównaniu z poprzednim wydaniem tej ksi¹¿ki rozbudowano rozdzia³y traktuj¹ce
o podstawach programowania w jêzyku Object Pascal. Znacznie poszerzono te¿ rozdzia³
po�wiêcony programowaniu obiektowemu.
Pomoc¹ w zg³êbianiu tajników Delphi 7 bêdzie 28 kompletnych, przyk³adowych
projektów do³¹czonych do ksi¹¿ki, ilustruj¹cych najwa¿niejsze poruszane zagadnienia.
Spis treści
Wstęp ............................................................................................... 7
Rozdział 1. Elementarz Object Pascala................................................................. 9Moduły ................................................................................................................................9
Program główny ................................................................................................................10
Stałe...................................................................................................................................12
Zmienne.............................................................................................................................13
Typy całkowite..................................................................................................................14
Typy rzeczywiste...............................................................................................................15
Typ Currency.....................................................................................................................16
Typy logiczne....................................................................................................................16
Typy znakowe ...................................................................................................................17
Typy łańcuchowe ..............................................................................................................17
Literały łańcuchowe ..........................................................................................................18
Typ okrojony .....................................................................................................................18
Typ mnogościowy.............................................................................................................19
Typ wyliczeniowy.............................................................................................................19
Tablice...............................................................................................................................20
Rekordy .............................................................................................................................21
Operatory...........................................................................................................................23
Wskazania i adresy............................................................................................................24
Instrukcje sterujące przebiegiem programu ......................................................................26
Instrukcja warunkowa If…Then .................................................................................26
Instrukcja warunkowa Case…Of................................................................................27
Instrukcja iteracyjna Repeat…Until ...........................................................................28
Instrukcja iteracyjna While…Do ................................................................................29
Instrukcja iteracyjna For…To…Do............................................................................29
Procedura przerwania programu Break ......................................................................30
Procedura przerwania programu Exit .........................................................................31
Procedura wyjścia z programu Halt ............................................................................31
Procedura zatrzymania programu RunError ...............................................................31
Procedura kontynuacji programu Continue ................................................................32
Rekordy z wariantami .......................................................................................................32
Procedury ..........................................................................................................................34
Parametry formalne.....................................................................................................34
4 ABC Delphi 7
Funkcje ..............................................................................................................................36
Operacje zmiennoprzecinkowe .........................................................................................37
Moduły na poważnie .........................................................................................................41
Podsumowanie ..................................................................................................................43
Rozdział 2. Zmienne o typie modyfikowalnym w czasie wykonywania programu... 45Rekord TVarData ..............................................................................................................45
Tablice wariantowe ...........................................................................................................47
Podsumowanie ..................................................................................................................50
Rozdział 3. Projektowanie obiektowe OOD ......................................................... 51Klasy..................................................................................................................................51
Metody ..............................................................................................................................54
Obiekty ..............................................................................................................................54
Widoczność obiektów .......................................................................................................56
Współdziałanie obiektów ..................................................................................................56
Implementacja obiektu ......................................................................................................56
Własności ..........................................................................................................................57
Dziedziczenie ....................................................................................................................59
Klasy abstrakcyjne ............................................................................................................62
Podsumowanie ..................................................................................................................63
Rozdział 4. Środowisko programisty — IDE ........................................................ 65Biblioteka VCL .................................................................................................................67
Karta Standard ............................................................................................................68
Karta Additional..........................................................................................................69
Karta Win32................................................................................................................72
Karta System...............................................................................................................74
Karta Dialogs ..............................................................................................................75
Biblioteka CLX .................................................................................................................76
Karta Additional..........................................................................................................76
Karta System...............................................................................................................77
Karta Dialogs ..............................................................................................................77
Podsumowanie ..................................................................................................................77
Rozdział 5. Object Pascal w wydaniu Delphi ....................................................... 79Formularz ..........................................................................................................................79
Zdarzenia...........................................................................................................................81
Wykorzystujemy własne funkcje i procedury...................................................................86
Metody przeciążane...........................................................................................................88
Wyjątki ..............................................................................................................................91
Operacje na plikach — część I ..........................................................................................95
Operacje na plikach — część II.........................................................................................98
Operacje na plikach — część III .....................................................................................101
Strukturalna obsługa wyjątków.......................................................................................107
Tablice otwarte................................................................................................................108
Tablice dynamiczne.........................................................................................................109
Typ OleVariant................................................................................................................109
Drukowanie .....................................................................................................................112
Rekordy w Delphi ...........................................................................................................114
Podsumowanie ................................................................................................................121
Spis treści 5
Rozdział 6. Biblioteka VCL............................................................................... 123Komponenty TActionList, TImageList, TOpenDialog, TSaveDialog i TMainMenu ....123
Komponenty TActionManager i TActionMainMenuBar ...............................................129
Klasa TMediaPlayer........................................................................................................134
Podsumowanie ................................................................................................................137
Rozdział 7. Biblioteka CLX............................................................................... 139Komponenty TTimer i TLCDNumber ............................................................................139
Pliki i katalogi .................................................................................................................143
Znaki wielobajtowe...................................................................................................144
Komponenty klas TDirectoryTreeView i TFileListView ...............................................144
Podsumowanie ................................................................................................................147
Rozdział 8. Komponentowy model Delphi.......................................................... 149Tworzenie i instalacja własnego komponentu ................................................................149
Modyfikacja istniejącego komponentu z biblioteki VCL/CLX ......................................156
Podsumowanie ................................................................................................................160
Skorowidz...................................................................................... 161
Rozdział 3.
Projektowanie
obiektowe OOD
Programowanie oparte na zasadach projektowania obiektowego OOD (ang. Object
Oriented Design) stanowi zespół metod i sposobów, pozwalających elementom skła-
dowym aplikacji stać się odpowiednikiem obiektu lub klasy obiektów rzeczywiście
istniejących w otaczającym nas świecie. Wszystkie aplikacje tworzone są po to, aby
w sposób mniej lub bardziej prawdziwy odzwierciedlały lub modelowały otaczającą
nas rzeczywistość. Każda aplikacja jest zbiorem współdziałających ze sobą różnych
elementów. Przed rozpoczęciem projektowania aplikacji należy:
1. Zdefiniować nowy (lub zaimplementować istniejący) typ danych — klasę.
2. Zdefiniować obiekty oraz ich atrybuty.
3. Zaprojektować operacje, jakie każdy z obiektów ma wykonywać.
4. Ustalić zasady widoczności obiektów.
5. Ustalić zasady współdziałania obiektów.
6. Zaimplementować każdy z obiektów na potrzeby działania aplikacji.
7. Ustalić mechanizmy dziedziczenia obiektów.
Klasy
Klasa, definiując nowy typ (wzorzec) danych, może być źródłem definicji innych klas
pochodnych. Klasa jest jednym z podstawowych pojęć języka Object Pascal. Za pomocą
słowa kluczowego ����� definiujemy nowy typ danych, będący w istocie połączeniem
danych i instrukcji, które wykonują na nich działania, umożliwiających tworzenie
nowych (lub wykorzystanie istniejących) elementów, będących reprezentantami klasy.
W największym przybliżeniu konstrukcja klasy umożliwia deklarowanie elementów
prywatnych (ang. private), publicznych (ang. public), chronionych (ang. protected)
52 ABC Delphi 7
oraz publikowanych (ang. published). Domyślnie w standardowym języku Object
Pascal wszystkie elementy klasy traktowane są jako prywatne, co oznacza, że dostęp do
nich jest ściśle kontrolowany i żadna funkcja, nienależąca do klasy, nie może z nich
korzystać. Jeżeli w definicji klasy pojawią się elementy publiczne, oznacza to, że mogą
one uzyskiwać dostęp do innych części programu. Chronione elementy klasy dostępne
są jedynie w danej klasie lub w klasach potomnych. Ogólną postać definicji klasy można
przedstawić w sposób następujący:
������������� ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� �������!����������"������������� ��#$�������
Jeszcze kilkanaście lat temu, przed pojawieniem się wizualnych środowisk programi-stycznych, słowo obiekt (ang. object) było jednoznacznie utożsamiane z klasą. Obecniesytuacja nieco się skomplikowała, gdyż słowo obiekt ma o wiele szersze znaczenie. Z tegowzględu wygodniej jest posługiwać się szeroko stosowanym w anglojęzycznej literaturzesformułowaniem egzemplarz klasy (ang. class instance). Otóż po zdefiniowaniu klasy,tworzymy egzemplarz jej typu o nazwie takiej samej, jak nazwa klasy występująca posłowie �����. Jednak klasy tworzymy po to, by stały się specyfikatorami typów danych.Jeżeli po instrukcji definicji klasy (kończącej się słowem kluczowym ���), po słowiekluczowym �� podamy pewną nazwę, utworzymy tym samym określony egzemplarzklasy, który od tej chwili traktowany jest jako nowy, pełnoprawny typ danych.
Jako przykład zaprojektujemy bardzo prostą w budowie klasę �� ����, za pomocąktórej będziemy mogli odczytać wybrane informacje o pewnej osobie.
Deklaracja klasy �� ����, składającej się z części publicznej i prywatnej, może wy-glądać następująco:
������%&������� ������������������������������'���&������(��!�)*���+��������������������������!�)*����������
W sekcji publicznej (rozpoczynającej się od słowa kluczowego � ����) deklaracjiklasy �� ���� umieściliśmy prototyp jedynej procedury składowej klasy, natomiastw prywatnej (rozpoczynającej się od słowa kluczowego ������) umieściliśmy deklarację
Rozdział 3. ♦ Projektowanie obiektowe OOD 53
jednej zmiennej (dokładniej wskaźnika) składowej klasy. Mimo że istnieje możliwośćdeklarowania zmiennych publicznych w klasie, to jednak zalecane jest, aby dążyć dotego, by ich deklaracje były umieszczane w sekcji prywatnej, zaś dostęp do nich byłmożliwy poprzez funkcje z sekcji publicznej. Jak już się zapewne domyślamy, dostępdo wskaźnika �������� z sekcji prywatnej będzie możliwy właśnie poprzez procedurę������ ������, której jedynym parametrem jest właśnie wskaźnik. Tego typu technikaprogramowania nosi nazwę enkapsulacji danych, co oznacza, że dostęp do prywatnychdanych jest zawsze ściśle kontrolowany.
Enkapsulacja (ang. encapsulation) jest mechanizmem wiążącym instrukcje z danymii zabezpieczającym je przed ingerencją z zewnątrz i błędnym użyciem.
W ciele procedury ������ ������ dokonujemy porównania dwóch ciągów znaków,czyli łańcucha wskazywanego przez �������� oraz drugiego, odpowiadającego jużkonkretnemu nazwisku danej osoby. Jeżeli oba łańcuchy są identyczne, procedurawyświetli odpowiedni komunikat. Ponieważ omawiana procedura jest częścią klasy�� ����, to przy jej zapisie w programie musimy poinformować kompilator, iż właśniedo niej należy. W Object Pascalu służy temu celowi operator w postaci kropki (�),zwany też niekiedy operatorem rozróżniania zakresu.
����������%&�������'���&������(��!�)*���+��������������������! ����������(��������� �,-��������,+�����������-�����(,"�������������������,+��������������������(��������� �,'��������,+���������������-�����(,��������������,+�������������������������-�����(,"��������������������,+�������
Kompletny kod modułu projektu Projekt_11.dpr, korzystającego z omawianej klasy,przedstawiono na listingu 3.1.
Listing 3.1. Kod projektu Projekt_11.dpr
������ �)������.//�012))%3)��*4�&45�6������&��7����
������%&������� ������������������������������'���&������(��!�)*���+��������������������������!�)*������������888888888888888888888888888888888888888888888888888888888����������%&�������'���&������(��!�)*���+��������������������! ����������(��������� �,-��������,+�����
54 ABC Delphi 7
������-�����(,"�������������������,+��������������������(��������� �,'��������,+���������������-�����(,��������������,+�������������������������-�����(,"��������������������,+���������888888888888888888888888888888888888888888888888888888888������������ �����&������������%&��������&������!�%&�������������&������!�)*���������������&������! ,'��������,���&�������'���&������(����&������+���9���5������
Metody
Każdy wykorzystywany w programie egzemplarz klasy (lub obiekt) wykonuje (lub
my wykonujemy na nim) pewne czynności — operacje, zwane potocznie metodami.
Metodami nazywamy funkcje lub procedury, będące elementami klasy i obsługujące
obiekt przynależny do danej klasy. W przykładzie pokazanym na listingu 3.1 procedura
������ ������ jest właśnie taką metodą.
Obiekty
Obiekt jest dynamicznym egzemplarzem (reprezentantem) macierzystej klasy. Stanowi
też pewien element rzeczywistości, którą charakteryzuje określony stan, tzn. obiekt
jest aktywny lub nie. W odróżnieniu od zwykłych egzemplarzy klas, obiekty są zawsze
alokowane dynamicznie w pewnym obszarze pamięci, zwanej stertą. Jedną z najważ-
niejszych cech odróżniających obiekty od normalnych egzemplarzy klas jest to, że za
tworzenie i zwalnianie obiektów w trakcie działania programu odpowiedzialny jest
programista. Każdy obiekt tworzony jest za pomocą funkcji składowej klasy, zwanej
konstruktorem. Definicja konstruktora rozpoczyna się od słowa kluczowego ����� ���.
W Delphi domyślną nazwą konstruktora pozostaje słowo �����. W celu zwolnienia
(zniszczenia) obiektu w momencie, gdy nie jest on już potrzebny, używamy jego destruk-
tora. Definicja destruktora rozpoczyna się od słowa kluczowego ���� ���. Powszechnie
stosowaną nazwą destruktora jest słowo ������. Należy jednak pamiętać, iż jawne
wywoływanie w programie destruktora klasy wiąże się z dość poważnymi konsekwen-
cjami i wymaga pewnej wprawy, dlatego dużo bezpieczniejsze jest używanie prostej
funkcji (metody) ��� w celu zniszczenia danego obiektu.
Rozdział 3. ♦ Projektowanie obiektowe OOD 55
Na listingu 3.2 zaprezentowano zmodyfikowaną wersję poprzednio omawianego progra-
mu. W obecnej wersji tworzony jest dynamicznie egzemplarz (obiekt) klasy �� ����.
Listing 3.2. Idea tworzenia i zwalniania dynamicznego egzemplarza klasy
������ �)������.//�012))%3)��*4�&45�6������&��7����
������%&������� ���������������������������������������� ���������������������������������������*����������������������'���&������(��!�)*���+��������������������������!�)*������������888888888888888888888888888888888888888888888888888888888����������%&�������'���&������(��!�)*���+��������������������! ����������(��������� �,-��������,+�����������-�����(,"�������������������,+��������������������(��������� �,'��������,+���������������-�����(,��������������,+�������������������������-�����(,"��������������������,+���������888888888888888888888888888888888888888888888888888888888������������%&�������*������������������������������#��������������������888888888888888888888888888888888888888888888888888888888�����&������!�%&�������������&������!�)*���������������������������� ������������ ������(�������+�����&������������%&������������������&����������������������������������� ������#�����������������������%&��������&������! %&�������*������������&������! ,'��������,���&�������'���&������(����&������+���9���5�����������������(����������+���������&������������������������:�����������#����� ������;�����&�������;��������
56 ABC Delphi 7
Często początkujący programiści Delphi popełniają dość poważny błąd, polegającyna próbie utworzenia obiektu poprzez bezpośrednie odwołanie się do konstruktora
�����:
&�������*������
Zawsze należy pamiętać, iż obiekty tworzymy wyłącznie z poziomu odwołania siędo nazwy macierzystej klasy, a dopiero potem wywołujemy jej konstruktor:
&������! %&�������*������
Zwalnianie tak utworzonego obiektu odbywa się poprzez bezpośrednie wywołanie
metody ���:
&�������;����
Podczas niszczenia obiektu nie korzystamy już z odwołania do nazwy macierzystejklasy.
Widoczność obiektów
Jeżeli uznamy to za konieczne, możemy ustalić zakres widoczności obiektów w odnie-
sieniu do fragmentu programu. Obiekt taki będzie korzystał ze zmiennych dostępnych
jedynie dla metod klasy, w której je zdefiniowano.
Współdziałanie obiektów
Jeżeli obiekt lub grupę obiektów uczynimy widocznymi w całej aplikacji, należy ustalić
zasady porozumiewania się obiektów, czyli relacje pomiędzy nimi. Dla każdego z obiek-
tów ustanawiamy ściśle określony zbiór reguł i funkcji, dzięki którym korzystać z niego
mogą inne obiekty.
Implementacja obiektu
Implementacja, czyli oprogramowanie obiektu, oznacza stworzenie kodu źródłowego,
obsługującego metody z nim związane. Korzystając z zasad programowania obiektowo-
zdarzeniowego, z poszczególnymi obiektami kojarzymy odpowiadające im zdarzenia.
Rozdział 3. ♦ Projektowanie obiektowe OOD 57
Własności
Nowoczesny Object Pascal wprowadza bardziej ogólne pojęcie klasy poprzez imple-
mentację własności. Własność podobna jest do pola w klasie, ale może zachowywać
się jak metoda. Własności pełnią rolę metod dostępu i modyfikacji (nazywanych me-
todami ��� i ���) i mają szczególne znaczenie w zintegrowanym środowisku progra-
misty IDE, chociaż ich użycie nie jest ograniczone tylko do niego (co wykażemy za
chwilę). Właściwość posiada mechanizmy odczytu (���) i zapisu (����), służące do
pobierania i ustawiania wartości właściwości. Mechanizmem odczytu może być na-
zwa pola lub metoda zwracająca wartość własności, natomiast mechanizmem zapisu
— nazwa pola lub metoda ustawiająca wartość pola. Zaniedbując mechanizm zapisy-
wania, tworzy się własność tylko do odczytu. Dopuszczalne jest również stworzenie
własności tylko do zapisu, jednak celowość takiego tworu jest bardzo wątpliwa. Więk-
szość mechanizmów zapisujących i odczytujących stanowią nazwy pól lub metod,
chociaż mogą to być również części pól agregujących, takich jak struktury lub tablice.
Jeżeli dyrektywa ��� lub ���� odwołuje się do elementu tablicy, indeks tablicy musi
być stały, a typ pola nie może być tablicą dynamicznie alokowaną w pamięci.
Własności mogą być definiowane przy użyciu dyrektyw ���� �� lub �����. Informa-
cja ta nie ma żadnego znaczenia dla Delphi, jednak używa się jej podczas wykonywa-
nia opisów formularzy w pliku .dfm lub .xfm. Wartością dyrektywy ���� �� jest stała
o typie takim samym, jak typ właściwości. Wartość domyślną mogą posiadać jedynie
właściwości typu wyliczeniowego, całkowitego lub zbiorowego. Dyrektywa ���� ��
posiada znaczenie tylko w przypadku właściwości publikowanych. Brak dyrektywy
���� �� równoznaczny jest nadaniu własności dyrektywy ������ ��. Wartością dy-
rektywy ����� jest stała boolowska, pole typu boolowskiego lub bezargumentowa
metoda, zwracająca wynik typu �������. Warto pamiętać, iż nadanie własności za
pomocą dyrektywy ����� wartości � � (wartości domyślnej) nie powoduje, iż taka
właśnie wartość domyślna zostanie zapisana do pliku .dfm (ewentualnie .xfm). Można
jedynie pominąć wartość własności w pliku .dfm (.xfm), nadając dyrektywie �����
wartość �����.
W celu zilustrowania metod posługiwania się własnościami zbudujemy prostą klasę,
której wykorzystanie w programie umożliwi w bardzo elegancki i przejrzysty sposób
odczytywane i zapisywanie danych w postaci nazwisk wybranych osób. W tym celu
skorzystamy z definicji własności. Ponieważ ogólnie przyjętą konwencją jest, aby w tego
typu programach posługiwać się pewnymi standardowymi przedrostkami dla zmiennych
oraz funkcji, w dalszej części opisu będziemy wykorzystywać nazewnictwo angiel-
skie po to, by nie tworzyć mieszanki nazw polskich i angielskich (np. SetNazwisko).
W pierwszej kolejności określimy własność, za pomocą której będziemy w stanie od-
czytywać i przypisywać odpowiednie wartości (w tym wypadku łańcuchy znaków re-
prezentujące nazwiska i imiona osób). Każda własność służy do przechowywania
wartości, zatem należy zadeklarować związaną z nią zmienną (tzw. pole w klasie).
Ogólnie przyjętą konwencją jest to, że zmienne mają takie same nazwy, jak związane
z nimi własności, ale poprzedzone są literą F. W naszym programie w sekcji prywatnej
definicji klasy �� ���� zadeklarujemy jedną taką zmienną typu ���� , reprezentującą
tablicę indeksującą nazwiska studentów. Dodatkowo w tej samej sekcji zadeklarujemy
58 ABC Delphi 7
funkcję (metodę) �����!���, która w przyszłości będzie odczytywała za pomocą in-
deksu imię i nazwisko wybranej osoby, oraz procedurę �����!���, za pomocą której
będzie można przypisać odpowiedni łańcuch znaków (imię i nazwisko) do odpowiedniego
indeksu w tablicy:
�������������;�� �!������</��=>����&���������������������?���� �(�!�@������+!�&����������������������&���� �(�!�@���������� ��!�&�����+�
Przechodzimy teraz do deklaracji samej własności. W tym celu należy użyć słowa klu-
czowego ������. Dla potrzeb programu wystarczy, by własność służyła wyłącznie
do przekazywania danych (imion i nazwisk osób) za pomocą indeksu. Własność zade-
klarujemy w sekcji publicznej definicji klasy. Zdefiniowana własność ��!� będzie od-
czytywać aktualny stan tablicy ���!� za pomocą dyrektywy ���, a następnie przeka-
zywać (zapisywać) ją do procedury �����!���, korzystając z dyrektywy ����:
������������������������������������������������������*��������������������������#����:����������������������������� �<�!�@������>!�&�����������?���� �����������������������������������������������&���� ��
Jednoparametrowa funkcja składowa klasy (metoda) �����!��� ma bardzo prostą budowę
i służyć będzie do odpowiedniego indeksowania nazwisk:
���������%&�������?���� �(�!�@������+!�&�����������������9����! ;�� �<�>�������
Dwuparametrowa procedura �����!��� również nie jest skomplikowana i przypisuje
odpowiedniemu indeksowi tablicy ciąg znaków, określony przez zmienną ��!��:
����������%&�������&���� �(�!�@���������� ��!�&�����+������������;�� �<�>! �� ���������
Kompletny kod projektu Projekt_12.dpr, wykorzystującego własność w klasie, poka-
zany jest na listingu 3.3.
Listing 3.3. Praktyczny sposób posługiwania się własnościami w klasie
������ �)������./A�012))%3)��*4�&45�6������&��7����
������%&������� ����������������������;�� �!������</��=>����&���������������������?���� �(�!�@������+!�&����������������������&���� �(�!�@���������� ��!�&�����+�
Rozdział 3. ♦ Projektowanie obiektowe OOD 59
����������������������������������������������������������*��������������������������#����:����������������������������� �<�!�@������>!�&�����������?���� �����������������������������������������������&���� ����������888888888888888888888888888888888888888888888888888888888���������%&�������?���� �(�!�@������+!�&�����������������9����! ;�� �<�>���������888888888888888888888888888888888888888888888888888888888����������%&�������&���� �(�!�@���������� ��!�&�����+������������;�� �<�>! �� �����������888888888888888888888888888888888888888888888888888888888������������%&�������*������������������������������#��������������������888888888888888888888888888888888888888888888888888888888�����&������!�%&����������!�@��������������&������! %&�������*������
���������#����&�������&���� ���&��������� �</>! ,-�����'��������,���&��������� �<A>! ,'�����-��������,���&��������� �<B>! ,'���C�����D���,�
���������#����&�������?���� ��������! /����B�������-�����(&��������� �<�>+�
��9���5����&�������;��������
Dziedziczenie
Dziedziczenie jest jednym z najważniejszych mechanizmów programowania zorien-
towanego obiektowo. Pozwala na przekazywanie właściwości klasy bazowej (ang. base
class) klasom pochodnym (ang. derived classes). Oznacza to, że w prosty sposób można
zbudować pewną hierarchię klas, uporządkowaną od najbardziej ogólnej do najbardziej
szczegółowej. Na takiej właśnie hierarchii klas zbudowana jest w Delphi zarówno bi-
blioteka komponentów wizualnych VCL, jak i biblioteka międzyplatformowa CLX.
60 ABC Delphi 7
Dziedziczenie (ang. inheritance) jest procesem przejmowania przez jeden obiektwłaściwości innego, umożliwiającym tym samym klasyfikowanie obiektów.
Ogólną postać definicji klasy pochodnej zapisujemy z reguły w sposób następujący:
�������������� �����(��������E������������+0��������������������������������������
Jako przykład zdefiniujemy klasę o nazwie "����, dziedziczącą po pewnej klasie ba-
zowej �� ����, która zawierać będzie zmienną prywatną ���������, przechowującą
nazwisko wybranej osoby. Ze względu na to, iż klasa "���� dziedziczy po klasie
�� ����, procedura ����"���� z klasy "���� będzie miała bezpośredni dostęp do
pola ��������� klasy bazowej. Osoby będziemy rozróżniać poprzez ich imię i nazwi-
sko oraz ocenę z wybranego przedmiotu. W ten oto sposób wszystkie interesujące nas
informacje uzyskamy, wywołując w głównym programie jedynie procedury składowe
obiektu �� ���� klasy "����, tak jak pokazano to na listingu 3.4. Chociaż program
nasz składa się z dwóch różnych klas, zawierających szereg odrębnych elementów skła-
dowych, to jedynymi obiektami, do których jawnie odwołujemy się w programie głów-
nym, są procedury składowe ������ ���� oraz ����"���� obiektu �� ���� klasy "����.
Listing 3.4. Przykład dziedziczenia klas
������ �)������./B�012))%3)��*4�&45�6������&��7����
������%&������� ������������������������������'���&������������������������;��������!�&��������������888888888888888888888888888888888888888888888888888888888���������%4�������������������������%&��������%4����� �����(%&������+����������������������������������������������������������*�����(��������!�&�����+�����������������'���4�������������888888888888888888888888888888888888888888888888888888888����������%&�������'���&���������������������(;��������� �,'�����-��������,+�����������-�����(,"�������������������,+��������������������(;��������� �,-�����'��������,+���������������-�����(,��������������,+�������������������������-�����(,"��������������������,+�������
Rozdział 3. ♦ Projektowanie obiektowe OOD 61
��888888888888888888888888888888888888888888888888888888888����������%4�����'���4�������������������(;��������� �,'�����-��������,+�����������-�����(;��������F,!����� ���@���� �����!�G,+��������������������(;��������� �,-�����'��������,+���������������-�����(;��������F,!����� ���@���� �����!�A�G,+�������������������������-�����(,"���������,+���������888888888888888888888888888888888888888888888888888888888������������%4�����*�����(��������!�&�����+������������;��������! �������������������������������#��������������������%4������������������:��H��� �:�H�����;��������������%&������������������������H���������� ������������������������888888888888888888888888888888888888888888888888888888888�����&������!�%4����������������������������� ������������ ������(�������+�����&������������%4������&������! %4�����*�����(,-�����'��������,+���&�������'���4�������&�������'���&���������9���5�����������������(����������+���������&������������������������:�����������#����� ������;�����&�������;��������
Analizując przedstawione powyżej zapisy, warto też zwrócić uwagę na sposób definicji
konstruktora klasy "����. Otóż konstruktor został definiowany z parametrem for-
malnym w postaci zmiennej ��������. W ciele konstruktora wartość tego parametru
została przypisana zamiennej ���������, zdefiniowanej w części prywatnej klasy
�� ����. Taka definicja konstruktora zapewnia możliwość wywołania go w programie
głównym, z parametrem aktualnym w postaci nazwiska interesującej nas osoby. Wszystkie
metody wykorzystywane przez powyższy program są metodami statycznymi. Oznacza to,
iż kompilator Delphi łączy ich wywołanie z implementacją metody.
Programując hierarchiczną strukturę klas, zawsze należy pamiętać, że klasa bazowatworzona jest tylko wówczas, gdy konstruktor klasy potomnej wywoła konstruktorklasy bazowej. Delphi zawsze w pierwszej kolejności wywołuje konstruktor klasypotomnej. Każda klasa potomna musi posiadać swojego przodka (swoją klasębazową). Przodek może być dowolną inną klasą bazową, występującą w łańcuchu
dziedziczenia, aż po klasę "�#���. Jeżeli klasa bazowa nie zostanie jawnie okre-
ślona, Delphi jako domyślną klasę bazową przyjmie "�#���.
62 ABC Delphi 7
Klasy abstrakcyjne
W przeciwieństwie do omawianych wcześniej metod statycznych, metody deklarowane
ze słowem kluczowym ��� �� (tzw. metody wirtualne) w klasie bazowej muszą być
zastąpione nową definicją w klasie pochodnej poprzez wykorzystanie dyrektywy ������.
Cechą charakterystyczną metod wirtualnych jest to, iż są łączone przez Delphi w trakcie
wykonywania programu. Metoda wirtualna może zostać w klasie bazowej zadeklarowana
ze słowem �������, co oznacza, iż nie może być definiowana przez tę klasę. Metoda
abstrakcyjna zadeklarowana w klasie bazowej musi być przedefiniowana (przesłonięta)
przez klasę potomną. Klasę deklarującą jedną lub więcej metod abstrakcyjnych nazy-
wamy klasą abstrakcyjną. Na listingu 3.5 zamieszczono przykład projektu wykorzystu-
jącego klasę abstrakcyjną.
Listing 3.5. Zmodyfikowany Projekt_13.dpr, posługujący się klasą abstrakcyjną
������ �)������./B�012))%3)��*4�&45�6������&��7����
������%&������� ������������������������������'���&������������������������������������������;��������!�&��������������888888888888888888888888888888888888888888888888888888888���������%4���������������������������������������%&��������%4����� �����(%&������+���������������������������*�����(��������!�&�����+�����������������'���&���������������������������������'���4�������������888888888888888888888888888888888888888888888888888888888���2������������ ������'���&��������������%&����������������������������������� �� ����������������������� ����%4��������������%4�����'���&���������������������(;��������� �,'�����-��������,+�����������-�����(,"�������������������,+��������������������(;��������� �,-�����'��������,+���������������-�����(,��������������,+�������������������������-�����(,"��������������������,+���������888888888888888888888888888888888888888888888888888888888����������%4�����'���4�������������������(;��������� �,'�����-��������,+�����������-�����(;��������F,!����� ���@���� �����!�G,+
Rozdział 3. ♦ Projektowanie obiektowe OOD 63
��������������������(;��������� �,-�����'��������,+���������������-�����(;��������F,!����� ���@���� �����!�A�G,+�������������������������-�����(,"���������,+���������888888888888888888888888888888888888888888888888888888888������������%4�����*�����(��������!�&�����+������������;��������! ������������������888888888888888888888888888888888888888888888888888888888�����&������!�%4������������&������! %4�����*�����(,-�����'��������,+���&�������'���4�������&�������'���&���������9���5����&�������;��������
Podsumowanie
W rozdziale tym przypomniano podstawowe terminy, z którymi spotykamy się w trakcie
projektowania aplikacji. Przedstawione tu podstawowe wiadomości na temat budowy
klas oraz praktycznego wykorzystania ich elementów okażą się bardzo pomocne w trakcie
studiowania dalszej części książki.