Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00390 008790 10443495 na godz. na dobę w sumie
ABC Delphi 7 - książka
ABC Delphi 7 - książka
Autor: Liczba stron: 168
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-269-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> delphi - programowanie
Porównaj ceny (książka, ebook, audiobook).
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: 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.
Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI ABC Delphi 7 KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE 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. ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Spis treści Wstęp ...................................................z............................................ 7 Rozdział 1. Elementarz Object Pascala...................................................z.............. 9 Moduły ...................................................r...................................................r..........................9 Program główny ...................................................r...................................................r..........10 Stałe...................................................r...................................................r.............................12 Zmienne...................................................r...................................................r.......................13 Typy całkowite...................................................r...................................................r............14 Typy rzeczywiste...................................................r...................................................r.........15 Typ Currency.......................................r...................................................r...........................16 Typy logiczne...................................................r...................................................r..............16 Typy znakowe ...................................................r...................................................r.............17 Typy łańcuchowe ...................................................r...................................................r........17 Literały łańcuchowe ...................................................r...................................................r....18 Typ okrojony ...................................................r...................................................r...............18 Typ mnogościowy ...................................................r...................................................r.......19 Typ wyliczeniowy ...................................................r...................................................r.......19 Tablice...................................................r...................................................r.........................20 Rekordy ...................................................r...................................................r.......................21 Operatory...................................................r...................................................r.....................23 Wskazania i adresy...................................................r...................................................r......24 Instrukcje sterujące przebiegiem programu ...................................................r...................26 Instrukcja warunkowa If…Then ...................................................r..............................26 Instrukcja warunkowa Case…Of ...................................................r.............................27 Instrukcja iteracyjna Repeat…Until ...................................................r........................28 Instrukcja iteracyjna While…Do ...................................................r.............................29 Instrukcja iteracyjna For…To…Do ...................................................r.........................29 Procedura przerwania programu Break ...................................................r...................30 Procedura przerwania programu Exit ...................................................r......................31 Procedura wyjścia z programu Halt ...................................................r.........................31 Procedura zatrzymania programu RunError ...................................................r............31 Procedura kontynuacji programu Continue ...................................................r.............32 Rekordy z wariantami ...................................................r...................................................r.32 Procedury ...................................................r...................................................r....................34 Parametry formalne...................................................r..................................................34 4 ABC Delphi 7 Funkcje ...................................................r...................................................r........................36 Operacje zmiennoprzecinkowe ...................................................r......................................37 Moduły na poważnie ...................................................r...................................................r...41 Podsumowanie ...................................................r...................................................r............43 Rozdział 2. Zmienne o typie modyfikowalnym w czasie wykonywania programu... 45 Rekord TVarData ...................................................r...................................................r........45 Tablice wariantowe ...................................................r...................................................r.....47 Podsumowanie ...................................................r...................................................r............50 Rozdział 3. Projektowanie obiektowe OOD ...................................................z...... 51 Klasy................................................r...................................................r...............................51 Metody ...................................................r...................................................r........................54 Obiekty ...................................................r...................................................r........................54 Widoczność obiektów ...................................................r...................................................r.56 Współdziałanie obiektów ...................................................r...............................................56 Implementacja obiektu ...................................................r...................................................r56 Własności ...................................................r...................................................r....................57 Dziedziczenie ...................................................r...................................................r..............59 Klasy abstrakcyjne ...................................................r...................................................r......62 Podsumowanie ...................................................r...................................................r............63 Rozdział 4. Środowisko programisty — IDE ...................................................z..... 65 Biblioteka VCL ...................................................r...................................................r...........67 Karta Standard ...................................................r...................................................r......68 Karta Additional...................................................r...................................................r....69 Karta Win32...................................................r...................................................r..........72 Karta System ...................................................r...................................................r.........74 Karta Dialogs ...................................................r...................................................r........75 Biblioteka CLX ...................................................r...................................................r...........76 Karta Additional...................................................r...................................................r....76 Karta System ...................................................r...................................................r.........77 Karta Dialogs ...................................................r...................................................r........77 Podsumowanie ...................................................r...................................................r............77 Rozdział 5. Object Pascal w wydaniu Delphi ...................................................z.... 79 Formularz ............................................r...................................................r...........................79 Zdarzenia...................................................r...................................................r.....................81 Wykorzystujemy własne funkcje i procedury ...................................................r................86 Metody przeciążane...................................................r...................................................r.....88 Wyjątki ...................................................r...................................................r........................91 Operacje na plikach — część I ...................................................r.......................................95 Operacje na plikach — część II...................................................r......................................98 Operacje na plikach — część III ...................................................r..................................101 Strukturalna obsługa wyjątków...................................................r....................................107 Tablice otwarte...................................................r...................................................r..........108 Tablice dynamiczne...................................................r...................................................r...109 Typ OleVariant...................................................r...................................................r..........109 Drukowanie ...................................................r...................................................r...............112 Rekordy w Delphi ...................................................r...................................................r.....114 Podsumowanie ...................................................r...................................................r..........121 Spis treści 5 Rozdział 6. Biblioteka VCL...................................................z............................ 123 Komponenty TActionList, TImageList, TOpenDialog, TSaveDialog i TMainMenu ....123 Komponenty TActionManager i TActionMainMenuBar ...............................................129 Klasa TMediaPlayer...................................................r...................................................r..134 Podsumowanie ...................................................r...................................................r..........137 Rozdział 7. Biblioteka CLX...................................................z............................ 139 Komponenty TTimer i TLCDNumber ...................................................r.........................139 Pliki i katalogi ...................................................r...................................................r...........143 Znaki wielobajtowe...................................................r................................................144 Komponenty klas TDirectoryTreeView i TFileListView ...............................................144 Podsumowanie ...................................................r...................................................r..........147 Rozdział 8. Komponentowy model Delphi...................................................z....... 149 Tworzenie i instalacja własnego komponentu ...................................................r.............149 Modyfikacja istniejącego komponentu z biblioteki VCL/CLX ......................................156 Podsumowanie ...................................................r...................................................r..........160 Skorowidz...................................................z................................... 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 aplikaceji należy: 1. Zdefiniować nowy (lub zaimplementować istniejący) typ edanych — klasę. 2. Zdefiniować obiekty oraz ich atrybuty. 3. Zaprojektować operacje, jakie każdy z obiektów ma wykeonywać. 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łaniea 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 ENCUU 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: V[RG 0CYC-NCU[ENCUU RTKXCVG RT[YCVPGFCPGKHWPMELG RTQVGEVGF EJTQPKQPGFCPGKHWPMELG RWDNKE RWDNKEPGFCPGKHWPMELG RWDNKUJGF RWDNKMQYCPGFCPGKHWPMELG GPF  XCT  IGORNCT-NCU[0CYC-NCU[ $GIKP RTQITCOIđÎYP[ PF Jeszcze kilkanaście lat temu, przed pojawieniem się wizualnych środowisk programi- stycznych, słowo obiekt (ang. object) było jednoznacznie utożsamiane z klasą. Obecnie sytuacja nieco się skomplikowała, gdyż słowo obiekt ma o wiele szersze znaczenie. Z tego względu wygodniej jest posługiwać się szeroko stosowanym w anglojęzycznej literaturze sformułowaniem egzemplarz klasy (ang. class instance). Otóż po zdefiniowaniu klasy, tworzymy egzemplarz jej typu o nazwie takiej samej, jak nazwa klasy występująca po słowie ENCUU. 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 GPF), po słowie kluczowym XCT podamy pewną nazwę, utworzymy tym samym określony egzemplarz klasy, który od tej chwili traktowany jest jako nowey, pełnoprawny typ danych. Jako przykład zaprojektujemy bardzo prostą w budowie klasę 65VWFGPV, za pomocą której będziemy mogli odczytać wybrane informacje o peewnej osobie. Deklaracja klasy 65VWFGPV, składającej się z części publicznej i prywatnej, może wy- glądać następująco: V[RG 65VWFGPVENCUU RWDNKE RTQEGFWTG,CMK5VWFGPV LU2 JCT  RTKXCVG 0CYKUMQ2 JCT GPF W sekcji publicznej (rozpoczynającej się od słowa kluczowego RWDNKE) deklaracji klasy 65VWFGPV umieściliśmy prototyp jedynej procedury składowej klasy, natomiast w prywatnej (rozpoczynającej się od słowa kluczowego RTKXCVG) 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ć do tego, 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ęp do wskaźnika 0CYKUMQ z sekcji prywatnej będzie możliwy właśnie poprzez procedurę ,CMK5VWFGPV , której jedynym parametrem jest właśnie wskaźnik. Tego typu technika programowania nosi nazwę enkapsulacji danych, co oznacza, że dostęp do prywatnych danych jest zawsze ściśle kontrolowany. Enkapsulacja (ang. encapsulation) jest mechanizmem wiążącym instrukcje z danymi i zabezpieczającym je przed ingerencją z zewnątrz is błędnym użyciem. W ciele procedury ,CMK5VWFGPV dokonujemy porównania dwóch ciągów znaków, czyli łańcucha wskazywanego przez 0CYKUMQ oraz drugiego, odpowiadającego już konkretnemu nazwisku danej osoby. Jeżeli oba łańcuchy są identyczne, procedura wyświetli odpowiedni komunikat. Ponieważ omawiana procedura jest częścią klasy 65VWFGPV, to przy jej zapisie w programie musimy poinformować kompilator, iż właśnie do niej należy. W Object Pascalu służy temu celowi operator w postaci kropki (), zwany też niekiedy operatorem rozróżniania zakresu. RTQEGFWTG65VWFGPV,CMK5VWFGPV LU2 JCT  DGIKP PCYKUMQLU KH 0CYKUMQ 9CEMQYUMK VJGP 9TKVGNP $CTFQFQDT[UVWFGPV GNUG KH 0CYKUMQ ,CPMQYUMK VJGP 9TKVGNP -KGRUMKUVWFGPV GNUG 9TKVGNP $TCMVCMKGIQUVWFGPVC  GPF 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 RTQITCO2TQLGMVA ]#226;2  1051. _ WUGU 5[U7VKNU V[RG 65VWFGPVENCUU RWDNKE RTQEGFWTG,CMK5VWFGPV LU2 JCT  RTKXCVG 0CYKUMQ2 JCT GPF  RTQEGFWTG65VWFGPV,CMK5VWFGPV LU2 JCT  DGIKP PCYKUMQLU KH 0CYKUMQ 9CEMQYUMK VJGP 54 ABC Delphi 7 9TKVGNP $CTFQFQDT[UVWFGPV GNUG KH 0CYKUMQ ,CPMQYUMK VJGP 9TKVGNP -KGRUMKUVWFGPV GNUG 9TKVGNP $TCMVCMKGIQUVWFGPVC  GPF  XCT GIGORNCT5VWFGPVMNCU[65VWFGPV 5VWFGPV65VWFGPV -VQT[5VWFGPV2 JCT DGIKP -VQT[5VWFGPV ,CPMQYUMK  5VWFGPV,CMK5VWFGPV -VQT[5VWFGPV  4GCF.0 GPF 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 ,CMK5VWFGPV 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 EQPUVTWEVQT. W Delphi domyślną nazwą konstruktora pozostaje słowo TGCVG. 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 FGUVWEVQT. Powszechnie stosowaną nazwą destruktora jest słowo GUVTQ[. 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) (TGG 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 65VWFGPV. Listing 3.2. Idea tworzenia i zwalniania dynamicznego egzemplartza klasy RTQITCO2TQLGMVA ]#226;2  1051. _ WUGU 5[U7VKNU V[RG 65VWFGPVENCUU RWDNKE FGMNCTCELCDGRCTCOGVTQYGIQMQPUVTWMVQTC EQPUVTWEVQT TGCVG RTQEGFWTG,CMK5VWFGPV LU2 JCT  RTKXCVG 0CYKUMQ2 JCT GPF  RTQEGFWTG65VWFGPV,CMK5VWFGPV LU2 JCT  DGIKP PCYKUMQLU KH 0CYKUMQ 9CEMQYUMK VJGP 9TKVGNP $CTFQFQDT[UVWFGPV GNUG KH 0CYKUMQ ,CPMQYUMK VJGP 9TKVGNP -KGRUMKUVWFGPV GNUG 9TKVGNP $TCMVCMKGIQUVWFGPVC  GPF  EQPUVTWEVQT65VWFGPV TGCVG DGIKP QRELQPCNPKGEKCđQMQPUVTWMVQTC GPF  XCT 5VWFGPV65VWFGPV -VQT[5VWFGPV2 JCT DGIKP VYQTGPKGF[PCOKEPGIQGIGORNCTC QDKGMVW 5VWFGPVMNCU[65VWFGPV QDKGMV5VWFGPVVYQTQP[LGUVCYUGRQKQOWQFYQđCPKC FQPCY[MNCU[65VWFGPV 5VWFGPV65VWFGPV TGCVG -VQT[5VWFGPV ,CPMQYUMK  5VWFGPV,CMK5VWFGPV -VQT[5VWFGPV  4GCF.0 YCNPKCPKG PKUEGPKG QDKGMVW5VWFGPV RQRTGDGRQħTGFPKGY[YQđCPKGOGVQF[(TGG 5VWFGPV(TGG GPF 56 ABC Delphi 7 Często początkujący programiści Delphi popełniają dość poważny błąd, polegający na próbie utworzenia obiektu poprzez bezpośrednie osdwołanie się do konstruktora TGCVG: 5VWFGPV TGCVG Zawsze należy pamiętać, iż obiekty tworzymy wyłącznie z poziomu odwołania się do nazwy macierzystej klasy, a dopiero potem wywołujsemy jej konstruktor: 5VWFGPV65VWFGPV TGCVG Zwalnianie tak utworzonego obiektu odbywa się poprzez bezpośrednie wywołanie metody (TGG: 5VWFGPV(TGG Podczas niszczenia obiektu nie korzystamy już z odwołania do nazwy macierzystej klasy. 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 kojarzymye 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 )GV i 5GV) 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 (TGCF) i zapisu (YTKVG), 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 TGCF lub YTKVG odwołuje się do elementu tablicy, indeks tablicy musie być stały, a typ pola nie może być tablicą dynamiczniee alokowaną w pamięci. Własności mogą być definiowane przy użyciu dyrektyw FGHCWNV lub UVQTGF. 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 FGHCWNV 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 FGHCWNV posiada znaczenie tylko w przypadku właściwości publikowanych. Brak dyrektywy FGHCWNV równoznaczny jest nadaniu własności dyrektywy PQFGHCWNV. Wartością dy- rektywy UVQTGF jest stała boolowska, pole typu boolowskiego lub bezargumentowa metoda, zwracająca wynik typu DQQNGCP. Warto pamiętać, iż nadanie własności za pomocą dyrektywy UVQTGF wartości VTWG (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 UVQTGF wartość HCNUG. 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 ei 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 65VWFGPV zadeklarujemy jedną taką zmienną typu 5VTKPI, reprezentującą tablicę indeksującą nazwiska studentów. Dodatkowo w tej samej sekcji zadeklarujemy 58 ABC Delphi 7 funkcję (metodę) )GV0COG , która w przyszłości będzie odczytywała za pomocą in- deksu imię i nazwisko wybranej osoby, oraz procedurę 5GV0COG , za pomocą której będzie można przypisać odpowiedni łańcuch znaków (imię i nazwisko) do odpowiedniego indeksu w tablicy: RTKXCVG (0COGCTTC[=?QH5VTKPI HWPEVKQP)GV0COG K+PVGIGT 5VTKPI RTQEGFWTG5GV0COG K+PVGIGTPCOGU5VTKPI  Przechodzimy teraz do deklaracji samej własności. W tym celu należy użyć słowa klu- czowego RTQRGTV[. 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ść 0COG będzie od- czytywać aktualny stan tablicy (0COG za pomocą dyrektywy TGCF, a następnie przeka- zywać (zapisywać) ją do procedury 5GV0COG , korzystając z dyrektywy YTKVG: RWDNKE FGMNCTCELCMQPUVTWMVQTC EQPUVTWEVQT TGCVG FGMNCTCELCYđCUPQħEKVCDNKEQYGL RTQRGTV[0COG=K+PVGIGT?5VTKPITGCF)GV0COG YTKVG5GV0COG Jednoparametrowa funkcja składowa klasy (metoda) )GV0COG ma bardzo prostą budowę i służyć będzie do odpowiedniego indeksowania nazwisk:e HWPEVKQP65VWFGPV)GV0COG K+PVGIGT 5VTKPI DGIKP 4GUWNV(0COG=K? GPF Dwuparametrowa procedura 5GV0COG również nie jest skomplikowana i przypisuje odpowiedniemu indeksowi tablicy ciąg znaków, określoeny przez zmienną PCOGU: RTQEGFWTG65VWFGPV5GV0COG K+PVGIGTPCOGU5VTKPI  DGIKP (0COG=K?PCOGU GPF 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 tklasie RTQITCO2TQLGMVA ]#226;2  1051. _ WUGU 5[U7VKNU V[RG 65VWFGPVENCUU RTKXCVG (0COGCTTC[=?QH5VTKPI HWPEVKQP)GV0COG K+PVGIGT 5VTKPI RTQEGFWTG5GV0COG K+PVGIGTPCOGU5VTKPI  Rozdział 3. ♦ Projektowanie obiektowe OOD 59 RWDNKE FGMNCTCELCMQPUVTWMVQTC EQPUVTWEVQT TGCVG FGMNCTCELCYđCUPQħEKVCDNKEQYGL RTQRGTV[0COG=K+PVGIGT?5VTKPITGCF)GV0COG YTKVG5GV0CNOG GPF  HWPEVKQP65VWFGPV)GV0COG K+PVGIGT 5VTKPI DGIKP 4GUWNV(0COG=K? GPF  RTQEGFWTG65VWFGPV5GV0COG K+PVGIGTPCOGU5VTKPI  DGIKP (0COG=K?PCOGU GPF  EQPUVTWEVQT65VWFGPV TGCVG DGIKP QRELQPCNPKGEKCđQMQPUVTWMVQTC GPF  XCT 5VWFGPV65VWFGPV K+PVGIGT DGIKP 5VWFGPV65VWFGPV TGCVG Y[YQđWLG5VWFGPV5GV0COG 5VWFGPV0COG=? 9CEGM,CPMQYUMK  5VWFGPV0COG=? ,CPGM9CEMQYUMK  5VWFGPV0COG=? ,QNCĐQDWKēUMC  Y[YQđWLG5VWFGPV)GV0COG HQTKVQFQ 9TKVGNP 5VWFGPV0COG=K?  4GCF.0 5VWFGPV(TGG GPF 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 emiędzyplatformowa CLX. 60 ABC Delphi 7 Dziedziczenie (ang. inheritance) jest procesem przejmowania przez jeden obiekt właściwości innego, umożliwiającym tym samym klasyfiksowanie obiektów. Ogólną postać definicji klasy pochodnej zapisujemy z reguły w sposób następujący: 0CYC0QYGL-NCU[ENCUU 0CYC-NCU[ KGFKEQPGL ] FGMNCTCELGUGMELKYPQYGLMNCUKG GPF Jako przykład zdefiniujemy klasę o nazwie 61EGPC, dziedziczącą po pewnej klasie ba- zowej 65VWFGPV, która zawierać będzie zmienną prywatną (0CYKUMQ, przechowującą nazwisko wybranej osoby. Ze względu na to, iż klasa 61EGPC dziedziczy po klasie 65VWFGPV, procedura ,CMC1EGPC z klasy 61EGPC będzie miała bezpośredni dostęp do pola (0CYKUMQ 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 5VWFGPV klasy 61EGPC, 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 ,CMK5VWFGPV oraz ,CMC1EGPC obiektu 5VWFGPV klasy 61EGPC. Listing 3.4. Przykład dziedziczenia klas RTQITCO2TQLGMVA ]#226;2  1051. _ WUGU 5[U7VKNU V[RG 65VWFGPVENCUU RWDNKE RTQEGFWTG,CMK5VWFGPV RTKXCVG (0CYKUMQ5VTKPI GPF  -NCUC61EGPCFKGFKE[RQMNCUKG65VWFGPV 61EGPCENCUU 65VWFGPV RWDNKE FGMNCTCELCMQPUVTWMVQTC EQPUVTWEVQT TGCVG 0CYKUMQ5VTKPI  RTQEGFWTG,CMC1EGPC GPF  RTQEGFWTG65VWFGPV,CMK5VWFGPV DGIKP KH (0CYKUMQ ,CPGM9CEMQYUMK VJGP 9TKVGNP $CTFQFQDT[UVWFGPV GNUG KH (0CYKUMQ 9CEGM,CPMQYUMK VJGP 9TKVGNP -KGRUMKUVWFGPV GNUG 9TKVGNP $TCMVCMKGIQUVWFGPVC  GPF Rozdział 3. ♦ Projektowanie obiektowe OOD 61  RTQEGFWTG61EGPC,CMC1EGPC DGIKP KH (0CYKUMQ ,CPGM9CEMQYUMK VJGP 9TKVGNP (0CYKUMQ  ICOKP+PHQTOCV[MC GNUG KH (0CYKUMQ 9CEGM,CPMQYUMK VJGP 9TKVGNP (0CYKUMQ  ICOKP+PHQTOCV[MC GNUG 9TKVGNP $TCMQEGP[  GPF  EQPUVTWEVQT61EGPC TGCVG 0CYKUMQ5VTKPI  DGIKP (0CYKUMQ0CYKUMQ QRELQPCNPKGEKCđQMQPUVTWMVQTCMNCU[61EGPC YCTVQħEKæFQO[ħNPæRQNC(0CYKUMQMNCU[65VWFGPVN RTGMC[YCPæLCMQCTIWOGPVMQPUVTWMVQTC GPF  XCT 5VWFGPV61EGPC DGIKP VYQTGPKGF[PCOKEPGIQGIGORNCTC QDKGMVW 5VWFGPVMNCU[61EGPC 5VWFGPV61EGPC TGCVG 9CEGM,CPMQYUMK  5VWFGPV,CMC1EGPC 5VWFGPV,CMK5VWFGPV 4GCF.0 YCNPKCPKG PKUEGPKG QDKGMVW5VWFGPV RQRTGDGRQħTGFPKGY[YQđCPKGOGVQF[(TGG 5VWFGPV(TGG GPF Analizując przedstawione powyżej zapisy, warto też zwrócić uwagę na sposób definicji konstruktora klasy 61EGPC. Otóż konstruktor został definiowany z parametrem for- malnym w postaci zmiennej 0CYKUMQ. W ciele konstruktora wartość tego parametru została przypisana zamiennej (0CYKUMQ, zdefiniowanej w części prywatnej klasy 65VWFGPV. 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 implementeacją metody. Programując hierarchiczną strukturę klas, zawsze należy pamiętać, że klasa bazowa tworzona jest tylko wówczas, gdy konstruktor klasy potomnej wywoła konstruktor klasy bazowej. Delphi zawsze w pierwszej kolejności wywołuje konstruktor klasy potomnej. 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ę 61DLGEV. Jeżeli klasa bazowa nie zostanie jawnie okre- ślona, Delphi jako domyślną klasę bazową przyjmie 61DLGEV. 62 ABC Delphi 7 Klasy abstrakcyjne W przeciwieństwie do omawianych wcześniej metod statycznych, metody deklarowane ze słowem kluczowym XKTVWCN (tzw. metody wirtualne) w klasie bazowej muszą być zastąpione nową definicją w klasie pochodnej poprzez wykorzystanie dyrektywy QXGTTKFG. 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 CDUVTCEV, 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ą abtstrakcyjną RTQITCO2TQLGMVA ]#226;2  1051. _ WUGU 5[U7VKNU V[RG 65VWFGPVENCUU RWDNKE RTQEGFWTG,CMK5VWFGPVXKTVWCNCDUVTCEV RTKXCVG (0CYKUMQ5VTKPI GPF  -NCUC61EGPCFKGFKE[RQMNCUKGCDUVTCME[LPGLN65VWFGPV 61EGPCENCUU 65VWFGPV RWDNKE EQPUVTWEVQT TGCVG 0CYKUMQ5VTKPI  RTQEGFWTG,CMK5VWFGPVQXGTTKFG RTQEGFWTG,CMC1EGPC GPF  #DUVTCME[LPCOGVQFC,CMK5VWFGPVMNCU[65VWFGPV RTGFGHKPKQYCPCLGUVKCKORNGOGPVQYCPCY MNCUKGRQVQOPGL61EGPC RTQEGFWTG61EGPC,CMK5VWFGPV DGIKP KH (0CYKUMQ ,CPGM9CEMQYUMK VJGP 9TKVGNP $CTFQFQDT[UVWFGPV GNUG KH (0CYKUMQ 9CEGM,CPMQYUMK VJGP 9TKVGNP -KGRUMKUVWFGPV GNUG 9TKVGNP $TCMVCMKGIQUVWFGPVC  GPF  RTQEGFWTG61EGPC,CMC1EGPC DGIKP KH (0CYKUMQ ,CPGM9CEMQYUMK VJGP 9TKVGNP (0CYKUMQ  ICOKP+PHQTOCV[MC Rozdział 3. ♦ Projektowanie obiektowe OOD 63 GNUG KH (0CYKUMQ 9CEGM,CPMQYUMK VJGP 9TKVGNP (0CYKUMQ  ICOKP+PHQTOCV[MC GNUG 9TKVGNP $TCMQEGP[  GPF  EQPUVTWEVQT61EGPC TGCVG 0CYKUMQ5VTKPI  DGIKP (0CYKUMQ0CYKUMQ GPF  XCT 5VWFGPV61EGPC DGIKP 5VWFGPV61EGPC TGCVG 9CEGM,CPMQYUMK  5VWFGPV,CMC1EGPC 5VWFGPV,CMK5VWFGPV 4GCF.0 5VWFGPV(TGG GPF 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.
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

ABC Delphi 7
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: