Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00186 005659 12774631 na godz. na dobę w sumie
C#. Praktyczny kurs. Wydanie III - książka
C#. Praktyczny kurs. Wydanie III - książka
Autor: Liczba stron: 416
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-1456-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c# - programowanie
Porównaj ceny (książka, ebook, audiobook).

Programuj w C#!

C# należy do rodziny obiektowych języków programowania. Co to oznacza? Otóż znajduje się on w doborowym towarzystwie Javy, C++ i wielu innych języków, za pomocą których można tworzyć wspaniałe aplikacje, ale jednocześnie jest od nich odrobinę łatwiejszy. Jeśli dopiero zaczynasz przygodę z programowaniem, szybciej uda Ci się go opanować, a jeśli jest to dla Ciebie któryś kolejny język, zrozumienie jego składni i reguł nie powinno sprawić Ci większych trudności — szczególnie jeśli do nauki wykorzystasz tę książkę.

Ten znakomity praktyczny podręcznik pozwoli Ci przećwiczyć używanie i sposób działania wszystkich elementów C# — różnych typów danych, zmiennych i operatorów, instrukcji i tablic. Zobaczysz, jak korzystać z pętli i jak zachowują się obiekty. Poznasz najróżniejsze rodzaje klas, opanujesz wygodne korzystanie z dziedziczenia i nauczysz się obsługiwać błędy. W dalszej części książki znajdziesz zaawansowane zagadnienia programowania obiektowego i odkryjesz, jak projektować aplikacje z interfejsem graficznym. Krótko mówiąc, po starannym wykonaniu ćwiczeń będziesz w stanie zaprojektować i zbudować własną aplikację z użyciem języka C#!

Stwórz własną aplikację w języku C#!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Opieka redakcyjna: Ewelina Burska Projekt okładki: Studio Gravite/Olsztyn Obarek, Pokoński, Pazdrijowski, Zaprucki Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/cshpk3 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Pliki z ćwiczeniami i listingami wykorzystanymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/cshpk3.zip ISBN: 978-83-283-1456-6 Copyright © Helion 2016 Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis tre(cid:264)ci Wst(cid:246)p .............................................................................................. 9 Czym jest C#? .................................................................................................................. 9 Dla kogo jest ta ksi(cid:261)(cid:298)ka? .................................................................................................. 9 Standardy C# .................................................................................................................. 10 Rozdzia(cid:228) 1. Zanim zaczniesz programowa(cid:232) ........................................................ 11 Lekcja 1. Podstawowe koncepcje C# i .NET .................................................................. 11 Jak to dzia(cid:225)a? ............................................................................................................ 11 Narz(cid:266)dzia ................................................................................................................. 12 Instalacja narz(cid:266)dzi .................................................................................................... 13 Lekcja 2. Pierwsza aplikacja, kompilacja i uruchomienie programu .............................. 16 .NET Framework ...................................................................................................... 16 Visual Studio ............................................................................................................ 19 Mono ........................................................................................................................ 22 MonoDevelop (Xamarin Studio) .............................................................................. 23 Struktura kodu .......................................................................................................... 26 Lekcja 3. Komentarze ..................................................................................................... 27 Komentarz blokowy ................................................................................................. 27 Komentarz liniowy ................................................................................................... 28 Komentarz XML ...................................................................................................... 29 (cid:251)wiczenia do samodzielnego wykonania ................................................................. 30 Rozdzia(cid:228) 2. Elementy j(cid:246)zyka ............................................................................. 31 Typy danych ................................................................................................................... 31 Lekcja 4. Typy danych w C# .......................................................................................... 32 Typy danych w C# ................................................................................................... 32 Zapis warto(cid:286)ci (litera(cid:225)y) ............................................................................................ 36 Zmienne .......................................................................................................................... 39 Lekcja 5. Deklaracje i przypisania .................................................................................. 39 Proste deklaracje ...................................................................................................... 39 Deklaracje wielu zmiennych .................................................................................... 41 Nazwy zmiennych .................................................................................................... 42 Zmienne typów odno(cid:286)nikowych ............................................................................... 42 (cid:251)wiczenia do samodzielnego wykonania ................................................................. 43 Poleć książkęKup książkę 4 C#. Praktyczny kurs Lekcja 6. Wyprowadzanie danych na ekran ................................................................... 43 Wy(cid:286)wietlanie warto(cid:286)ci zmiennych ........................................................................... 43 Wy(cid:286)wietlanie znaków specjalnych ........................................................................... 46 Instrukcja Console.Write .......................................................................................... 48 (cid:251)wiczenia do samodzielnego wykonania ................................................................. 49 Lekcja 7. Operacje na zmiennych ................................................................................... 49 Operacje arytmetyczne ............................................................................................. 50 Operacje bitowe ....................................................................................................... 57 Operacje logiczne ..................................................................................................... 61 Operatory przypisania .............................................................................................. 63 Operatory porównywania (relacyjne) ....................................................................... 64 Pozosta(cid:225)e operatory .................................................................................................. 65 Priorytety operatorów ............................................................................................... 65 (cid:251)wiczenia do samodzielnego wykonania ................................................................. 66 Instrukcje steruj(cid:261)ce ......................................................................................................... 67 Lekcja 8. Instrukcja warunkowa if…else ....................................................................... 67 Podstawowa posta(cid:252) instrukcji if…else ..................................................................... 67 Zagnie(cid:298)d(cid:298)anie instrukcji if…else ............................................................................. 69 Instrukcja if…else if ................................................................................................. 72 (cid:251)wiczenia do samodzielnego wykonania ................................................................. 75 Lekcja 9. Instrukcja switch i operator warunkowy ......................................................... 76 Instrukcja switch ...................................................................................................... 76 Przerywanie instrukcji switch ................................................................................... 79 Operator warunkowy ................................................................................................ 81 (cid:251)wiczenia do samodzielnego wykonania ................................................................. 82 Lekcja 10. P(cid:266)tle .............................................................................................................. 82 P(cid:266)tla for .................................................................................................................... 83 P(cid:266)tla while ................................................................................................................ 86 P(cid:266)tla do…while ........................................................................................................ 88 P(cid:266)tla foreach ............................................................................................................. 89 (cid:251)wiczenia do samodzielnego wykonania ................................................................. 90 Lekcja 11. Instrukcje break i continue ............................................................................ 91 Instrukcja break ........................................................................................................ 91 Instrukcja continue ................................................................................................... 95 (cid:251)wiczenia do samodzielnego wykonania ................................................................. 96 Tablice ............................................................................................................................ 97 Lekcja 12. Podstawowe operacje na tablicach ................................................................ 98 Tworzenie tablic ....................................................................................................... 98 Inicjalizacja tablic .................................................................................................. 101 W(cid:225)a(cid:286)ciwo(cid:286)(cid:252) Length ................................................................................................ 102 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 103 Lekcja 13. Tablice wielowymiarowe ............................................................................ 104 Tablice dwuwymiarowe ......................................................................................... 104 Tablice tablic .......................................................................................................... 107 Tablice dwuwymiarowe i w(cid:225)a(cid:286)ciwo(cid:286)(cid:252) Length ........................................................ 109 Tablice nieregularne ............................................................................................... 111 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 115 Rozdzia(cid:228) 3. Programowanie obiektowe ............................................................ 117 Podstawy ...................................................................................................................... 117 Lekcja 14. Klasy i obiekty ............................................................................................ 118 Podstawy obiektowo(cid:286)ci .......................................................................................... 118 Pierwsza klasa ........................................................................................................ 119 Jak u(cid:298)y(cid:252) klasy? ....................................................................................................... 121 Poleć książkęKup książkę Spis tre(cid:264)ci 5 Metody klas ............................................................................................................ 122 Jednostki kompilacji, przestrzenie nazw i zestawy ................................................. 126 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 130 Lekcja 15. Argumenty i przeci(cid:261)(cid:298)anie metod ................................................................ 131 Argumenty metod ................................................................................................... 131 Obiekt jako argument ............................................................................................. 134 Przeci(cid:261)(cid:298)anie metod ................................................................................................. 138 Argumenty metody Main ....................................................................................... 139 Sposoby przekazywania argumentów .................................................................... 140 Definicje metod za pomoc(cid:261) wyra(cid:298)e(cid:276) lambda ......................................................... 143 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 144 Lekcja 16. Konstruktory i destruktory .......................................................................... 145 Czym jest konstruktor? ........................................................................................... 145 Argumenty konstruktorów ..................................................................................... 148 Przeci(cid:261)(cid:298)anie konstruktorów .................................................................................... 149 S(cid:225)owo kluczowe this ............................................................................................... 151 Niszczenie obiektu ................................................................................................. 154 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 155 Dziedziczenie ............................................................................................................... 156 Lekcja 17. Klasy potomne ............................................................................................ 156 Dziedziczenie ......................................................................................................... 156 Konstruktory klasy bazowej i potomnej ................................................................. 160 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 164 Lekcja 18. Modyfikatory dost(cid:266)pu ................................................................................. 164 Okre(cid:286)lanie regu(cid:225) dost(cid:266)pu ........................................................................................ 165 Dlaczego ukrywamy wn(cid:266)trze klasy? ...................................................................... 170 Jak zabroni(cid:252) dziedziczenia? ................................................................................... 174 Tylko do odczytu .................................................................................................... 175 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 178 Lekcja 19. Przes(cid:225)anianie metod i sk(cid:225)adowe statyczne .................................................. 179 Przes(cid:225)anianie metod ................................................................................................ 179 Przes(cid:225)anianie pól .................................................................................................... 182 Sk(cid:225)adowe statyczne ................................................................................................ 183 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 186 Lekcja 20. W(cid:225)a(cid:286)ciwo(cid:286)ci i struktury ............................................................................... 186 W(cid:225)a(cid:286)ciwo(cid:286)ci ........................................................................................................... 187 Struktury ................................................................................................................. 196 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 200 Rozdzia(cid:228) 4. Wyj(cid:241)tki i obs(cid:228)uga b(cid:228)(cid:246)dów .............................................................. 203 Lekcja 21. Blok try…catch ........................................................................................... 203 Badanie poprawno(cid:286)ci danych ................................................................................. 203 Wyj(cid:261)tki w C# ......................................................................................................... 207 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 211 Lekcja 22. Wyj(cid:261)tki to obiekty ...................................................................................... 212 Dzielenie przez zero ............................................................................................... 212 Wyj(cid:261)tek jest obiektem ............................................................................................ 213 Hierarchia wyj(cid:261)tków .............................................................................................. 214 Przechwytywanie wielu wyj(cid:261)tków ......................................................................... 215 Zagnie(cid:298)d(cid:298)anie bloków try…catch .......................................................................... 218 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 220 Poleć książkęKup książkę 6 C#. Praktyczny kurs Lekcja 23. W(cid:225)asne wyj(cid:261)tki ........................................................................................... 220 Zg(cid:225)aszanie wyj(cid:261)tków .............................................................................................. 221 Ponowne zg(cid:225)oszenie przechwyconego wyj(cid:261)tku ...................................................... 223 Tworzenie w(cid:225)asnych wyj(cid:261)tków .............................................................................. 225 Wyj(cid:261)tki warunkowe ............................................................................................... 226 Sekcja finally .......................................................................................................... 228 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 231 Rozdzia(cid:228) 5. System wej(cid:264)cia-wyj(cid:264)cia ................................................................ 233 Lekcja 24. Ci(cid:261)gi znaków .............................................................................................. 233 Znaki i (cid:225)a(cid:276)cuchy znakowe ...................................................................................... 233 Znaki specjalne ....................................................................................................... 237 Zamiana ci(cid:261)gów na warto(cid:286)ci .................................................................................. 238 Formatowanie danych ............................................................................................ 240 Przetwarzanie ci(cid:261)gów ............................................................................................. 242 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 247 Lekcja 25. Standardowe wej(cid:286)cie i wyj(cid:286)cie ................................................................... 247 Klasa Console i odczyt znaków .............................................................................. 248 Wczytywanie tekstu z klawiatury ........................................................................... 255 Wprowadzanie liczb ............................................................................................... 256 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 257 Lekcja 26. Operacje na systemie plików ...................................................................... 258 Klasa FileSystemInfo ............................................................................................. 258 Operacje na katalogach .......................................................................................... 259 Operacje na plikach ................................................................................................ 266 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 271 Lekcja 27. Zapis i odczyt plików .................................................................................. 271 Klasa FileStream .................................................................................................... 272 Podstawowe operacje odczytu i zapisu ................................................................... 274 Operacje strumieniowe ........................................................................................... 278 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 287 Rozdzia(cid:228) 6. Zaawansowane zagadnienia programowania obiektowego ............. 289 Polimorfizm .................................................................................................................. 289 Lekcja 28. Konwersje typów i rzutowanie obiektów .................................................... 289 Konwersje typów prostych ..................................................................................... 290 Rzutowanie typów obiektowych ............................................................................ 291 Rzutowanie na typ Object ...................................................................................... 295 Typy proste te(cid:298) s(cid:261) obiektowe! ................................................................................ 297 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 299 Lekcja 29. Pó(cid:296)ne wi(cid:261)zanie i wywo(cid:225)ywanie metod klas pochodnych ............................ 299 Rzeczywisty typ obiektu ........................................................................................ 300 Dziedziczenie a wywo(cid:225)ywanie metod .................................................................... 302 Dziedziczenie a metody prywatne .......................................................................... 307 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 308 Lekcja 30. Konstruktory oraz klasy abstrakcyjne ......................................................... 309 Klasy i metody abstrakcyjne .................................................................................. 309 Wywo(cid:225)ania konstruktorów ..................................................................................... 313 Wywo(cid:225)ywanie metod w konstruktorach ................................................................. 316 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 318 Interfejsy ....................................................................................................................... 319 Lekcja 31. Tworzenie interfejsów ................................................................................ 319 Czym s(cid:261) interfejsy? ................................................................................................ 319 Interfejsy a hierarchia klas ..................................................................................... 322 Poleć książkęKup książkę Spis tre(cid:264)ci 7 Interfejsy i w(cid:225)a(cid:286)ciwo(cid:286)ci .......................................................................................... 324 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 326 Lekcja 32. Implementacja kilku interfejsów ................................................................. 326 Implementowanie wielu interfejsów ...................................................................... 327 Konflikty nazw ....................................................................................................... 328 Dziedziczenie interfejsów ...................................................................................... 331 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 333 Klasy zagnie(cid:298)d(cid:298)one ...................................................................................................... 334 Lekcja 33. Klasa wewn(cid:261)trz klasy ................................................................................. 334 Tworzenie klas zagnie(cid:298)d(cid:298)onych ............................................................................. 334 Kilka klas zagnie(cid:298)d(cid:298)onych ..................................................................................... 336 Sk(cid:225)adowe klas zagnie(cid:298)d(cid:298)onych .............................................................................. 338 Obiekty klas zagnie(cid:298)d(cid:298)onych ................................................................................. 339 Rodzaje klas wewn(cid:266)trznych ................................................................................... 342 Dost(cid:266)p do sk(cid:225)adowych klasy zewn(cid:266)trznej .............................................................. 344 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 345 Typy uogólnione ........................................................................................................... 346 Lekcja 34. Kontrola typów i typy uogólnione .............................................................. 346 Jak zbudowa(cid:252) kontener? ......................................................................................... 346 Przechowywanie dowolnych danych ...................................................................... 350 Problem kontroli typów .......................................................................................... 352 Korzystanie z typów uogólnionych ........................................................................ 353 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 356 Rozdzia(cid:228) 7. Aplikacje z interfejsem graficznym ................................................ 359 Lekcja 35. Tworzenie okien ......................................................................................... 359 Pierwsze okno ........................................................................................................ 359 Klasa Form ............................................................................................................. 361 Tworzenie menu ..................................................................................................... 366 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 370 Lekcja 36. Delegacje i zdarzenia .................................................................................. 371 Koncepcja zdarze(cid:276) i delegacji ................................................................................ 371 Tworzenie delegacji ............................................................................................... 371 Delegacja jako funkcja zwrotna ............................................................................. 375 Delegacja powi(cid:261)zana z wieloma metodami ............................................................ 379 Zdarzenia ................................................................................................................ 381 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 391 Lekcja 37. Komponenty graficzne ................................................................................ 392 Wy(cid:286)wietlanie komunikatów ................................................................................... 392 Obs(cid:225)uga zdarze(cid:276) ..................................................................................................... 393 Menu ...................................................................................................................... 395 Etykiety .................................................................................................................. 397 Przyciski ................................................................................................................. 399 Pola tekstowe ......................................................................................................... 401 Listy rozwijane ....................................................................................................... 404 (cid:251)wiczenia do samodzielnego wykonania ............................................................... 407 Zako(cid:254)czenie ................................................................................ 409 Skorowidz .................................................................................... 410 Poleć książkęKup książkę 8 C#. Praktyczny kurs Poleć książkęKup książkę Rozdzia(cid:228) 3. Programowanie obiektowe Ka(cid:298)dy program w C# sk(cid:225)ada si(cid:266) z jednej lub wielu klas. W dotychczas prezentowa- nych przyk(cid:225)adach by(cid:225)a to tylko jednak klasa o nazwie Program. Przypomnijmy sobie nasz(cid:261) pierwsz(cid:261) aplikacj(cid:266), wy(cid:286)wietlaj(cid:261)c(cid:261) na ekranie napis. Jej kod wygl(cid:261)da(cid:225) nast(cid:266)puj(cid:261)co: using System; public class Program { public static void Main() { Console.WriteLine( Mój pierwszy program! ); } } Za(cid:225)o(cid:298)yli(cid:286)my wtedy, (cid:298)e szkielet kolejnych programów, na których demonstrowano struktury j(cid:266)zyka programowania, ma w(cid:225)a(cid:286)nie tak wygl(cid:261)da(cid:252). Teraz nadszed(cid:225) czas, aby dowiedzie(cid:252) si(cid:266), dlaczego w(cid:225)a(cid:286)nie tak. Wszystko zostanie wyja(cid:286)nione w niniejszym rozdziale. Podstawy Pierwsza cz(cid:266)(cid:286)(cid:252) rozdzia(cid:225)u 3. sk(cid:225)ada si(cid:266) z trzech lekcji, w których podj(cid:266)to tematyk(cid:266) podstaw programowania obiektowego w C#. W lekcji 14. jest omawiana budowa klas oraz tworzenie obiektów. Zosta(cid:225)y w niej przedstawione pola i metody, sposoby ich deklaracji oraz wywo(cid:225)ywania. Lekcja 15. jest po(cid:286)wi(cid:266)cona argumentom metod oraz technice przeci(cid:261)(cid:298)ania metod, zosta(cid:225)a w niej równie(cid:298) przybli(cid:298)ona wykorzystywana ju(cid:298) wcze(cid:286)niej metoda Main. W ostatniej, 16. lekcji, zaprezentowano temat konstruktorów, czyli specjalnych metod wywo(cid:225)ywanych podczas tworzenia obiektów. Poleć książkęKup książkę 118 C#. Praktyczny kurs Lekcja 14. Klasy i obiekty Lekcja 14. rozpoczyna rozdzia(cid:225) przedstawiaj(cid:261)cy podstawy programowania obiekto- wego w C#. Najwa(cid:298)niejsze poj(cid:266)cia zostan(cid:261) tu wyja(cid:286)nione na praktycznych przyk(cid:225)a- dach. Zajmiemy si(cid:266) tworzeniem klas, ich struktur(cid:261) i deklaracjami, przeanalizujemy zwi(cid:261)zek mi(cid:266)dzy klas(cid:261) i obiektem. Zostan(cid:261) przedstawione sk(cid:225)adowe klasy, czyli pola i metody, b(cid:266)dzie te(cid:298) wyja(cid:286)nione, czym s(cid:261) warto(cid:286)ci domy(cid:286)lne pól. Opisane zostan(cid:261) równie(cid:298) relacje mi(cid:266)dzy zadeklarowan(cid:261) na stosie zmienn(cid:261) obiektow(cid:261) (inaczej referencyjn(cid:261), odno(cid:286)nikow(cid:261)) a utworzonym na stercie obiektem. Podstawy obiektowo(cid:264)ci Program w C# sk(cid:225)ada si(cid:266) z klas, które s(cid:261) z kolei opisami obiektów. To podstawowe poj(cid:266)cia zwi(cid:261)zane z programowaniem obiektowym. Osoby, które nie zetkn(cid:266)(cid:225)y si(cid:266) do- tychczas z programowaniem obiektowym, mog(cid:261) potraktowa(cid:252) obiekt (ang. object) jako pewien byt programistyczny, który mo(cid:298)e przechowywa(cid:252) dane i wykonywa(cid:252) operacje, czyli ró(cid:298)ne zadania. Klasa (ang. class) to z kolei definicja, opis takiego obiektu. Skoro klasa definiuje obiekt, jest zatem równie(cid:298) jego typem. Czym jest typ obiektu? Przytoczmy jedn(cid:261) z definicji: „Typ jest przypisany zmiennej, wyra(cid:298)eniu lub innemu bytowi programistycznemu (danej, obiektowi, funkcji, procedurze, operacji, metodzie, parametrowi, modu(cid:225)owi, wyj(cid:261)tkowi, zdarzeniu). Specyfikuje on rodzaj warto(cid:286)ci, które mo(cid:298)e przybiera(cid:252) ten byt. (…) Jest to równie(cid:298) ograniczenie kontekstu, w którym od- wo(cid:225)anie do tego bytu mo(cid:298)e by(cid:252) u(cid:298)yte w programie”1. Innymi s(cid:225)owy, typ obiektu okre- (cid:286)la po prostu, czym jest dany obiekt. Tak samo jak mia(cid:225)o to miejsce w przypadku zmiennych typów prostych. Je(cid:286)li mieli(cid:286)my zmienn(cid:261) typu int, to mog(cid:225)a ona przecho- wywa(cid:252) warto(cid:286)ci ca(cid:225)kowite. Z obiektami jest podobnie. Zmienna obiektowa hipote- tycznej klasy Punkt mo(cid:298)e przechowywa(cid:252) obiekty klasy (typu) Punkt2. Klasa to zatem nic innego jak definicja nowego typu danych. Co mo(cid:298)e by(cid:252) obiektem? Tak naprawd(cid:266) — wszystko. W (cid:298)yciu codziennym mianem tym okre(cid:286)li(cid:252) mo(cid:298)emy stó(cid:225), krzes(cid:225)o, komputer, dom, samochód, radio… Ka(cid:298)dy z obiektów ma pewne cechy, w(cid:225)a(cid:286)ciwo(cid:286)ci, które go opisuj(cid:261): wielko(cid:286)(cid:252), kolor, powierzchni(cid:266), wy- soko(cid:286)(cid:252). Co wi(cid:266)cej, ka(cid:298)dy obiekt mo(cid:298)e sk(cid:225)ada(cid:252) si(cid:266) z innych obiektów (rysunek 3.1). Na przyk(cid:225)ad mieszkanie sk(cid:225)ada si(cid:266) z poszczególnych pomieszcze(cid:276), z których ka(cid:298)de mo(cid:298)e by(cid:252) obiektem; w ka(cid:298)dym pomieszczeniu mamy z kolei inne obiekty: sprz(cid:266)ty domowe, meble itd. Obiekty oprócz tego, (cid:298)e maj(cid:261) w(cid:225)a(cid:286)ciwo(cid:286)ci, mog(cid:261) wykonywa(cid:252) ró(cid:298)ne funkcje, zadania. Innymi s(cid:225)owy, ka(cid:298)dy obiekt ma przypisany pewien zestaw polece(cid:276), które potrafi wy- konywa(cid:252). Na przyk(cid:225)ad samochód „rozumie” polecenia „uruchom silnik”, „wy(cid:225)(cid:261)cz silnik”, „skr(cid:266)(cid:252) w prawo”, „przyspiesz” itp. Funkcje te sk(cid:225)adaj(cid:261) si(cid:266) na pewien interfejs udo- st(cid:266)pniany nam przez ten(cid:298)e samochód. Dzi(cid:266)ki interfejsowi mo(cid:298)emy wp(cid:225)ywa(cid:252) na za- chowanie samochodu i wydawa(cid:252) mu polecenia. 1 K. Subieta, Wytwarzanie, integracja i testowanie systemów informatycznych, PJWSTK, Warszawa 1997. 2 W dalszej cz(cid:266)(cid:286)ci ksi(cid:261)(cid:298)ki zostanie pokazane, (cid:298)e takiej zmiennej mo(cid:298)na równie(cid:298) przypisa(cid:252) obiekty klas potomnych lub nadrz(cid:266)dnych w stosunku do klasy Punkt. Poleć książkęKup książkę Rozdzia(cid:228) 3. (cid:105) Programowanie obiektowe 119 Rysunek 3.1. Obiekt mo(cid:298)e zawiera(cid:252) inne obiekty W programowaniu jest bardzo podobnie. Za pomoc(cid:261) klas staramy si(cid:266) opisa(cid:252) obiekty, ich w(cid:225)a(cid:286)ciwo(cid:286)ci, zbudowa(cid:252) konstrukcje, interfejs, dzi(cid:266)ki któremu b(cid:266)dziemy mogli wydawa(cid:252) polecenia realizowane potem przez obiekty. Obiekt powstaje jednak dopie- ro w trakcie dzia(cid:225)ania programu jako instancja (wyst(cid:261)pienie, egzemplarz) danej klasy. Obiektów danej klasy mo(cid:298)e by(cid:252) bardzo du(cid:298)o. Je(cid:286)li na przyk(cid:225)ad klas(cid:261) b(cid:266)dzie Samo- chód, to instancj(cid:261) tej klasy b(cid:266)dzie konkretny egzemplarz o danym numerze seryjnym. Poniewa(cid:298) dla osób nieobeznanych z programowaniem obiektowym mo(cid:298)e to wszystko brzmie(cid:252) nieco zawile, od razu zobaczmy, jak to b(cid:266)dzie wygl(cid:261)da(cid:225)o w praktyce. Pierwsza klasa Za(cid:225)ó(cid:298)my, (cid:298)e pisany przez nas program wymaga przechowywania danych odnosz(cid:261)cych si(cid:266) do punktów na p(cid:225)aszczy(cid:296)nie, ekranie. Ka(cid:298)dy taki punkt jest charakteryzowany przez dwie warto(cid:286)ci: wspó(cid:225)rz(cid:266)dn(cid:261) x oraz wspó(cid:225)rz(cid:266)dn(cid:261) y. Utwórzmy wi(cid:266)c klas(cid:266) opisuj(cid:261)c(cid:261) obiekty tego typu. Schematyczny szkielet klasy wygl(cid:261)da nast(cid:266)puj(cid:261)co: class nazwa_klasy { //tre(cid:286)(cid:252) klasy } W tre(cid:286)ci klasy definiujemy pola i metody. Pola s(cid:225)u(cid:298)(cid:261) do przechowywania danych, metody do wykonywania ró(cid:298)nych operacji. W przypadku klasy, która ma przecho- wywa(cid:252) dane dotycz(cid:261)ce wspó(cid:225)rz(cid:266)dnych x i y, wystarcz(cid:261) dwa pola typu int (przy za(cid:225)o- (cid:298)eniu, (cid:298)e wystarczaj(cid:261)ce b(cid:266)dzie przechowywanie wy(cid:225)(cid:261)cznie wspó(cid:225)rz(cid:266)dnych ca(cid:225)kowi- tych). Pozostaje jeszcze wybór nazwy dla takiej klasy. Wyst(cid:266)puj(cid:261) tu takie same ograniczenia jak w przypadku nazewnictwa zmiennych (por. lekcja 5.), czyli nazwa klasy mo(cid:298)e sk(cid:225)ada(cid:252) si(cid:266) jedynie z liter (zarówno ma(cid:225)ych, jak i du(cid:298)ych), cyfr oraz znaku podkre(cid:286)lenia, ale nie mo(cid:298)e zaczyna(cid:252) si(cid:266) od cyfry. Mo(cid:298)na stosowa(cid:252) znaki polskie znaki (cho(cid:252) wielu programistów u(cid:298)ywa wy(cid:225)(cid:261)cznie alfabetu (cid:225)aci(cid:276)skiego, nawet je(cid:286)li nazwy pochodz(cid:261) z j(cid:266)zyka polskiego). Przyj(cid:266)te jest równie(cid:298), (cid:298)e w nazwach nie u(cid:298)ywa si(cid:266) znaku podkre(cid:286)lenia. Nasz(cid:261) klas(cid:266) nazwiemy zatem, jak(cid:298)eby inaczej, Punkt i b(cid:266)dzie ona mia(cid:225)a posta(cid:252) wi- doczn(cid:261) na listingu 3.1. Kod ten zapiszemy w pliku o nazwie Punkt.cs. Poleć książkęKup książkę 120 C#. Praktyczny kurs Listing 3.1. Klasa przechowuj(cid:261)ca wspó(cid:225)rz(cid:266)dne punktów class Punkt { int x; int y; } Ta klasa zawiera dwa pola o nazwach x i y, które opisuj(cid:261) wspó(cid:225)rz(cid:266)dne po(cid:225)o(cid:298)enia punktu. Pola definiujemy w taki sam sposób jak zmienne. Kiedy mamy zdefiniowan(cid:261) klas(cid:266) Punkt, mo(cid:298)emy zadeklarowa(cid:252) zmienn(cid:261) typu Punkt. Robimy to podobnie jak wtedy, gdy deklarowali(cid:286)my zmienne typów prostych (np. short, int, char), czyli pisz(cid:261)c: typ_zmiennej nazwa_zmiennej; Poniewa(cid:298) typem zmiennej jest nazwa klasy (klasa to definicja typu danych), to je(cid:286)li nazw(cid:261) zmiennej ma by(cid:252) przykladowyPunkt, deklaracja przyjmie posta(cid:252): Punkt przykladowyPunkt; W ten sposób powsta(cid:225)a zmienna odno(cid:286)nikowa (referencyjna, obiektowa), która do- my(cid:286)lnie jest pusta, tzn. nie zawiera (cid:298)adnych danych. Dok(cid:225)adniej rzecz ujmuj(cid:261)c, po deklaracji zmienna taka zawiera warto(cid:286)(cid:252) specjaln(cid:261) null, która okre(cid:286)la, (cid:298)e nie ma ona odniesienia do (cid:298)adnego obiektu. Musimy wi(cid:266)c sami utworzy(cid:252) obiekt klasy Punkt i przy- pisa(cid:252) go tej zmiennej3. Obiekty tworzy si(cid:266) za pomoc(cid:261) operatora new w postaci: new nazwa_klasy(); zatem ca(cid:225)a konstrukcja schematycznie wygl(cid:261)da(cid:252) b(cid:266)dzie nast(cid:266)puj(cid:261)co: nazwa_klasy nazwa_zmiennej = new nazwa_klasy(); a w przypadku naszej klasy Punkt: Punkt przykladowyPunkt = new Punkt(); Oczywi(cid:286)cie, podobnie jak w przypadku zmiennych typów prostych (por. lekcja 5.), równie(cid:298) i tutaj mo(cid:298)na oddzieli(cid:252) deklaracj(cid:266) zmiennej od jej inicjalizacji, zatem równie poprawna jest konstrukcja w postaci: Punkt przykladowyPunkt; przykladowyPunkt = new Punkt(); Koniecznie trzeba sobie dobrze uzmys(cid:225)owi(cid:252), (cid:298)e po wykonaniu tych instrukcji w pa- mi(cid:266)ci powstaj(cid:261) dwie ró(cid:298)ne struktury. Pierwsz(cid:261) z nich jest powsta(cid:225)a na tak zwanym stosie (ang. stack) zmienna referencyjna przykladowyPunkt, drug(cid:261) jest powsta(cid:225)y na tak zwanej stercie (ang. heap) obiekt klasy (typu) Punkt. Zmienna przykladowyPunkt za- wiera odniesienie do przypisanego jej obiektu klasy Punkt i tylko poprzez ni(cid:261) mo(cid:298)emy si(cid:266) do tego obiektu odwo(cid:225)ywa(cid:252). Schematycznie zobrazowano to na rysunku 3.2. 3 Osoby programuj(cid:261)ce w C++ powinny zwróci(cid:252) na to uwag(cid:266), gdy(cid:298) w tym j(cid:266)zyku ju(cid:298) sama deklaracja zmiennej typu klasowego powoduje wywo(cid:225)anie domy(cid:286)lnego konstruktora i utworzenie obiektu. Poleć książkęKup książkę Rozdzia(cid:228) 3. (cid:105) Programowanie obiektowe 121 Rysunek 3.2. Zale(cid:298)no(cid:286)(cid:252) mi(cid:266)dzy zmienn(cid:261) odno(cid:286)nikow(cid:261) a wskazywanym przez ni(cid:261) obiektem Je(cid:286)li chcemy odwo(cid:225)a(cid:252) si(cid:266) do danego pola klasy, korzystamy z operatora . (kropka), czyli u(cid:298)ywamy konstrukcji: nazwa_zmiennej_obiektowej.nazwa_pola_obiektu Przyk(cid:225)adowo przypisanie warto(cid:286)ci 100 polu x obiektu klasy Punkt reprezentowanego przez zmienn(cid:261) przykladowyPunkt b(cid:266)dzie wygl(cid:261)da(cid:225)o nast(cid:266)puj(cid:261)co: przykladowyPunkt.x = 100; Jak u(cid:276)y(cid:232) klasy? Spróbujmy teraz przekona(cid:252) si(cid:266), (cid:298)e obiekt klasy Punkt faktycznie jest w stanie prze- chowywa(cid:252) dane. Jak wiadomo z poprzednich rozdzia(cid:225)ów, aby program móg(cid:225) zosta(cid:252) uruchomiony, musi zawiera(cid:252) metod(cid:266) Main (wi(cid:266)cej o metodach ju(cid:298) w kolejnym pod- punkcie, a o metodzie Main w jednej z kolejnych lekcji). Dopiszmy wi(cid:266)c do klasy Punkt tak(cid:261) metod(cid:266), która utworzy obiekt, przypisze jego polom pewne warto(cid:286)ci oraz wy(cid:286)wietli je na ekranie. Kod programu realizuj(cid:261)cego takie zadanie jest widoczny na listingu 3.2. Listing 3.2. U(cid:298)ycie klasy Punkt using System; class Punkt { int x; int y; public static void Main() { Punkt punkt1 = new Punkt(); punkt1.x = 100; punkt1.y = 200; Console.WriteLine( punkt.x = + punkt1.x); Console.WriteLine( punkt.y = + punkt1.y); } } Poleć książkęKup książkę 122 C#. Praktyczny kurs Struktura klasy Punkt jest taka sama jak w przypadku listingu 3.1, z t(cid:261) ró(cid:298)nic(cid:261), (cid:298)e do jej tre(cid:286)ci zosta(cid:225)a dodana metoda Main. W tej metodzie deklarujemy zmienn(cid:261) klasy Punkt o nazwie punkt1 i przypisujemy jej nowo utworzony obiekt tej klasy. Dokonu- jemy zatem jednoczesnej deklaracji i inicjalizacji. Od tej chwili zmienna punkt1 wskazuje na obiekt klasy Punkt, mo(cid:298)emy si(cid:266) zatem pos(cid:225)ugiwa(cid:252) ni(cid:261) tak, jakby(cid:286)my po- s(cid:225)ugiwali si(cid:266) samym obiektem. Pisz(cid:261)c zatem punkt1.x = 100, przypisujemy warto(cid:286)(cid:252) 100 polu x, a pisz(cid:261)c punkt.y = 200, przypisujemy warto(cid:286)(cid:252) 200 polu y. W ostatnich dwóch liniach korzystamy z instrukcji Console.WriteLine, aby wy(cid:286)wietli(cid:252) warto(cid:286)(cid:252) obu pól na ekranie. Efekt jest widoczny na rysunku 3.3. Rysunek 3.3. Wynik dzia(cid:225)ania klasy Punkt z listingu 3.2 Metody klas Klasy oprócz pól przechowuj(cid:261)cych dane zawieraj(cid:261) tak(cid:298)e metody, które wykonuj(cid:261) za- pisane przez programist(cid:266) operacje. Definiujemy je w ciele (czyli wewn(cid:261)trz) klasy pomi(cid:266)dzy znakami nawiasu klamrowego. Ka(cid:298)da metoda mo(cid:298)e przyjmowa(cid:252) argumenty oraz zwraca(cid:252) wynik. Schematyczna deklaracja metody wygl(cid:261)da nast(cid:266)puj(cid:261)co: typ_wyniku nazwa_metody(argumenty_metody) { instrukcje metody } Po umieszczeniu w ciele klasy deklaracja taka b(cid:266)dzie natomiast wygl(cid:261)da(cid:225)a tak: class nazwa_klasy { typ_wyniku nazwa_metody(argumenty_metody) { instrukcje metody } } Je(cid:286)li metoda nie zwraca (cid:298)adnego wyniku, jako typ wyniku nale(cid:298)y zastosowa(cid:252) s(cid:225)owo void; je(cid:286)li natomiast nie przyjmuje (cid:298)adnych parametrów, pomi(cid:266)dzy znakami nawiasu okr(cid:261)g(cid:225)ego nie nale(cid:298)y nic wpisywa(cid:252). Aby zobaczy(cid:252), jak to wygl(cid:261)da w praktyce, do klasy Punkt dodamy prost(cid:261) metod(cid:266), której zadaniem b(cid:266)dzie wy(cid:286)wietlenie warto(cid:286)ci wspó(cid:225)rz(cid:266)dnych x i y na ekranie. Nadamy jej nazw(cid:266) WyswietlWspolrzedne, zatem jej wygl(cid:261)d b(cid:266)dzie nast(cid:266)puj(cid:261)cy: void WyswietlWspolrzedne() { Console.WriteLine( wspó(cid:239)rz(cid:218)dna x = + x); Console.WriteLine( wspó(cid:239)rz(cid:218)dna y = + y); } Poleć książkęKup książkę Rozdzia(cid:228) 3. (cid:105) Programowanie obiektowe 123 S(cid:225)owo void oznacza, (cid:298)e metoda nie zwraca (cid:298)adnego wyniku, a brak argumentów po- mi(cid:266)dzy znakami nawiasu okr(cid:261)g(cid:225)ego wskazuje, (cid:298)e metoda ta (cid:298)adnych argumentów nie przyjmuje. We wn(cid:266)trzu metody znajduj(cid:261) si(cid:266) dwie dobrze nam znane instrukcje, które wy(cid:286)wietlaj(cid:261) na ekranie wspó(cid:225)rz(cid:266)dne punktu. Po umieszczeniu powy(cid:298)szego kodu w klasie Punkt przyjmie ona posta(cid:252) widoczn(cid:261) na listingu 3.3. Listing 3.3. Dodanie metody do klasy Punkt using System; class Punkt { int x; int y; void WyswietlWspolrzedne() { Console.WriteLine( wspó(cid:239)rz(cid:218)dna x = + x); Console.WriteLine( wspó(cid:239)rz(cid:218)dna y = + y); } } Po utworzeniu obiektu danej klasy mo(cid:298)emy wywo(cid:225)a(cid:252) (uruchomi(cid:252)) metod(cid:266) w taki sam sposób, w jaki odwo(cid:225)ujemy si(cid:266) do pól klasy, tzn. korzystaj(cid:261)c z operatora . (kropka). Je(cid:286)li zatem przyk(cid:225)adowa zmienna punkt1 zawiera referencj(cid:266) do obiektu klasy Punkt, prawid(cid:225)owym wywo(cid:225)aniem metody WyswietlWspolrzedne b(cid:266)dzie: punkt1.WyswietlWspolrzedne(); Ogólnie wywo(cid:225)anie metody wygl(cid:261)da nast(cid:266)puj(cid:261)co: nazwa_zmiennej.nazwa_metody(argumenty_metody); Oczywi(cid:286)cie, je(cid:286)li dana metoda nie ma argumentów, po prostu je pomijamy. Przy czym termin wywo(cid:225)anie oznacza po prostu wykonanie kodu (instrukcji) zawartego w metodzie. U(cid:298)yjmy zatem metody Main do przetestowania nowej konstrukcji. W tym celu zmo- dyfikujemy program z listingu 3.2 tak, aby wykorzystywa(cid:225) metod(cid:266) WyswietlWspolrzedne. Odpowiedni kod jest zaprezentowany na listingu 3.4. Wynik jego dzia(cid:225)ania jest (cid:225)atwy do przewidzenia (rysunek 3.4). Listing 3.4. Wywo(cid:225)anie metody WyswietlWspolrzedne using System; class Punkt { int x; int y; void WyswietlWspolrzedne() { Console.WriteLine( wspó(cid:239)rz(cid:218)dna x = + x); Console.WriteLine( wspó(cid:239)rz(cid:218)dna y = + y); Poleć książkęKup książkę C#. Praktyczny kurs 124 } public static void Main() { Punkt punkt1 = new Punkt(); punkt1.x = 100; punkt1.y = 200; punkt1.WyswietlWspolrzedne(); } } Rysunek 3.4. Wynik dzia(cid:225)ania metody WyswietlWspolrzedne z klasy Punkt Przedstawiony kod jest w istocie z(cid:225)o(cid:298)eniem przyk(cid:225)adów z listingów 3.2 i 3.3. Klasa Punkt z listingu 3.3 zosta(cid:225)a uzupe(cid:225)niona o nieco zmodyfikowany kod metody Main, po- brany z listingu 3.2. W metodzie tej jest wi(cid:266)c tworzony nowy obiekt typu Punkt i ustala- ne s(cid:261) warto(cid:286)ci jego pól x i y. Do wy(cid:286)wietlenia warto(cid:286)ci zapisanych w x i y jest nato- miast u(cid:298)ywana metoda WyswietlWspolrzedne. Zobaczmy teraz, w jaki sposób napisa(cid:252) metody, które b(cid:266)d(cid:261) mog(cid:225)y zwraca(cid:252) wyniki. Typ wyniku nale(cid:298)y poda(cid:252) przed nazw(cid:261) metody, zatem je(cid:286)li ma ona zwraca(cid:252) warto(cid:286)(cid:252) typu int, deklaracja powinna wygl(cid:261)da(cid:252) nast(cid:266)puj(cid:261)co: int nazwa_metody() { //instrukcje metody } Sam wynik zwracamy natomiast przez zastosowanie instrukcji return. Najlepiej zo- baczy(cid:252) to na praktycznym przyk(cid:225)adzie. Do klasy Punkt dodamy zatem dwie metody — jedna b(cid:266)dzie podawa(cid:225)a warto(cid:286)(cid:252) wspó(cid:225)rz(cid:266)dnej x, druga y. Nazwiemy je odpowiednio PobierzX i PobierzY. Wygl(cid:261)d metody PobierzX b(cid:266)dzie nast(cid:266)puj(cid:261)cy: int PobierzX() { return x; } Przed nazw(cid:261) metody znajduje si(cid:266) okre(cid:286)lenie typu zwracanego przez ni(cid:261) wyniku — skoro jest to int, oznacza to, (cid:298)e metoda ta musi zwróci(cid:252) jako wynik liczb(cid:266) ca(cid:225)kowit(cid:261) z przedzia(cid:225)u okre(cid:286)lonego przez typ int (tabela 2.1). Wynik jest zwracany dzi(cid:266)ki in- strukcji return. Zapis return x oznacza zwrócenie przez metod(cid:266) warto(cid:286)ci zapisanej w polu x. Jak (cid:225)atwo si(cid:266) domy(cid:286)li(cid:252), metoda PobierzY b(cid:266)dzie wygl(cid:261)da(cid:225)a analogicznie, z tym (cid:298)e b(cid:266)- dzie w niej zwracana warto(cid:286)(cid:252) zapisana w polu y. Pe(cid:225)ny kod klasy Punkt po dodaniu tych dwóch metod b(cid:266)dzie wygl(cid:261)da(cid:225) tak, jak przedstawiono na listingu 3.5. Poleć książkęKup książkę Rozdzia(cid:228) 3. (cid:105) Programowanie obiektowe 125 Listing 3.5. Metody zwracaj(cid:261)ce wyniki using System; class Punkt { int x; int y; int PobierzX() { return x; } int PobierzY() { return y; } void WyswietlWspolrzedne() { Console.WriteLine( wspó(cid:239)rz(cid:218)dna x = + x); Console.WriteLine( wspó(cid:239)rz(cid:218)dna y = + y); } } Je(cid:286)li teraz zechcemy przekona(cid:252) si(cid:266), jak dzia(cid:225)aj(cid:261) nowe metody, mo(cid:298)emy wyposa(cid:298)y(cid:252) klas(cid:266) Punkt w metod(cid:266) Main testuj(cid:261)c(cid:261) ich dzia(cid:225)anie. Mog(cid:225)aby ona mie(cid:252) posta(cid:252) wi- doczn(cid:261) na listingu 3.6. Listing 3.6. Metoda Main testuj(cid:261)ca dzia(cid:225)anie klasy Punkt public static void Main() { Punkt punkt1 = new Punkt(); punkt1.x = 100; punkt1.y = 200; int wspX = punkt1.PobierzX(); int wspY = punkt1.PobierzY(); Console.WriteLine( wspó(cid:239)rz(cid:218)dna x = + wspX); Console.WriteLine( wspó(cid:239)rz(cid:218)dna y = + wspY); } Pocz(cid:261)tek kodu jest tu taki sam jak we wcze(cid:286)niej prezentowanych przyk(cid:225)adach — po- wstaje obiekt typu Punkt i s(cid:261) w nim zapisywane przyk(cid:225)adowe wspó(cid:225)rz(cid:266)dne. Nast(cid:266)pnie two- rzone s(cid:261) dwie zmienne typu int: wspX i wspY. Pierwszej przypisywana jest warto(cid:286)(cid:252) zwróco- na przez metod(cid:266) PobierzX, a drugiej — warto(cid:286)(cid:252) zwrócona przez metod(cid:266) PobierzY. Warto(cid:286)ci zapisane w zmiennych s(cid:261) nast(cid:266)pnie wy(cid:286)wietlane w standardowy sposób na ekranie. Warto tu zauwa(cid:298)y(cid:252), (cid:298)e zmienne wspX i wspY pe(cid:225)ni(cid:261) funkcj(cid:266) pomocnicz(cid:261) — dzi(cid:266)ki nim kod jest czytelniejszy. Nic jednak nie stoi na przeszkodzie, aby warto(cid:286)ci zwrócone przez metody by(cid:225)y u(cid:298)ywane bezpo(cid:286)rednio w instrukcjach Console.WriteLine4. Metoda 4 Po wyja(cid:286)nieniach przedstawionych w lekcji 3. mo(cid:298)na si(cid:266) domy(cid:286)li(cid:252), (cid:298)e to, co do tej pory by(cid:225)o nazywane instrukcj(cid:261) WriteLine, jest w rzeczywisto(cid:286)ci wywo(cid:225)aniem metody o nazwie WriteLine. Poleć książkęKup książkę 126 C#. Praktyczny kurs Main mog(cid:225)aby wi(cid:266)c mie(cid:252) równie(cid:298) posta(cid:252) przedstawion(cid:261) na listingu 3.7. Efekt dzia(cid:225)ania by(cid:225)by taki sam. Listing 3.7. Alternatywna wersja metody Main public static void Main() { Punkt punkt1 = new Punkt(); punkt1.x = 100; punkt1.y = 200; Console.WriteLine( wspó(cid:239)rz(cid:218)dna x = + punkt1.PobierzX()); Console.WriteLine( wspó(cid:239)rz(cid:218)dna y = + punkt1.PobierzY()); } Jednostki kompilacji, przestrzenie nazw i zestawy Ka(cid:298)d(cid:261) klas(cid:266) mo(cid:298)na zapisa(cid:252) w pliku o dowolnej nazwie. Cz(cid:266)sto przyjmuje si(cid:266) jednak, (cid:298)e nazwa pliku powinna by(cid:252) zgodna z nazw(cid:261) klasy. Je(cid:286)li zatem istnieje klasa Punkt, to jej kod powinien znale(cid:296)(cid:252) si(cid:266) w pliku Punkt.cs. W jednym pliku mo(cid:298)e si(cid:266) te(cid:298) znale(cid:296)(cid:252) kilka klas. Wówczas jednak zazwyczaj s(cid:261) to tylko jedna klasa g(cid:225)ówna oraz dodatkowe klasy pomocnicze. W przypadku prostych aplikacji tych zasad nie trzeba przestrzega(cid:252), ale w przypadku wi(cid:266)kszych programów umieszczenie ca(cid:225)ej struktury kodu w jednym pliku spowodowa(cid:225)oby du(cid:298)e trudno(cid:286)ci w zarz(cid:261)dzaniu nim. Pojedynczy plik mo(cid:298)na na- zwa(cid:252) jednostk(cid:261) kompilacji lub modu(cid:225)em. Wszystkie dotychczasowe przyk(cid:225)ady sk(cid:225)ada(cid:225)y si(cid:266) zawsze z jednej klasy zapisywanej w jednym pliku. Zobaczmy wi(cid:266)c, jak mog(cid:261) wspó(cid:225)pracowa(cid:252) ze sob(cid:261) dwie klasy. Na li- stingu 3.8 znajduje si(cid:266) nieco zmodyfikowana tre(cid:286)(cid:252) klasy Punkt z listingu 3.1. Przed sk(cid:225)a- dowymi zosta(cid:225)y dodane s(cid:225)owa public, dzi(cid:266)ki którym b(cid:266)dzie istnia(cid:225)a mo(cid:298)liwo(cid:286)(cid:252) od- wo(cid:225)ywania si(cid:266) do nich z innych klas. Ta kwestia zostanie wyja(cid:286)niona dok(cid:225)adniej w jednej z kolejnych lekcji. Na listingu 3.9 jest natomiast widoczny kod klasy Program, która ko- rzysta z klasy Punkt. Tak wi(cid:266)c tre(cid:286)(cid:252) z listingu 3.8 zapiszemy w pliku o nazwie Punkt.cs, a kod z listingu 3.9 w pliku Program.cs. Listing 3.8. Prosta klasa Punkt class Punkt { public int x; public int y; } Listing 3.9. Klasa Program korzystaj(cid:261)ca z obiektu klasy Punkt using System; public class Program { public static void Main() { Punkt punkt1 = new Punkt(); Poleć książkęKup książkę Rozdzia(cid:228) 3. (cid:105) Programowanie obiektowe 127 punkt1.x = 100; punkt1.y = 200; Console.WriteLine( punkt1.x = + punkt1.x); Console.WriteLine( punkt1.y = + punkt1.y); } } W klasie Program znajduje si(cid:266) metoda Main, od której rozpoczyna si(cid:266) wykonywanie kodu aplikacji. W tej metodzie tworzony jest obiekt punkt1 klasy Punkt, jego sk(cid:225)ado- wym przypisywane s(cid:261) warto(cid:286)ci 100 i 200, a nast(cid:266)pnie s(cid:261) one wy(cid:286)wietlane na ekranie. Tego typu konstrukcje by(cid:225)y wykorzystywane ju(cid:298) kilkakrotnie we wcze(cid:286)niejszych przyk(cid:225)adach. Jak teraz przetworzy(cid:252) oba kody na plik wykonywalny? Nie jest to skomplikowane, po prostu nazwy obu plików (Program.cs i Punkt.cs) nale(cid:298)y zastosowa(cid:252) jako argumenty wywo(cid:225)ania kompilatora, czyli w wierszu polece(cid:276) wyda(cid:252) komend(cid:266): csc Program.cs Punkt.cs Trzeba te(cid:298) wiedzie(cid:252), (cid:298)e plik wykonywalny powsta(cid:225)y po kompilacji nie zawiera tylko kodu wykonywalnego. W rzeczywisto(cid:286)ci kod wykonywany na platformie .NET sk(cid:225)a- da si(cid:266) z tak zwanych zestawów (ang. assembly). Pojedynczy zestaw sk(cid:225)ada si(cid:266) z ma- nifestu, metadanych oraz kodu j(cid:266)zyka po(cid:286)redniego IL. Manifest to wszelkie informacje o zestawie, takie jak nazwy plików sk(cid:225)adowych, odwo(cid:225)ania do innych zestawów, numer wersji itp. Metadane natomiast to opis danych i kodu j(cid:266)zyka po(cid:286)redniego w danym zestawie, zawieraj(cid:261)cy m.in. definicje zastosowanych typów danych. Wszystko to mo(cid:298)e by(cid:252) umieszczone w jednym lub te(cid:298) kilku plikach (exe, dll). We wszystkich przyk(cid:225)adach w tej ksi(cid:261)(cid:298)ce b(cid:266)dziemy mieli do czynienia tylko z zestawami jednoplikowymi i b(cid:266)d(cid:261) to pliki wykonywalne typu exe, generowane automatycznie przez kompilator, tak (cid:298)e nie b(cid:266)dziemy musieli zag(cid:225)(cid:266)bia(cid:252) si(cid:266) w te kwestie. Nie mo(cid:298)na jednak pomin(cid:261)(cid:252) zagadnienia przestrzeni nazw. Przestrze(cid:276) nazw to ograniczenie widoczno(cid:286)ci danej nazwy, ograniczenie kontekstu, w którym jest ona rozpoznawana. Czemu to s(cid:225)u(cid:298)y? Otó(cid:298) pojedyncza aplikacja mo(cid:298)e si(cid:266) sk(cid:225)ada(cid:252) z bardzo du(cid:298)ej liczby klas, a jeszcze wi(cid:266)cej klas znajduje si(cid:266) w bibliotekach udost(cid:266)pnianych przez .NET. Co wi(cid:266)cej, nad jednym projektem zwykle pracuj(cid:261) zespo(cid:225)y programistów. W takiej sytuacji nietrudno o pojawianie si(cid:266) konfliktów nazw, czyli powstawanie klas o takich samych nazwach. Tymczasem nazwa ka(cid:298)dej klasy musi by(cid:252) unikatowa. Ten problem rozwi(cid:261)zuj(cid:261) w(cid:225)a(cid:286)nie przestrzenie nazw. Je(cid:286)li bowiem kla- sa zostanie umieszczona w danej przestrzeni, to b(cid:266)dzie widoczna tylko w niej. B(cid:266)d(cid:261) wi(cid:266)c mog(cid:225)y istnie(cid:252) klasy o takiej samej nazwie, o ile tylko zostan(cid:261) umieszczone w ró(cid:298)- nych przestrzeniach nazw. Tak(cid:261) przestrze(cid:276) definiuje si(cid:266) za pomoc(cid:261) s(cid:225)owa namespace, a jej sk(cid:225)adowe nale(cid:298)y umie(cid:286)ci(cid:252) w wyst(cid:266)puj(cid:261)cym dalej nawiasie klamrowym. Schema- tycznie wygl(cid:261)da to tak: namespace nazwa_przestrzeni { elementy przestrzeni nazw } Poleć książkęKup książkę Poleć książkęKup książkę Skorowidz .NET Framework, 13, 16 A akcesor set, 191 aliasy, 297 aplikacje konsolowe, 19 okienkowe, 361 argumenty, 374 konstruktorów, 148 metody, 131 metody Main, 139 automatyczne konwersje warto(cid:286)ci, 54 wywo(cid:225)anie konstruktora, 313 B badanie poprawno(cid:286)ci danych, 203 bitowa alternatywa wykluczaj(cid:261)ca, 60 blok default, 80 finally, 229 try…catch, 203, 208, 218 aplikacji, 100 kompilacji, 55, 175, 315 b(cid:225)(cid:261)d b(cid:225)(cid:266)dna hierarchia wyj(cid:261)tków, 217 implementacja interfejsów, 330 C chronione pola, 169 ci(cid:261)gi znaków, 35, 233, 35, 233 CIL, Common Intermediate Language, 12 CLR, Common Language Runtime, 12 CLS, Common Language Specification, 12 D OnUjemneEventDelegate, 387 deklaracja, 39 metody, 122 zmiennej, 39 wielu zmiennych, 41 dekrementacja, 51 delegacja, 371, 379 destruktor, 145, 154 dodawanie delegacji, 381 metody, 123 procedur obs(cid:225)ugi, 385 znaków, 236 dokument XML, 29 dost(cid:266)p chroniony, protected, 169 do klasy, 165 do obiektu generuj(cid:261)cego zdarzenie, 386 do sk(cid:225)adowych klasy zagnie(cid:298)d(cid:298)onej, 338 do sk(cid:225)adowych klasy zewn(cid:266)trznej, 344 prywatny, private, 168 publiczny, public, 166 Poleć książkęKup książkę Skorowidz 411 dynamiczna tablica, 347, 350 dyrektywa using, 129 dziedziczenie, 156, 174, 302, 307, 322 interfejsu, 200, 323, 331 struktury, 199 dzielenie przez zero, 212 etykiety, 397 E F FCL, Framework Class Library, 12 formatowanie danych, 240 funkcje zwrotne, 375 H hierarchia klas, 322 hierarchia wyj(cid:261)tków, 214 I IDE, Integrated Development Environment, 15 iloczyn bitowy, 58 logiczny ( ), 61 logiczny ( ), 62 implementacja interfejsów, 325, 330 informacja o b(cid:225)(cid:266)dzie, 100 informacje o pliku, 269 inicjalizacja, 40 pól, 198 tablic, 101 w(cid:225)a(cid:286)ciwo(cid:286)ci, 196 zmiennej, 40 inicjalizator, 152 inkrementacja, 51 instalacja .NET Framework, 13 Mono, 15 MonoDevelop, 15 Visual Studio, 14 instrukcja break, 91 Console.Write, 48 continue, 95 goto, 79 if, 68 if...else, 67, 69 if...else if, 72 return, 188 switch, 76–79 instrukcje steruj(cid:261)ce, 67 warunkowe, 67 graficzny, 359 IDrawable, 321 interfejs, 199, 319, 322, 324 interpolacja (cid:225)a(cid:276)cuchów znakowych, 46 J jednostki kompilacji, 126 j(cid:266)zyk C#, 9 K katalog, 259 klasa, 118 BinaryReader, 285 BinaryWriter, 283 Button, 399 ComboBox, 405 Console, 248 Convert, 238 DirectoryInfo, 259 FileInfo, 266 FileStream, 272 FileSystemInfo, 258 Form, 361 Kontener, 377, 384 Label, 397 MainForm, 365 StreamReader, 279 StreamWriter, 281 TablicaInt, 349, 350 TextBox, 401 Triangle, 307 klasy abstrakcyjne, 309, 319 chronione, 165, 342 kontenerowe, 376 pochodne, 299 potomne, 156 prywatne, 165, 342 publiczne, 165, 342 statyczne, 129 wewn(cid:266)trzne, 165, 342 wewn(cid:266)trzne chronione, 165, 342 zagnie(cid:298)d(cid:298)one, 334 zewn(cid:266)trzne, 344 klawiatura, 255 klawisze specjalne, 253 kod po(cid:286)redni, CIL, 12 (cid:296)ród(cid:225)owy, 11 Poleć książkęKup książkę 412 C#. Praktyczny kurs kolejno(cid:286)(cid:252) wykonywania konstruktorów, 315 kolory, 253 komentarz, 27 blokowy, 27 liniowy, 28 XML, 29 kompilacja, 11 just-in-time, 12 kompilator, 11 csc.exe, 12, 19 mcs, 23 komponenty graficzne, 392 komunikat, 392 o b(cid:225)(cid:266)dzie, 214 konflikty nazw, 328 konsola, 17 konsolidacja, 12 konstruktor, 145, 147 bezargumentowy, 199 domy(cid:286)lny, 314 inicjalizuj(cid:261)cy w(cid:225)a(cid:286)ciwo(cid:286)(cid:252), 195 przyjmuj(cid:261)cy argumenty, 148 struktury, 199 konstruktory klasy bazowej i potomnej, 160 BinaryReader, 285 BinaryWriter, 283 kontener, 346 kontrola typów, 346, 352 konwersja, 239, 293 typów prostych, 290, 293 konwersje warto(cid:286)ci, 54 L linia tekstu, 255 linkowanie, 12 lista plików, 261 listy inicjalizacyjne, 152 listy rozwijane, 404, 405 litera(cid:225) null, 38 litera(cid:225)y, 36 ca(cid:225)kowitoliczbowe, 36 logiczne, 38 (cid:225)a(cid:276)cuchowe, 38 zmiennoprzecinkowe, 37 znakowe, 38 logiczna negacja, 62 (cid:227) (cid:225)a(cid:276)cuchy znakowe, 35, 233 (cid:225)(cid:261)czenie napisów, 45 M manifest, 127 menu, 366, 368, 395 Kompilacja, 21 rozwijane, 368 Tools, 21 z dwoma podpozycjami, 396 metadane, 127 metoda, 122 Draw, 311 DrawShape, 306, 312 Main, 125, 127, 136 ToString, 296, 297 metody abstrakcyjne, 309 klasy BinaryReader, 285, 286 klasy BinaryWriter, 283 klasy Console, 249 klasy Convert, 238 klasy DirectoryInfo, 260 klasy FileInfo, 267 klasy FileStream, 272 klasy FileSystemInfo, 259 klasy Form, 362 klasy StreamReader, 279 klasy StreamWriter, 281 klasy string, 243 operuj(cid:261)ce na polu, 160 prywatne, 307 statyczne, 183 ustawiaj(cid:261)ce pola, 132 wirtualne, 303, 305 zwracaj(cid:261)ce wyniki, 125 zwrotne, 377 modyfikator sealed, 174 modyfikatory dost(cid:266)pu, 164 Mono, 15, 22 MonoDevelop, 15, 23 N nawiasy klamrowe, 68 nazwy zmiennych, 42 negacja bitowa, 59 nieprawid(cid:225)owe dziedziczenie interfejsów, 333 niszczenie obiektu, 154 O obiekt, 118 generuj(cid:261)cy zdarzenie, 386 jako argument, 134 Poleć książkęKup książkę Skorowidz 413 obiekt klasy zagnie(cid:298)d(cid:298)one
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C#. Praktyczny kurs. Wydanie III
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ą: