Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00201 009149 10485856 na godz. na dobę w sumie
Programowanie obiektowe w Visual Basic .NET dla każdego - książka
Programowanie obiektowe w Visual Basic .NET dla każdego - książka
Autor: , , Liczba stron: 376
Wydawca: Helion Język publikacji: polski
ISBN: 83-7197-783-2 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> visual basic - programowanie
Porównaj ceny (książka, ebook, audiobook).
Visual Basic to język programowania pozwalający nawet początkującym programistom pisać zaawansowane aplikacje wykorzystujące wszystkie możliwości systemów operacyjnych z rodziny Windows. Jego kolejne wersje w coraz większym stopniu korzystały z technik programowania zorientowanego obiektowo (OOP). Najnowsza z nich, Visual Basic .NET jest uwieńczeniem tej ewolucji.

Jeśli chcesz tworzyć aplikacje w VB .NET, musisz nauczyć się programować obiektowo. Z pewnością pomoże Ci w tym książka 'Programowanie obiektowe w Visual Basic .NET'. Informacje w niej zawarte przydadzą się także, gdy zaczniesz używać innych języków programowania opartych na obiektach, takich jak C++, C# czy Java.

Ten podręcznik, łączący praktyczne ćwiczenia z niezbędną dawką przydatnej teorii, nauczy Cię samodzielnie tworzyć aplikacje używające obiektów, dziedziczenia, poliformizmu i sterowania za pomocą zdarzeń. Dowiesz się również jak obsługiwać błędy. Odrębne rozdziały poświęcono obiektom zdalnym (aplikacjom klient-serwer), udostępnianiu aplikacji poprzez Internet tworzeniu atrakcyjnego interfejsu użytkownika oraz językowi XML. Poznasz także środowisko projektowe Visual Studio .NET. Swoją wiedzę będziesz mógł sprawdzić za pomocą licznych quizów.

Książka zawiera:

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 KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE 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 Programowanie obiektowe w Visual Basic .NET dla ka¿dego Autorzy: Richard Simon, Leslie Koorhan, Ken Cox T³umaczenie: Jadwiga Gnybek ISBN: 83-7197-783-2 Tytu³ orygina³u: TY Object Oriented Programming with Visual Basic.NET in 21 Days Format: B5, stron: 374 Visual Basic to jêzyk programowania pozwalaj¹cy nawet pocz¹tkuj¹cym programistom pisaæ zaawansowane aplikacje wykorzystuj¹ce wszystkie mo¿liwoġci systemów operacyjnych z rodziny Windows. Jego kolejne wersje w coraz wiêkszym stopniu korzysta³y z technik programowania zorientowanego obiektowo (OOP). Najnowsza z nich, Visual Basic .NET jest uwieñczeniem tej ewolucji. Jeġli chcesz tworzyæ aplikacje w VB .NET, musisz nauczyæ siê programowaæ obiektowo. Z pewnoġci¹ pomo¿e Ci w tym ksi¹¿ka „Programowanie obiektowe w Visual Basic .NET”. Informacje w niej zawarte przydadz¹ siê tak¿e, gdy zaczniesz u¿ywaæ innych jêzyków programowania opartych na obiektach, takich jak C++, C# czy Java. Ten podrêcznik, ³¹cz¹cy praktyczne æwiczenia z niezbêdn¹ dawk¹ przydatnej teorii, nauczy Ciê samodzielnie tworzyæ aplikacje u¿ywaj¹ce obiektów, dziedziczenia, poliformizmu i sterowania za pomoc¹ zdarzeñ. Dowiesz siê równie¿ jak obs³ugiwaæ b³êdy. Odrêbne rozdzia³y poġwiêcono obiektom zdalnym (aplikacjom klient-serwer), udostêpnianiu aplikacji poprzez Internet tworzeniu atrakcyjnego interfejsu u¿ytkownika oraz jêzykowi XML. Poznasz tak¿e ġrodowisko projektowe Visual Studio .NET. Swoj¹ wiedzê bêdziesz móg³ sprawdziæ za pomoc¹ licznych quizów. Ksi¹¿ka zawiera: • Wprowadzenie do programowania obiektowego w Visual Basic .NET • Wyjaġnienie terminologii zwi¹zanej z programowaniem obiektowym • Omówienie ġrodowiska Visual Studio .NET oraz tworzenia interfejsów u¿ytkownika za pomoc¹ Windows Forms i WebForms • Praktyczne æwiczenia i quizy sprawdzaj¹ce wiedzê Spis treści O Autorze ........................................................................................ 11 Wstęp .............................................................................................. 13 Jak zorganizowana jest ta książka? ...................................................i................................14 Konwencje użyte w książce ...................................................i...........................................15 Rozdział 1. Programowanie zorientowane obiektowo — budowa aplikacji sterowanej zadaniami ....................................................................... 17 Tworzenie projektu ...................................................i...................................................i.....18 Definiowanie obiektu SimpleMsg...................................................i..................................19 Tworzenie obiektów w Visual Basic .NET...................................................i..............19 Dodawanie właściwości...................................................i...........................................20 Tworzenie klasy SmartMsg...................................................i............................................22 Dziedziczenie w Visual Basic .NET...................................................i........................22 Dodanie metody Write() ...................................................i..........................................23 Dodanie metody Read() ...................................................i...........................................24 Budowa obiektu MsgReader ...................................................i..........................................25 Tworzenie okna formularza ...................................................i.....................................26 Wywołanie obiektu SmartMsg ...................................................i................................28 Wyświetlanie obiektu SmartMsg...................................................i.............................29 Obsługa zdarzeń OK i Anuluj...................................................i..................................30 Łączymy wszystko w całość ...................................................i..........................................31 Sub main()...................................................i...................................................i.............31 Ustawianie parametrów startowych...................................................i.........................31 Podsumowanie ...................................................i...................................................i............32 Pytania i odpowiedzi ...................................................i...................................................i...32 Warsztaty...................................................i...................................................i.....................33 Quiz...................................................i...................................................i.......................33 Ćwiczenie...................................................i...................................................i..............33 Rozdział 2. Terminologia wykorzystywana w OOP ............................................... 35 Obiekt ...................................................i...................................................i..........................35 Klasa...................................................i...................................................i............................36 Pola i zakresy ...................................................i...................................................i..............37 Prywatne ...................................................i...................................................i...............38 Chronione...................................................i...................................................i..............39 Publiczne...................................................i...................................................i...............39 Pola statyczne...................................................i...................................................i........40 Klasy finalne i abstrakcyjne...................................................i.....................................41 Właściwości ...................................................i...................................................i................43 4 Programowanie obiektowe w Visual Basic .NET dla każdego Metody i ich działanie ...................................................i...................................................i.44 Zdarzenia i delegaty ...................................................i...................................................i....45 Konstruktory.......................................i...................................................i............................47 Destruktory...................................................i...................................................i..................48 Interfejsy.........................................i...................................................i................................49 Podsumowanie ...................................................i...................................................i............50 Pytania i odpowiedzi ...................................................i...................................................i...50 Warsztaty...................................................i...................................................i.....................51 Quiz...................................................i...................................................i.......................51 Ćwiczenie...................................................i...................................................i..............51 Rozdział 3. Zawieranie danych i cech w obiekcie ............................................... 53 Projektowanie publicznego interfejsu klasy...................................................i...................54 Ochrona pól klas......................................i...................................................i.......................55 Definiowanie prywatnych pól klasy...................................................i...............................56 Zastosowanie hermetyzacji w projektowaniu obiektów ...................................................i58 Podsumowanie ...................................................i...................................................i............64 Pytania i odpowiedzi ...................................................i...................................................i...64 Warsztaty...................................................i...................................................i.....................65 Quiz...................................................i...................................................i.......................65 Ćwiczenie...................................................i...................................................i..............65 Rozdział 4. Tworzenie nowych obiektów na bazie obiektów już istniejących......... 67 Mechanizm dziedziczenia ...................................................i..............................................68 Klasa bazowa ...................................................i...................................................i........68 Dziedziczenie klas ...................................................i...................................................i69 Dodawanie danych...................................................i...................................................i70 Dodawanie funkcji ...................................................i...................................................i70 Optymalizacja klas ...................................................i...................................................i......70 Nadpisywanie — zmiana funkcjonalności istniejących metod ..................................71 Wykorzystanie klas abstrakcyjnych...................................................i.........................72 Wykorzystanie pól chronionych ...................................................i..............................73 Wykorzystanie pól współdzielonych ...................................................i.......................73 Tworzenie klas finalnych...................................................i.........................................74 Wykorzystanie dziedziczenia w Visual Basic .NET...................................................i......75 Proste dziedziczenie klas — tworzenie klasy MailMsg .............................................75 Dziedziczenie — tworzenie formularza transakcji ...................................................i..77 Podsumowanie ...................................................i...................................................i............81 Pytania i odpowiedzi ...................................................i...................................................i...82 Warsztaty...................................................i...................................................i.....................83 Quiz...................................................i...................................................i.......................83 Ćwiczenie...................................................i...................................................i..............83 Rozdział 5. Nadawanie obiektom cech polimorficznych ....................................... 85 Zalety polimorfizmu...................................................i...................................................i....85 Wykorzystanie polimorfizmu w Visual Basic .NET...................................................i......86 Dziedziczenie polimorfizmu...................................................i....................................86 Klasy abstrakcyjne a polimorfizm ...................................................i...........................90 Polimorfizm interfejsu ...................................................i.............................................92 Podsumowanie ...................................................i...................................................i............94 Pytania i odpowiedzi ...................................................i...................................................i...95 Warsztaty...................................................i...................................................i.....................95 Quiz...................................................i...................................................i.......................95 Ćwiczenie...................................................i...................................................i..............96 Spis treści 5 Rozdział 6. Budowa obiektów złożonych poprzez łączenie obiektów..................... 97 Różnica pomiędzy kompozycją a dziedziczeniem...................................................i.........97 Asocjacja...................................................i...................................................i...............99 Agregacja ...................................................i...................................................i..............99 Kompozycja ...................................................i...................................................i..........99 Projektowanie obiektów przy użyciu kompozycji ...................................................i.......100 Podsumowanie ...................................................i...................................................i..........105 Pytania i odpowiedzi ...................................................i...................................................i.105 Warsztaty...................................................i...................................................i...................106 Quiz...................................................i...................................................i.....................106 Ćwiczenie...................................................i...................................................i............106 Rozdział 7. Poznajemy środowisko programistyczne Visual Basic .NET .............. 107 Praca w Microsoft .NET Framework ...................................................i...........................108 Common Language Runtime (CLR)...................................................i......................108 Biblioteka klas .NET...................................................i..............................................109 Praca z Visual Basic .NET IDE ...................................................i...................................109 Wykorzystanie okna Solution Explorer ...................................................i.................111 Project ...................................................i...................................................i.................112 Referencje ...................................................i...................................................i...........113 Referencje WWW...................................................i..................................................113 Toolbox ...................................................i...................................................i...............114 Form Designer ...................................................i...................................................i....115 Uruchamianie i debugowanie aplikacji ...................................................i........................117 Wykorzystywanie systemu pomocy Help Online ...................................................i........118 Podsumowanie ...................................................i...................................................i..........120 Pytania i odpowiedzi ...................................................i...................................................i.120 Warsztaty...................................................i...................................................i...................121 Quiz...................................................i...................................................i.....................121 Ćwiczenie...................................................i...................................................i............121 Rozdział 8. Typy danych w Visual Basic .NET .................................................... 123 Poznajemy typy danych Visual Basic .NET ...................................................i................124 Typ Object ...................................................i...................................................i..........124 Synonimy typów Common Numeric Data....................................................i............125 Używanie zmiennych typu łańcuch znaków (String) ...............................................126 Praca z danymi typu Data ...................................................i......................................127 Używanie zmiennych typu Boolean ...................................................i......................128 Tworzenie struktur ...................................................i.................................................128 Praca ze zmiennymi typu wyliczeniowego...................................................i............129 Używanie tablic ...................................................i...................................................i..131 Podsumowanie ...................................................i...................................................i..........132 Pytania i odpowiedzi ...................................................i...................................................i.132 Warsztaty...................................................i...................................................i...................133 Quiz...................................................i...................................................i.....................133 Ćwiczenie...................................................i...................................................i............133 Rozdział 9. Organizowanie klas w grupy ............................................................ 135 Przestrzenie nazw...................................................i...................................................i......136 Praca z przestrzeniami nazw .NET ...................................................i........................137 Używanie przestrzeni nazw ...................................................i...................................138 Tworzenie przestrzeni nazw ...................................................i..................................140 Podsumowanie ...................................................i...................................................i..........141 Pytania i odpowiedzi ...................................................i...................................................i.141 Warsztaty...................................................i...................................................i...................142 Quiz...................................................i...................................................i.....................142 Ćwiczenie...................................................i...................................................i............142 6 Programowanie obiektowe w Visual Basic .NET dla każdego Rozdział 10. Tworzenie interfejsu użytkownika .................................................... 143 Wybieramy właściwy formularz ...................................................i..................................144 Używanie formularzy Windows...................................................i...................................145 Formularze Windows...................................................i.............................................145 Tworzenie formularza Windows...................................................i............................149 Rozbudowa formularza Windows...................................................i..........................152 Formularze WWW ...................................................i...................................................i....153 Praca z formularzem WWW i ASP.NET...................................................i...............153 Tworzenie formularza WWW ASP.NET ...................................................i..............154 Podsumowanie ...................................................i...................................................i..........158 Pytania i odpowiedzi ...................................................i...................................................i.158 Warsztaty...................................................i...................................................i...................159 Quiz...................................................i...................................................i.....................159 Ćwiczenie...................................................i...................................................i............159 Rozdział 11. Tworzenie i używanie komponentów ............................................... 161 Tworzenie klas komponentów Visual Basic .NET ...................................................i......161 Komponenty...................................................i...................................................i........162 Projektowanie i implementacja komponentów...................................................i......164 Programowanie klas do użycia w trakcie pracy aplikacji ...............................................166 Klasy Reflection...................................................i...................................................i..167 Programowanie obiektów nieznanych ...................................................i...................168 Podsumowanie ...................................................i...................................................i..........170 Pytania i odpowiedzi ...................................................i...................................................i.171 Warsztaty...................................................i...................................................i...................171 Quiz...................................................i...................................................i.....................171 Ćwiczenie...................................................i...................................................i............171 Rozdział 12. Budowa aplikacji WWW .................................................................. 173 Zorientowane obiektowo aplikacje ASP.NET w Visual Basic .NET .............................173 Tworzenie projektu WWW...................................................i....................................174 Tworzenie interfejsu użytkownika...................................................i.........................174 Serwisy WWW...................................................i...................................................i..........181 Tworzenie serwisów WWW ...................................................i..................................182 Używanie serwisów WWW...................................................i...................................183 Podsumowanie ...................................................i...................................................i..........185 Pytania i odpowiedzi ...................................................i...................................................i.186 Warsztaty...................................................i...................................................i...................186 Quiz...................................................i...................................................i.....................186 Ćwiczenie...................................................i...................................................i............186 Rozdział 13. Instalacja projektów Visual Basic .NET........................................... 187 Asemblacje ...................................................i...................................................i................188 Użycie asemblacji ...................................................i...................................................i.....189 Instalowanie asemblacji ...................................................i...............................................190 Asemblacje lokalne...................................................i................................................190 Asemblacje WWW ...................................................i................................................192 Podsumowanie ...................................................i...................................................i..........195 Pytania i odpowiedzi ...................................................i...................................................i.196 Warsztaty...................................................i...................................................i...................197 Quiz...................................................i...................................................i.....................197 Ćwiczenie...................................................i...................................................i............197 Spis treści 7 Rozdział 14. Praca z interfejsami obiektów ......................................................... 199 Interfejsy i OOP ...................................................i...................................................i........199 Wielokrotne dziedziczenie...................................................i.....................................200 Polimorfizm interfejsów ...................................................i........................................201 Tworzenie interfejsu Contract...................................................i......................................202 Programowanie interfejsów...................................................i..........................................204 Implementacja interfejsów ...................................................i...........................................205 Metody ...................................................i...................................................i................205 Właściwości ...................................................i...................................................i........206 Zdarzenia...................................................i...................................................i.............207 Użycie interfejsu jako wywołania zwrotnego ...................................................i..............208 Podsumowanie ...................................................i...................................................i..........210 Pytania i odpowiedzi ...................................................i...................................................i.210 Warsztaty...................................................i...................................................i...................211 Quiz...................................................i...................................................i.....................211 Ćwiczenie...................................................i...................................................i............211 Rozdział 15. Obsługa zdarzeń, komunikatów i powiadomień ................................ 213 Powtórka wiadomości o zdarzeniach i delegatach...................................................i.......214 Obsługa prostych zdarzeń ...................................................i......................................214 Obsługa zdarzeń dynamicznych za pośrednictwem delegatów ................................215 Użycie zdarzeń i operacji asynchronicznych ...................................................i...............216 Tworzenie i użycie własnych zdarzeń i delegatów ...................................................i......219 Tworzenie własnych zdarzeń z wykorzystaniem delegatów .NET Framework .......219 Deklarowanie i użycie własnych delegatów ...................................................i..........219 Klasy delegatów...................................................i...................................................i..221 Użycie zdarzeń do powiadamiania...................................................i...............................221 Podsumowanie ...................................................i...................................................i..........226 Pytania i odpowiedzi ...................................................i...................................................i.226 Warsztaty...................................................i...................................................i...................226 Quiz...................................................i...................................................i.....................227 Ćwiczenie...................................................i...................................................i............227 Rozdział 16. Przechwytywanie błędów................................................................. 229 Strukturalna obsługa wyjątków...................................................i....................................230 Używanie poleceń Try i Catch...................................................i...............................230 Zagnieżdżona obsługa błędów...................................................i...............................232 Użycie bloku Finally...................................................i..............................................233 Generowanie wyjątków ...................................................i.........................................235 Tworzenie i użycie własnych klas wyjątków...................................................i...............238 Podsumowanie ...................................................i...................................................i..........239 Pytania i odpowiedzi ...................................................i...................................................i.239 Warsztaty...................................................i...................................................i...................240 Quiz...................................................i...................................................i.....................240 Ćwiczenia...................................................i...................................................i............240 Rozdział 17. Projektowanie i używanie obiektów zdalnych .................................. 241 Filozofia obiektów zdalnych ...................................................i........................................241 Obiekty zdalne ...................................................i...................................................i....242 Obiekty proxy ...................................................i...................................................i.....243 Aktywacja obiektu ...................................................i.................................................244 Cykl życia zdalnego obiektu...................................................i..................................244 Dynamiczne publikowanie obiektów zdalnych ...................................................i.....245 Wybór pomiędzy kopią a referencją ...................................................i............................245 Użycie kanałów w procesie komunikacji...................................................i.....................246 8 Programowanie obiektowe w Visual Basic .NET dla każdego Budowa klienta i serwera połączonych za pośrednictwem TCP.....................................247 Aplikacja serwera dla obiektów zdalnych ...................................................i.............247 Budowanie klienta wykorzystującego zdalny obiekt................................................250 Podsumowanie ...................................................i...................................................i..........253 Pytania i odpowiedzi ...................................................i...................................................i.253 Warsztaty...................................................i...................................................i...................254 Quiz...................................................i...................................................i.....................254 Ćwiczenia...................................................i...................................................i............254 Rozdział 18. Projektowanie aplikacji zarządzającej projektem ............................. 255 Spotkanie z klientem ...................................................i...................................................i.255 Domeny...................................................i...................................................i...............256 Dekompozycja modelu domen ...................................................i..............................257 Projektowanie zgodne z wymaganiami...................................................i........................258 Tworzenie projektu interakcji ...................................................i................................258 Tworzenie klas programowych z klas konceptualnych ............................................259 Podsumowanie ...................................................i...................................................i..........264 Pytania i odpowiedzi ...................................................i...................................................i.264 Warsztaty...................................................i...................................................i...................264 Quiz...................................................i...................................................i.....................265 Ćwiczenia...................................................i...................................................i............265 Rozdział 19. Tworzenie aplikacji zarządzającej projektem ................................... 267 Tworzenie modułów klas ...................................................i.............................................267 Tworzenie interfejsu...................................................i...................................................i..268 Tworzenie klas ...................................................i...................................................i..........269 Klasa Employee ...................................................i...................................................i..270 Klasy potomne ...................................................i...................................................i....274 Pozostałe klasy...................................................i...................................................i....277 Podsumowanie ...................................................i...................................................i..........283 Pytania i odpowiedzi ...................................................i...................................................i.283 Warsztaty...................................................i...................................................i...................283 Quiz...................................................i...................................................i.....................284 Ćwiczenia...................................................i...................................................i............284 Rozdział 20. Dodawanie cech funkcjonalnych do aplikacji .................................. 285 Projektowanie klas wizualnych...................................................i....................................286 Tworzenie klas wizualnych...................................................i..........................................287 Komponowanie formularza ...................................................i...................................287 Przeglądanie kodu generowanego...................................................i..........................290 Tworzenie formularza ...................................................i..................................................291 Rozmieszczanie elementów formularza pracownika................................................292 Przegląd kodu formularza pracownika ...................................................i..................294 Rozmieszczanie elementów formularza produktu ...................................................i.298 Przeglądanie kodu formularza produktu...................................................i................299 Rozmieszczanie elementów formularza projektu ...................................................i..301 Przeglądanie kodu formularza projektu ...................................................i.................302 Rozmieszczanie elementów formularza elementu projektu .....................................305 Przeglądanie kodu formularza elementu projektu ...................................................i.305 Podsumowanie ...................................................i...................................................i..........306 Pytania i odpowiedzi ...................................................i...................................................i.307 Warsztaty...................................................i...................................................i...................307 Quiz...................................................i...................................................i.....................307 Ćwiczenia...................................................i...................................................i............307 Spis treści 9 Rozdział 21. Rozszerzanie funkcjonalności aplikacji............................................ 309 Dane utrwalone ...................................................i...................................................i.........309 Wprowadzenie do XML-a...................................................i............................................310 Zasady poprawnego formatowania dokumentu XML ..............................................311 Dodatkowe narzędzia...................................................i.............................................312 Document Object Model i XPath ...................................................i.................................313 DOM ...................................................i...................................................i...................313 Odpytywanie DOM...................................................i................................................313 Model obiektów DOM...................................................i...........................................314 Kodowanie modułów klas...................................................i............................................315 Metoda Save()...................................................i...................................................i.....315 Metoda Read() ...................................................i...................................................i....320 Metoda Delete() ...................................................i...................................................i..322 Klasa Resource...................................................i...................................................i....322 Przeglądanie danych...................................................i...................................................i..323 Klasy Product, Project i ProjectItem ...................................................i............................324 Podsumowanie ...................................................i...................................................i..........325 Pytania i odpowiedzi ...................................................i...................................................i.325 Warsztaty...................................................i...................................................i...................325 Quiz...................................................i...................................................i.....................326 Ćwiczenia...................................................i...................................................i............326 Dodatek A Odpowiedzi na pytania quizu............................................................ 327 Rozdział 1., „Programowanie zorientowane obiektowo — budowai aplikacji sterowanej zadaniami”...................................................i...............................................327 Quiz...................................................i...................................................i.....................327 Ćwiczenia...................................................i...................................................i............327 Rozdział 2., „Terminologia wykorzystywana w OOP” ..................................................330 Quiz...................................................i...................................................i.....................330 Ćwiczenia...................................................i...................................................i............331 Rozdział 3., „Zawieranie danych i cech w obiekcie”...................................................i...331 Quiz...................................................i...................................................i.....................331 Ćwiczenia...................................................i...................................................i............331 Rozdział 4., „Tworzenie nowych obiektów na bazie obiektów już istniejących” ..........332 Quiz...................................................i...................................................i.....................332 Ćwiczenia...................................................i...................................................i............332 Rozdział 5., „Nadawanie obiektom cech polimorficznych” ...........................................334 Quiz...................................................i...................................................i.....................334 Ćwiczenia...................................................i...................................................i............334 Rozdział 6., „Budowa obiektów złożonych poprzez łączenie obiektów”.......................336 Quiz...................................................i...................................................i.....................336 Ćwiczenia...................................................i...................................................i............336 Rozdział 7., „Poznajemy środowisko programistyczne Visual Basic .NET” .................337 Quiz...................................................i...................................................i.....................337 Ćwiczenia...................................................i...................................................i............337 Rozdział 8., „Typy danych w Visual Basic .NET” ...................................................i......338 Quiz...................................................i...................................................i.....................338 Ćwiczenia...................................................i...................................................i............338 Rozdział 9., „Organizowanie klas w grupy” ...................................................i................339 Quiz...................................................i...................................................i.....................339 Ćwiczenia...................................................i...................................................i............339 Rozdział 10., „Tworzenie interfejsu użytkownika” ...................................................i.....339 Quiz...................................................i...................................................i.....................339 Ćwiczenia...................................................i...................................................i............340 10 Programowanie obiektowe w Visual Basic .NET dla każdego Rozdział 11., „Tworzenie i używanie komponentów”...................................................i.340 Quiz...................................................i...................................................i.....................340 Ćwiczenia...................................................i...................................................i............341 Rozdział 12., „Budowa aplikacji WWW”...................................................i....................342 Quiz...................................................i...................................................i.....................342 Ćwiczenia...................................................i...................................................i............342 Rozdział 13., „Instalowanie projektów .NET Visual Basic” ..........................................343 Quiz...................................................i...................................................i.....................343 Ćwiczenia...................................................i...................................................i............343 Rozdział 14., „Praca z interfejsami obiektów” ...................................................i............344 Quiz...................................................i...................................................i.....................344 Ćwiczenia...................................................i...................................................i............344 Rozdział 15., „Obsługa zdarzeń, komunikatów i powiadomień” ...................................344 Quiz...................................................i...................................................i.....................344 Ćwiczenia...................................................i...................................................i............345 Rozdział 16., „Przechwytywanie błędów”...................................................i...................346 Quiz...................................................i...................................................i.....................346 Ćwiczenia...................................................i...................................................i............346 Rozdział 17., „Projektowanie i używanie obiektów zdalnych” ......................................347 Quiz...................................................i...................................................i.....................347 Ćwiczenia...................................................i...................................................i............347 Rozdział 18., „Projektowanie aplikacji zarządzającej projektem” .................................348 Quiz...................................................i...................................................i.....................348 Ćwiczenia...................................................i...................................................i............349 Rozdział 19., „Tworzenie aplikacji zarządzającej projektem” .......................................350 Quiz...................................................i...................................................i.....................350 Ćwiczenia...................................................i...................................................i............350 Rozdział 20., „Dodawanie cech funkcjonalnych do aplikacji”.......................................351 Quiz...................................................i...................................................i.....................351 Ćwiczenia...................................................i...................................................i............351 Rozdział 21., „Rozszerzanie funkcjonalności aplikacji” ................................................352 Quiz...................................................i...................................................i.....................352 Ćwiczenia...................................................i...................................................i............352 Dodatek B Pies... z klasą ................................................................................. 355 Tworzenie klasy bazowej ...................................................i.............................................356 Wykorzystanie klasy bazowej...................................................i......................................357 Rozwijając „pieską logikę” ...................................................i..........................................358 Podsumowanie ...................................................i...................................................i..........360 Skorowidz....................................................................................... 361 Rozdział 14. Praca z interfejsami obiektów W poprzednich wersjach Visual Basica jedynie interfejsy dawały możliwość zastoso- wania polimorfizmu. Visual Basic .NET może realizować polimorfizm poprzez inter- fejsy lub mechanizm dziedziczenia. Użycie interfejsów czy dziedziczenia jest kwestią wyboru pomiędzy realizacją podstawowych i specyficznych funkcji. Zwykle dziedzi- czenie używane jest w przypadku, gdy podstawowa funkcjonalność realizowana jest w klasach bazowych, natomiast klasy potomne jedynie ją rozszerzają. Interfejsy zaś są optymalnym rozwiązaniem w przypadku, gdy potrzebna jest podobna funkcjonal- ność w różnych implementacjach kilku klas mających ze isobą niewiele wspólnego. W rozdziale tym przyjrzymy się bliżej roli interfejsów w Visual Basic .NET i sposo- bom ich najwłaściwszego wykorzystania w aplikacjach .NET. Ponieważ w poprzed- nich rozdziałach omówione zostały podstawowe zagadnienia związane z budowaniem interfejsów, teraz naszą uwagę skupimy na sposobach ich najlepszego wykorzystania. Omówimy więc sposoby:     definiowania interfejsów, dziedziczenia pomiędzy interfejsami, implementacji interfejsów wewnątrz definicji klas, rozpoznawania sytuacji, w której wykorzystanie interfiejsu jest najlepszym rozwiązaniem,  użycia interfejsów do połączeń zwrotnych. Interfejsy i OOP Interfejsy, podobnie jak klasy, definiują zbiór właściwości, metod i zdarzeń. Różnica pomiędzy nimi polega na tym, że interfejsy same w sobie nie definiują implementacji, natomiast to klasy, które je wykorzystują, muszą zapewniić ich implementację. 200 Programowanie obiektowe w Visual Basic .NET dla każdego Podstawową zaletą interfejsów jest to, że umożliwiają budowę systemu z opisa- nych przez interfejsy programowych komponentów, których właściwa imple- mentacja może być zmieniana bez zmiany istniejącego kodu programu korzysta- jącego z tych interfejsów. W rzeczywistości zmianie ulec mogą całe klasy i tak długo, jak implementują one interfejsy, mogą być nadal bez przeszkód używane przez resztę aplikacji. Wielokrotne dziedziczenie Podobnie jak ma to miejsce w przypadku klas, interfejsy mogą dziedziczyć po sobie i tworzyć kompletny zorientowany obiektowo projekt. W przypadku interfejsów możliwe jest dziedziczenie po więcej niż jednym obiekcie nadrzędnym, co nie jest możliwe w odniesieniu do klas, a jest to czasem przydatne w projektowaniu zo- rientowanym obiektowo. Na przykład combo box składa się z pola tekstowego (test box) i listy wartości (list box). Podczas implementacji combo box za pomocą klas niezbędne jest użycie omówionej w rozdziale 6. kompozycji klas, ponieważ niemożliwe jest dziedzicze- nie klasy typu combo box jednocześnie po klasie pól tekstowych i klasie list warto- ści. Sposób użycia interfejsu combo box pokazano na listingu 14.1. Listing 14.1. Przykładowy interfejs kontrolki Combo Box +PVGTHCEG+7+ QPVTQN 5WD2CKPV PF+PVGTHCEG +PVGTHCEG+6GZV$QZ +PJGTKVU+7+ QPVTQN 5WD5GV6GZV $[8CNXCNWG#U5VTKPI PF+PVGTHCEG +PVGTHCEG+.KUV$QZ +PJGTKVU+7+ QPVTQN 5WD5GV+VGOU $[8CNKVGOU #U5VTKPI PF+PVGTHCEG +PVGTHCEG+ QODQ$QZ +PJGTKVU+6GZV$QZ+.KUV$QZ PF+PVGTHCEG Interfejs potomny dziedziczy po interfejsie bazowym wszystkie jego pola. Dlatego też zarówno interfejs +VGZV$QZ jak i +.KUV$QZ posiadają podprogram 2CKPV . Interfejs + QODQ$QZ posiada natomiast podprogramy 5GV6GZV , 5GV+VGOU i 2CKPV . Pomimo że podprogram 2CKPV przeniesiony jest z obu interfejsów bazowych, interfejs + QO DQ$QZ ma tylko jedną jego implementację. Rozdział 14. ♦ Praca z interfejsami obiektów 201 Polimorfizm interfejsów Interfejsy Visual Basic .NET zapewniają kolejny sposób realizacji polimorfizmu. Po- limorfizm jest w rzeczywistości nieodłączną cechą interfejsów, ponieważ z założenia nie posiadają one implementacji. Dlatego też każda klasa implementująca interfejs posiada odmienną jego implementację, co stanowi istotię polimorfizmu. Przykładem polimorfizmu jest definiowanie kilku klas, które implementują ten sam interfejs. Używając interfejsów zamiast klas, zauważamy, w jaki sposób interfejsy ob- sługują polimorfizm. Listing 14.2 pokazuje użycie interfejsów w serii obiektów będą- cych wielokątami. Listing 14.2. Polimorfizm interfejsów 2WDNKE+PVGTHCEG5JCRG (WPEVKQP+U2V+P5JCRG $[8CN2V#U5[UVGO TCYKPI2QKPV #U$QQNGCP PF+PVGTHCEG 2WDNKE NCUU4GEVCPING +ORNGOGPVU5JCRG 2TKXCVGTGEV#U TCYKPI4GEVCPING 2WDNKE(WPEVKQP2V+P4GEV $[8CN2V#U5[UVGO TCYKPI2QKPV #U$QQNGCPA +ORNGOGPVU5JCRG+U2V+P5JCRG 2V+P4GEV2V SWCNU TGEV  PF(WPEVKQP PF NCUU 2WDNKE NCUU KTENG +ORNGOGPVU5JCRG 2TKXCVGTIP#U TCYKPI4GIKQP 2WDNKE(WPEVKQP2V+P KTENG $[8CN2V#U5[UVGO TCYKPI2QKPV #U$QQNGCPA +ORNGOGPVU5JCRG+U2V+P5JCRG 2V+P KTENG2V SWCNU TIP  PF(WPEVKQP PF NCUU 5WD JGEM2QKPV $[8CN5JCRG1DLGEV#U5JCRG$[8CN2V#U5[UVGO TCYKPI2QKPV +H 5JCRG1DLGEV+U2V+P5JCRG 2V 6JGP $GGR  PF+H PF5WD 5WD6GUV  KO2V#U5[UVGO TCYKPI2QKPV  KO4GEV1DLGEV#U4GEVCPING  KO KTENG1DLGEV#U KTENG  JGEM2QKPV 4GEV1DLGEV2V  JGEM2QKPV KTENG1DLGEV2V PF5WD 202 Programowanie obiektowe w Visual Basic .NET dla każdego Zauważmy, w jaki sposób podprogram JGEM2QKPV pobiera 5JCRG jako parametr, a następnie używa metody interfejsu. W dalszej kolejności wywoływana jest metoda implementująca funkcjonalność interfejsu. Metoda ta jest różna dla każdego typu obiektu. Możemy nazwać tę metodę dowolnie i implementować w sposób, jaki naj- bardziej nam w określonej sytuacji odpowiada, pod warunkiem zachowania zgodno- ści listy parametrów. W ten sposób klasa może implementować interfejs, zachowując jednocześnie niezmienioną nazwę metody wewnątrz klasy. Możliwe jest również za- stąpienie dowolnego obiektu implementującego interfejs 5JCRG jako parametru pod- programu JGEM2QKPV . Tworzenie interfejsu Contract Interfejs reprezentuje „umowę” z klasą. Klasa, używając słowa kluczowego +ORNG OGPVU, „przystaje na umowę” mówiącą o tym, że będzie implementować interfejs. Po wyrażeniu przez klasę chęci implementacji interfejsu jest ona zobowiązana do im- plementacji całego interfejsu. Klasa nie może zaimplementować części interfejsu, wypełniając jednocześnie zaakceptowany wcześniej kontrakt. Dlatego też, jeśli klasa implementuje interfejs, użytkownicy klasy pewni są tego, że mogą używać wszyst- kich metod zdefiniowanych w tym interfejsie, ponieważ z całą pewnością zostaną one zaimplementowane. Należy pamiętać, że klasa może wypełnić umowę, dostarczając w szczególnym przy- padku takiej implementacji, która nie wykonuje żadnej czynności. Jedynym warunkiem jest zgodność w stosunku do zapisów zdefiniowanych w interfejsie dotyczących para- metrów i (w przypadku funkcji) zwracanych wartości. Wszystko inne zależne jest od klasy implementującej interfejs. W rzeczywistości zaletą użycia interfejsów jest to, że klasa decyduje o zastosowaniu określonej implementacji w konkretnym przypadku. Przykładowa klasa przedstawionej na listingu 14.3 implementuje trzy różne interfejsy. Listing 14.3. Implementacja wielu interfejsów przez jedną klasę owraz użycie obiektów klasy jako implementacji każdego z interfejsów 2WDNKE+PVGTHCEG+ ORNQ[GG (WPEVKQP)GV5CNCT[ #U GEKOCN PF+PVGTHCEG 2WDNKE+PVGTHCEG+2CTGPV (WPEVKQP*CU JKNFTGP #U$QQNGCP PF+PVGTHCEG 2WDNKE+PVGTHCEG+(TKGPF (WPEVKQP0WODGT1H(TKGPFU #U+PVGIGT PF+PVGTHCEG 2WDNKE NCUU2GTUQP +ORNGOGPVU+ ORNQ[GG +ORNGOGPVU+2CTGPV +ORNGOGPVU+(TKGPF Rozdział 14. ♦ Praca z interfejsami obiektów 203 2TKXCVGOAF5CNCT[#U GEKOCN 2TKXCVGOAD JKNFTGP#U$QQNGCP 2TKXCVGOAP(TKGPFU#U+PVGIGT 2WDNKE(WPEVKQP5CNCT[ #U GEKOCN+ORNGOGPVU+ ORNQ[GG)GV5CNCT[ 5CNCT[OAF5CNCT[  PF(WPEVKQP 2WDNKE(WPEVKQP*CU JKNFTGP #U$QQNGCP+ORNGOGPVU+2CTGPV*CU JKNFTGP *CU JKNFTGPOAD JKNFTGP  PF(WPEVKQP 2WDNKE(WPEVKQP*QY/CP[(TKGPFU A #U+PVGIGT+ORNGOGPVU+(TKGPF0WODGT1H(TKGPFU *QY/CP[(TKGPFUOAP(TKGPFU  PF(WPEVKQP PF NCUU /QFWNG2GTUQP7UGT 5WD JGEM5CNCT[ $[8CN ORNQ[GG#U+ ORNQ[GG  9V[OOKGLUEWPCNGľ[WOKGħEKèMQFRTQITCOW  6[NMQ)GV5CNCT[ OQľGD[èWľ[YCPCFNCVGIQQDKGMVW  PF5WD 5WD JGEM(COKN[ $[8CN2CTGPV#U+2CTGPV  9V[OOKGLUEWPCNGľ[WOKGħEKèMQFRTQITCOW  6[NMQ*CU JKNFTGP OQľGD[èWľ[YCPCFNCVGIQQDKGMV7W  PF5WD 5WD JGEM(TKGPFU $[8CN/[(TKGPF#U+(TKGPF  9V[OOKGLUEWPCNGľ[WOKGħEKèMQFRTQITCOW  6[NMQ0WODGT1H(TKGPFU OQľGD[èWľ[YCPCFNCVGIQQDK7GMVW  PF5WD 5WD6GUV2GTUQP  KO2GTUQP#U2GTUQP0GY2GTUQP  JGEM5CNCT[ 2GTUQP  JGEM(COKN[ 2GTUQP  JGEM(TKGPFU 2GTUQP  PF5WD PF/QFWNG Dla kompletności definicji klasy 2GTUQP niezbędne jest zaimplementowanie wszyst- kich metod zdefiniowanych w interfejsach + ORNQ[GG, +2CTGPV i +(TKGPF. Klasa 2GTUQP definiować może również własne cechy charakterystyczne, jednakże te metody, wła- ściwości i zdarzenia nie będą dostępne, gdy klasa będzie iużywana poprzez te interfejsy. W każdym z trzech interfejsów pokazanych w podprogramie 6GUV2GTUQP możliwe jest użycie klasy 2GTUQP. Jest to szczególnie użyteczne podczas projektowania aplika- cji posiadającej kilka niezależnych lub luźno powiązanych klas, które używane będą zamiennie. Stosując typ interfejsu jako parametr, użytkownik widzi jedynie metody, właściwości i zdarzenia zdefiniowane w interfejsie. Reszta implementacji wewnątrz klasy nie jest dla użytkownika interfejsu widoczna. 204 Programowanie obiektowe w Visual Basic .NET dla każdego Programowanie interfejsów Poznaliśmy już kilka przykładów zastosowania interfejsów w programowaniu zo- rientowanym obiektowo. Programowanie z wykorzystaniem interfejsów może jednak nieco różnić się od programowania z użyciem klas. Pierwszym spostrzeżeniem poczynionym podczas projektowania interfejsów, które mają być implementowane później, jest to, że ich metody nie mają określonych za- kresów dostępności. Wszystkie metody są jawne i dostępne do użytku jako publiczne. Na przykład wewnątrz klasy zdefiniować możemy metodę publiczną, chronioną lub prywatną. Interfejsy nie mają tej cechy. Każda metoda zdefiniowana w interfejsie do- stępna jest jako publiczna, czyli tak, jakby została zadeklarowana jako 2WDNKE. Nawet jeśli klasa implementująca implementuje metody jako 2TKXCVG dla użytkownika ko- rzystającego z interfejsu, są one dostępne tak, jakby byłyi zadeklarowane jako 2WDNKE. Posiadanie wszystkich metod interfejsu zadeklarowanych jako publiczne na sens, jeśli zdefiniowanie interfejsu było gruntownie przemyślanei, gdyż interfejsy definiowane są w celu opisania wspólnych możliwych do użycia cech czy funkcjonalności. Czy więc może znaleźć się w interfejsie coś, co zostało zadeklarowane jako prywatne? Działa- nie takie nie ma żadnego logicznego wytłumaczenia z wyjątkiem tego, że mogłoby to wymuszać na klasie implementację metody prywatnej, która może być użyta tylko w obrębie danej klasy. Kolejnym zagadnieniem, które na pierwszy rzut oka wydaje się być problemem (choć w rzeczywistości okazuje się to nieprawdą), jest fakt, że interfejs nie definiuje pól da- nych. Zadaniem interfejsu jest definiowanie jedynie publicznych interfejsów metod, zdarzeń i właściwości. Ponieważ, jak pamiętamy, interfejsy nie mają implementacji, nie ma sensu definiowanie pól danych, gdyż dostęp do danych powinien być realizo- wany poprzez ich metody i właściwości. Ostatnim problemem, który omówimy, jest nieco frustrująca sytuacja, gdy dwa inter- fejsy mają zaprojektowaną tę samą metodę. Jeśli dwa interfejsy są interfejsami bazo- wymi dla nowego, trzeciego interfejsu, użytkownik zmuszony jest do określenia, któ- rą z metod chce wywołać. Listing 14.4 pokazuje taki właśniie przypadek. Listing 14.4. Interfejs z kolizją nazw używających CType() do wskazawnia właściwego sposobu użycia metod 2WDNKE+PVGTHCEG+#TTC[ (WPEVKQP QWPV #U+PVGIGT PF+PVGTHCEG 2WDNKE+PVGTHCEG+ QWPVGT (WPEVKQP QWPV #U+PVGIGT PF+PVGTHCEG 2WDNKE+PVGTHCEG+ QWPV#TTC[ +PJGTKVU+#TTC[ +PJGTKVU+ QWPVGT PF+PVGTHCEG Rozdział 14. ♦ Praca z interfejsami obiektów 205 /QFWNG QWPV#TTC[6GUV 5WD6GUV $[8CNZ#U+ QWPV#TTC[  KOP QWPV 6[RG Z+ QWPVGT  QWPV  KOP#TTC[ QWPV 6[RG Z+#TTC[  QWPV  2QQUVCđ[MQFRTQITCOW  PF5WD PF/QFWNG W kodzie z listingu 14.4 funkcja 6[RG konwertuje wyrażenie precyzujące pierwszy argument (w tym przypadku Z) do typu używanego w drugim parametrze. Dzięki te- mu podczas wykonywania kodu wybierany jest właściwy interfejs i używana jest właściwa metoda QWPV. Nieco wcześniej wspominaliśmy, że jeśli ta sama metoda zawarta jest wewnątrz inter- fejsu i w jego interfejsie bazowym, to jest ona implementowana tylko raz. Dlatego też nie występuje wtedy problem pokazany na listingu 14.4. Implementacja interfejsów Ponieważ interfejs nie posiada implementacji, musi być przed użyciem zdefiniowany tak, aby dostarczał odpowiednich funkcji, metod, zdarzeń i właściwości. Interfejs mo- że być implementowany zarówno przez klasy, jak i definicje struktur zawierających słowo kluczowe +ORNGOGPVU. Jak już wspominaliśmy, klasa może implementować jeden lub wiele interfejsów. Przedstawiony poniżej kod pokazuje sposób, w jaki struktura implementuje interfejs podobnie, jak robi to klasa. 5VTWEVWTG/[5VTWEVWTG +ORNGOGPVU+/[+PVGTHCEG 2WDNKE(WPEVKQP+PVGTHCEG(WPEVKQP A #U+PVGIGT+ORNGOGPVU+/[+PVGTHCEG/[(WPEVKQP  PF(WPEVKQP PF5VTWEVWTG Jak już wspominaliśmy wcześniej, interfejs może deklarować metody (podprogramy i funkcje), zdarzenia i właściwości. Pamiętajmy jednak, że nie może deklarować pól danych. Metody W celu implementacji metod interfejsów poprzez klasy lub struktury, metody te de- klarowane są wewnątrz klas lub struktur z wykorzystaniem słowa kluczowego +ORNG OGPVU. Jedynym wymaganiem implementacji metody interfejsu jest to, aby metoda klasy lub struktury posiadała te same parametry i zwracała wartości zadeklarowane w metodzie interfejsu. 206 Programowanie obiektowe w Visual Basic .NET dla każdego Tak długo jak zgodne są listy parametrów i wartości zwracanych danych, możliwe jest również implementowanie wielu interfejsów przez pojedynczą metodę klasy lub struktury. Na przykład, zamieszczony poniżej kod pokazuje, jak w jednej funkcji zaimplemen- tować dwie metody QWPV zdefiniowane w listin
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Programowanie obiektowe w Visual Basic .NET dla każdego
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ą: