Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00136 000959 12921766 na godz. na dobę w sumie
C#. Praktyczny kurs. Wydanie II - książka
C#. Praktyczny kurs. Wydanie II - książka
Autor: Liczba stron: 416
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-3870-3 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c# - programowanie
Porównaj ceny (książka, ebook, audiobook).

Dołącz do grona profesjonalnych programistów C#!

C# to nowoczesny, w pełni obiektowy następca języków C i C++, łączący w sobie ich legendarną wydajność z mechanizmami, które doskonale sprawdziły się w środowiskach Javy i Delphi. Opracowany przez firmę Microsoft jako podstawowe narzędzie programistyczne dla platformy .NET, język C# zdobywa coraz większą popularność również za sprawą poziomu bezpieczeństwa, możliwości przenoszenia kodu oraz dostępu do wielu przydatnych narzędzi, które znacznie ułatwiają tworzenie różnego rodzaju programów, w tym aplikacji WWW, sieciowych, bazodanowych i graficznych.

Niezależnie od tego, czy dopiero zaczynasz swoją przygodę z programowaniem, czy też masz już pewne doświadczenie w korzystaniu z innych języków, książka 'C#. Praktyczny kurs. Wydanie II ' będzie dla Ciebie doskonałym wprowadzeniem w arkana praktycznego stosowania języka C#. Dzięki niej poznasz wszystkie niezbędne informacje teoretyczne i szybko zaczniesz pisać swoje pierwsze programy. Dowiesz się nie tylko jak używać podstawowych konstrukcji języka, lecz również jak korzystać z zaawansowanych mechanizmów obiektowych, obsługiwać wyjątki i przeprowadzać operacje wejścia-wyjścia, a nawet tworzyć interfejsy graficzne aplikacji.

Poznaj nowoczesny język programowania! Poznaj 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. Redaktor prowadzący: Ewelina Burska Projekt okładki: Maciej Pasek 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?cshpk2 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Materiały do książki można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/cshpk2.zip ISBN: 978-83-246-3870-3 Copyright © Helion 2012 Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treĈci Wstöp .............................................................................................. 9 Rozdziaä 1. Zanim zaczniesz programowaè ........................................................ 11 Lekcja 1. Podstawowe koncepcje C# i .NET .................................................................. 11 Jak to dziaáa? ............................................................................................................ 11 NarzĊdzia ................................................................................................................. 12 Instalacja narzĊdzi .................................................................................................... 13 Lekcja 2. Pierwsza aplikacja, kompilacja i uruchomienie programu .............................. 16 .NET Framework ...................................................................................................... 17 Visual C# Express .................................................................................................... 19 Mono ........................................................................................................................ 23 MonoDevelop ........................................................................................................... 24 Struktura kodu .......................................................................................................... 26 Lekcja 3. Komentarze ..................................................................................................... 27 Komentarz blokowy ................................................................................................. 27 Komentarz liniowy ................................................................................................... 29 Komentarz XML ...................................................................................................... 29 ûwiczenia do samodzielnego wykonania ................................................................. 31 Rozdziaä 2. Elementy jözyka ............................................................................. 33 Typy danych ................................................................................................................... 33 Lekcja 4. Typy danych w C# .......................................................................................... 34 Typy danych w C# ................................................................................................... 34 Zapis wartoĞci (literaáy) ............................................................................................ 38 Zmienne .......................................................................................................................... 40 Lekcja 5. Deklaracje i przypisania .................................................................................. 40 Proste deklaracje ...................................................................................................... 41 Deklaracje wielu zmiennych .................................................................................... 42 Nazwy zmiennych .................................................................................................... 43 Zmienne typów odnoĞnikowych ............................................................................... 44 ûwiczenia do samodzielnego wykonania ................................................................. 44 Lekcja 6. Wyprowadzanie danych na ekran ................................................................... 45 WyĞwietlanie wartoĞci zmiennych ........................................................................... 45 WyĞwietlanie znaków specjalnych ........................................................................... 48 Instrukcja Console.Write .......................................................................................... 49 ûwiczenia do samodzielnego wykonania ................................................................. 50 4 C#. Praktyczny kurs Lekcja 7. Operacje na zmiennych ................................................................................... 51 Operacje arytmetyczne ............................................................................................. 51 Operacje bitowe ....................................................................................................... 58 Operacje logiczne ..................................................................................................... 62 Operatory przypisania .............................................................................................. 64 Operatory porównywania (relacyjne) ....................................................................... 65 Pozostaáe operatory .................................................................................................. 66 Priorytety operatorów ............................................................................................... 66 ûwiczenia do samodzielnego wykonania ................................................................. 66 Instrukcje sterujące ......................................................................................................... 68 Lekcja 8. Instrukcja warunkowa if...else ........................................................................ 68 Podstawowa postaü instrukcji if...else ...................................................................... 68 ZagnieĪdĪanie instrukcji if...else .............................................................................. 70 Instrukcja if...else if .................................................................................................. 73 ûwiczenia do samodzielnego wykonania ................................................................. 75 Lekcja 9. Instrukcja switch i operator warunkowy ......................................................... 76 Instrukcja switch ...................................................................................................... 76 Przerywanie instrukcji switch ................................................................................... 79 Operator warunkowy ................................................................................................ 81 ûwiczenia do samodzielnego wykonania ................................................................. 82 Lekcja 10. PĊtle .............................................................................................................. 82 PĊtla for .................................................................................................................... 83 PĊtla while ................................................................................................................ 86 PĊtla do...while ......................................................................................................... 88 PĊtla foreach ............................................................................................................. 90 ûwiczenia do samodzielnego wykonania ................................................................. 90 Lekcja 11. Instrukcje break i continue ............................................................................ 91 Instrukcja break ........................................................................................................ 91 Instrukcja continue ................................................................................................... 95 ûwiczenia do samodzielnego wykonania ................................................................. 96 Tablice ............................................................................................................................ 97 Lekcja 12. Podstawowe operacje na tablicach ................................................................ 97 Tworzenie tablic ....................................................................................................... 97 Inicjalizacja tablic .................................................................................................. 100 WáaĞciwoĞü Length ................................................................................................ 101 ûwiczenia do samodzielnego wykonania ............................................................... 103 Lekcja 13. Tablice wielowymiarowe ............................................................................ 103 Tablice dwuwymiarowe ......................................................................................... 104 Tablice tablic .......................................................................................................... 107 Tablice dwuwymiarowe i wáaĞciwoĞü Length ........................................................ 109 Tablice nieregularne ............................................................................................... 110 ûwiczenia do samodzielnego wykonania ............................................................... 114 Rozdziaä 3. Programowanie obiektowe ............................................................ 117 Podstawy ...................................................................................................................... 117 Lekcja 14. Klasy i obiekty ............................................................................................ 118 Podstawy obiektowoĞci .......................................................................................... 118 Pierwsza klasa ........................................................................................................ 119 Jak uĪyü klasy? ....................................................................................................... 121 Metody klas ............................................................................................................ 122 Jednostki kompilacji, przestrzenie nazw i zestawy ................................................. 126 ûwiczenia do samodzielnego wykonania ............................................................... 130 Spis treĈci 5 Lekcja 15. Argumenty i przeciąĪanie metod ................................................................ 131 Argumenty metod ................................................................................................... 131 Obiekt jako argument ............................................................................................. 133 PrzeciąĪanie metod ................................................................................................. 137 Argumenty metody Main ....................................................................................... 138 Sposoby przekazywania argumentów ..................................................................... 139 ûwiczenia do samodzielnego wykonania ............................................................... 143 Lekcja 16. Konstruktory i destruktory .......................................................................... 144 Czym jest konstruktor? ........................................................................................... 144 Argumenty konstruktorów ..................................................................................... 146 PrzeciąĪanie konstruktorów .................................................................................... 147 Sáowo kluczowe this ............................................................................................... 149 Niszczenie obiektu ................................................................................................. 152 ûwiczenia do samodzielnego wykonania ............................................................... 153 Dziedziczenie ............................................................................................................... 154 Lekcja 17. Klasy potomne ............................................................................................ 154 Dziedziczenie ......................................................................................................... 154 Konstruktory klasy bazowej i potomnej ................................................................. 158 ûwiczenia do samodzielnego wykonania ............................................................... 162 Lekcja 18. Modyfikatory dostĊpu ................................................................................. 162 OkreĞlanie reguá dostĊpu ........................................................................................ 163 Dlaczego ukrywamy wnĊtrze klasy? ...................................................................... 168 Jak zabroniü dziedziczenia? ................................................................................... 172 Tylko do odczytu .................................................................................................... 173 ûwiczenia do samodzielnego wykonania ............................................................... 176 Lekcja 19. Przesáanianie metod i skáadowe statyczne ................................................... 177 Przesáanianie metod ................................................................................................ 177 Przesáanianie pól .................................................................................................... 180 Skáadowe statyczne ................................................................................................ 181 ûwiczenia do samodzielnego wykonania ............................................................... 184 Lekcja 20. WáaĞciwoĞci i struktury ............................................................................... 185 WáaĞciwoĞci ........................................................................................................... 185 Struktury ................................................................................................................. 193 ûwiczenia do samodzielnego wykonania ............................................................... 198 Rozdziaä 4. Obsäuga bäödów ............................................................................ 199 Lekcja 21. Blok try...catch ............................................................................................ 199 Badanie poprawnoĞci danych ................................................................................. 199 Wyjątki w C# ......................................................................................................... 203 ûwiczenia do samodzielnego wykonania ............................................................... 207 Lekcja 22. Wyjątki to obiekty ...................................................................................... 208 Dzielenie przez zero ............................................................................................... 208 Wyjątek jest obiektem ............................................................................................ 209 Hierarchia wyjątków .............................................................................................. 211 Przechwytywanie wielu wyjątków ......................................................................... 212 ZagnieĪdĪanie bloków try…catch .......................................................................... 214 ûwiczenia do samodzielnego wykonania ............................................................... 216 Lekcja 23. Tworzenie klas wyjątków ........................................................................... 217 Zgáaszanie wyjątków .............................................................................................. 217 Ponowne zgáoszenie przechwyconego wyjątku ...................................................... 219 Tworzenie wáasnych wyjątków .............................................................................. 221 Sekcja finally .......................................................................................................... 223 ûwiczenia do samodzielnego wykonania ............................................................... 226 6 C#. Praktyczny kurs Rozdziaä 5. System wejĈcia-wyjĈcia ................................................................ 227 Lekcja 24. Ciągi znaków .............................................................................................. 227 Znaki i áaĔcuchy znakowe ...................................................................................... 227 Znaki specjalne ....................................................................................................... 230 Zamiana ciągów na wartoĞci .................................................................................. 232 Formatowanie danych ............................................................................................ 234 Przetwarzanie ciągów ............................................................................................. 236 ûwiczenia do samodzielnego wykonania ............................................................... 240 Lekcja 25. Standardowe wejĞcie i wyjĞcie ................................................................... 241 Klasa Console i odczyt znaków .............................................................................. 241 Wczytywanie tekstu z klawiatury ........................................................................... 248 Wprowadzanie liczb ............................................................................................... 249 ûwiczenia do samodzielnego wykonania ............................................................... 251 Lekcja 26. Operacje na systemie plików ...................................................................... 252 Klasa FileSystemInfo ............................................................................................. 252 Operacje na katalogach .......................................................................................... 252 Operacje na plikach ................................................................................................ 260 ûwiczenia do samodzielnego wykonania ............................................................... 265 Lekcja 27. Zapis i odczyt plików .................................................................................. 265 Klasa FileStream .................................................................................................... 266 Podstawowe operacje odczytu i zapisu ................................................................... 267 Operacje strumieniowe ........................................................................................... 272 ûwiczenia do samodzielnego wykonania ............................................................... 281 Rozdziaä 6. Zaawansowane zagadnienia programowania obiektowego ............. 283 Polimorfizm .................................................................................................................. 283 Lekcja 28. Konwersje typów i rzutowanie obiektów .................................................... 283 Konwersje typów prostych ..................................................................................... 284 Rzutowanie typów obiektowych ............................................................................ 285 Rzutowanie na typ Object ...................................................................................... 289 Typy proste teĪ są obiektowe! ................................................................................ 291 ûwiczenia do samodzielnego wykonania ............................................................... 293 Lekcja 29. PóĨne wiązanie i wywoáywanie metod klas pochodnych ............................ 293 Rzeczywisty typ obiektu ........................................................................................ 294 Dziedziczenie a wywoáywanie metod .................................................................... 296 Dziedziczenie a metody prywatne .......................................................................... 301 ûwiczenia do samodzielnego wykonania ............................................................... 302 Lekcja 30. Konstruktory oraz klasy abstrakcyjne ......................................................... 303 Klasy i metody abstrakcyjne .................................................................................. 303 Wywoáania konstruktorów ..................................................................................... 307 Wywoáywanie metod w konstruktorach ................................................................. 311 ûwiczenia do samodzielnego wykonania ............................................................... 313 Interfejsy ....................................................................................................................... 314 Lekcja 31. Tworzenie interfejsów ................................................................................ 314 Czym są interfejsy? ................................................................................................ 314 Interfejsy a hierarchia klas ...................................................................................... 316 Interfejsy i wáaĞciwoĞci .......................................................................................... 318 ûwiczenia do samodzielnego wykonania ............................................................... 320 Lekcja 32. Implementacja kilku interfejsów ................................................................. 321 Implementowanie wielu interfejsów ...................................................................... 321 Konflikty nazw ....................................................................................................... 323 Dziedziczenie interfejsów ...................................................................................... 326 ûwiczenia do samodzielnego wykonania ............................................................... 328 Spis treĈci 7 Klasy zagnieĪdĪone ...................................................................................................... 329 Lekcja 33. Klasa wewnątrz klasy ................................................................................. 329 Tworzenie klas zagnieĪdĪonych ............................................................................. 329 Kilka klas zagnieĪdĪonych ..................................................................................... 331 Skáadowe klas zagnieĪdĪonych .............................................................................. 332 Obiekty klas zagnieĪdĪonych ................................................................................. 334 Rodzaje klas wewnĊtrznych ................................................................................... 337 DostĊp do skáadowych klasy zewnĊtrznej .............................................................. 338 ûwiczenia do samodzielnego wykonania ............................................................... 340 Typy uogólnione ........................................................................................................... 341 Lekcja 34. Kontrola typów i typy uogólnione .............................................................. 341 Jak zbudowaü kontener? ......................................................................................... 341 Przechowywanie dowolnych danych ...................................................................... 344 Problem kontroli typów .......................................................................................... 347 Korzystanie z typów uogólnionych ........................................................................ 348 ûwiczenia do samodzielnego wykonania ............................................................... 351 Rozdziaä 7. Aplikacje z interfejsem graficznym ................................................ 353 Lekcja 35. Tworzenie okien ......................................................................................... 353 Pierwsze okno ........................................................................................................ 353 Klasa Form ............................................................................................................. 355 Tworzenie menu ..................................................................................................... 360 ûwiczenia do samodzielnego wykonania ............................................................... 364 Lekcja 36. Delegacje i zdarzenia .................................................................................. 364 Koncepcja zdarzeĔ i delegacji ................................................................................ 365 Tworzenie delegacji ............................................................................................... 365 Delegacja jako funkcja zwrotna ............................................................................. 369 Delegacja powiązana z wieloma metodami ............................................................ 373 Zdarzenia ................................................................................................................ 375 ûwiczenia do samodzielnego wykonania ............................................................... 385 Lekcja 37. Komponenty graficzne ................................................................................ 386 WyĞwietlanie komunikatów ................................................................................... 386 Obsáuga zdarzeĔ ..................................................................................................... 387 Menu ...................................................................................................................... 389 Etykiety .................................................................................................................. 391 Przyciski ................................................................................................................. 393 Pola tekstowe ......................................................................................................... 395 Listy rozwijane ....................................................................................................... 398 ûwiczenia do samodzielnego wykonania ............................................................... 401 Zakoþczenie ................................................................................ 403 Skorowidz .................................................................................... 405 8 C#. Praktyczny kurs Rozdziaä 3. Programowanie obiektowe KaĪdy program w C# skáada siĊ z jednej lub wielu klas. W dotychczas prezentowa- nych przykáadach byáa to tylko jednak klasa o nazwie Program. Przypomnijmy sobie naszą pierwszą aplikacjĊ, wyĞwietlającą na ekranie napis. Jej kod wyglądaá nastĊpująco: using System; public class Program { public static void Main() { Console.WriteLine( Mój pierwszy program! ); } } ZaáoĪyliĞmy wtedy, Īe szkielet kolejnych programów, na których demonstrowano struk- tury jĊzyka programowania, ma wáaĞnie tak wyglądaü. Teraz nadszedá czas, aby wyja- Ğniü, dlaczego wáaĞnie tak. Wszystko przedstawi niniejszy rozdziaá. Podstawy Pierwsza czĊĞü rozdziaáu 3. skáada siĊ z trzech lekcji, w których podjĊto tematykĊ pod- staw programowania obiektowego w C#. W lekcji 14. jest omawiana budowa klas oraz tworzenie obiektów. Zostaáy w niej przedstawione pola i metody, sposoby ich deklaracji oraz wywoáywania. Lekcja 15. jest poĞwiĊcona argumentom metod oraz technice prze- ciąĪania metod, zostaáa w niej równieĪ przybliĪona wykorzystywana juĪ wczeĞniej metoda Main. W ostatniej, 16. lekcji, zaprezentowano temat konstruktorów, czyli spe- cjalnych metod wywoáywanych podczas tworzenia obiektów. 118 C#. Praktyczny kurs Lekcja 14. Klasy i obiekty Lekcja 14. rozpoczyna rozdziaá przedstawiający podstawy programowania obiekto- wego w C#. NajwaĪniejsze pojĊcia zostaną tu wyjaĞnione na praktycznych przykáa- dach. Zajmiemy siĊ tworzeniem klas, ich strukturą i deklaracjami, przeanalizujemy zwią- zek miĊdzy klasą i obiektem. Zostaną przedstawione skáadowe klasy, czyli pola i metody, bĊdzie teĪ wyjaĞnione, czym są wartoĞci domyĞlne pól. Opisane zostaną równieĪ relacje miĊdzy zadeklarowaną na stosie zmienną obiektową (inaczej referencyjną, odnoĞnikową) a utworzonym na stercie obiektem. Podstawy obiektowoĈci Program w C# skáada siĊ z klas, które są z kolei opisami obiektów. To podstawowe pojĊ- cia związane z programowaniem obiektowym. Osoby, które nie zetknĊáy siĊ dotych- czas z programowaniem obiektowym, mogą potraktowaü obiekt jako pewien byt pro- gramistyczny, który moĪe przechowywaü dane i wykonywaü operacje, czyli róĪne zadania. Klasa to z kolei definicja, opis takiego obiektu. Skoro klasa definiuje obiekt, jest zatem równieĪ jego typem. Czym jest typ obiektu? Przytoczmy jedną z definicji: „Typ jest przypisany zmiennej, wyraĪeniu lub innemu bytowi programistycznemu (danej, obiektowi, funkcji, procedurze, operacji, metodzie, parametrowi, moduáowi, wyjątkowi, zdarzeniu). Specyfikuje on rodzaj wartoĞci, które moĪe przybieraü ten byt. (...) Jest to równieĪ ograniczenie kontekstu, w którym odwo- áanie do tego bytu moĪe byü uĪyte w programie”1. Innymi sáowy, typ obiektu okreĞla po prostu, czym jest dany obiekt. Tak samo jak miaáo to miejsce w przypadku zmien- nych typów prostych. JeĞli mieliĞmy zmienną typu int, to mogáa ona przechowywaü wartoĞci caákowite. Z obiektami jest podobnie. Zmienna obiektowa hipotetycznej klasy Punkt moĪe przechowywaü obiekty klasy (typu) Punkt2. Klasa to zatem nic innego jak definicja nowego typu danych. Co moĪe byü obiektem? Tak naprawdĊ — wszystko. W Īyciu codziennym mianem tym okreĞliü moĪemy stóá, krzesáo, komputer, dom, samochód, radio… KaĪdy z obiektów ma pewne cechy, wáaĞciwoĞci, które go opisują: wielkoĞü, kolor, powierzchniĊ, wyso- koĞü. Co wiĊcej, kaĪdy obiekt moĪe skáadaü siĊ z innych obiektów (rysunek 3.1). Na przykáad mieszkanie skáada siĊ z poszczególnych pomieszczeĔ, z których kaĪde moĪe byü obiektem; w kaĪdym pomieszczeniu mamy z kolei inne obiekty: sprzĊty domowe, meble itd. Obiekty oprócz tego, Īe mają wáaĞciwoĞci, mogą wykonywaü róĪne funkcje, zadania. Innymi sáowy, kaĪdy obiekt ma przypisany pewien zestaw poleceĔ, które potrafi wyko- nywaü. Na przykáad samochód „rozumie” polecenia „uruchom silnik”, „wyáącz silnik”, 1 K. Subieta, Wytwarzanie, integracja i testowanie systemów informatycznych, PJWSTK, Warszawa 1997. 2 W dalszej czĊĞci ksiąĪki zostanie pokazane, Īe takiej zmiennej moĪna równieĪ przypisaü obiekty klas potomnych lub nadrzĊdnych w stosunku do klasy Punkt. Rozdziaä 3. i Programowanie obiektowe 119 Rysunek 3.1. Obiekt moĪe zawieraü inne obiekty „skrĊü w prawo”, „przyspiesz” itp. Funkcje te skáadają siĊ na pewien interfejs udostĊp- niany nam przez tenĪe samochód. DziĊki interfejsowi moĪemy wpáywaü na zachowanie samochodu i wydawaü mu polecenia. W programowaniu jest bardzo podobnie. Za pomocą klas staramy siĊ opisaü obiekty, ich wáaĞciwoĞci, zbudowaü konstrukcje, interfejs, dziĊki któremu bĊdziemy mogli wyda- waü polecenia realizowane potem przez obiekty. Obiekt powstaje jednak dopiero w trak- cie dziaáania programu jako instancja (wystąpienie, egzemplarz) danej klasy. Obiektów danej klasy moĪe byü bardzo duĪo. JeĞli na przykáad klasą bĊdzie Samochód, to instancją tej klasy bĊdzie konkretny egzemplarz o danym numerze seryjnym. PoniewaĪ dla osób nieobeznanych z programowaniem obiektowym moĪe to wszystko brzmieü nieco zawile, od razu zobaczmy, jak to bĊdzie wyglądaáo w praktyce. Pierwsza klasa ZaáóĪmy, Īe pisany przez nas program wymaga przechowywania danych odnoszących siĊ do punktów na páaszczyĨnie, ekranie. KaĪdy taki punkt jest charakteryzowany przez dwie wartoĞci: wspóárzĊdną x oraz wspóárzĊdną y. Utwórzmy wiĊc klasĊ opisu- jącą obiekty tego typu. Schematyczny szkielet klasy wygląda nastĊpująco: class nazwa_klasy { //treĞü klasy } W treĞci klasy definiujemy pola i metody. Pola sáuĪą do przechowywania danych, metody do wykonywania róĪnych operacji. W przypadku klasy, która ma przechowy- waü dane dotyczące wspóárzĊdnych x i y, wystarczą dwa pola typu int (przy zaáoĪeniu, Īe wystarczające bĊdzie przechowywanie wyáącznie wspóárzĊdnych caákowitych). Pozo- staje jeszcze wybór nazwy dla takiej klasy. WystĊpują tu takie same ograniczenia jak w przypadku nazewnictwa zmiennych (por. lekcja 5.), czyli nazwa klasy moĪe skáadaü siĊ jedynie z liter (zarówno maáych, jak i duĪych), cyfr oraz znaku podkreĞlenia, ale nie moĪe zaczynaü siĊ od cyfry. MoĪna stosowaü polskie znaki diakrytyczne (choü wielu pro- gramistów uĪywa wyáącznie alfabetu áaciĔskiego, nawet jeĞli nazwy pochodzą z jĊzyka polskiego). PrzyjĊte jest równieĪ, Īe w nazwach nie uĪywa siĊ znaku podkreĞlenia. Naszą klasĊ nazwiemy zatem, jakĪeby inaczej, Punkt i bĊdzie ona miaáa postaü widoczną na listingu 3.1. Kod ten zapiszemy w pliku o nazwie Punkt.cs. 120 C#. Praktyczny kurs Listing 3.1. Klasa przechowująca wspóárzĊdne punktów class Punkt { int x; int y; } Ta klasa zawiera dwa pola o nazwach x i y, które opisują wspóárzĊdne poáoĪenia punktu. Pola definiujemy w taki sam sposób jak zmienne. Kiedy mamy zdefiniowaną klasĊ Punkt, moĪemy zadeklarowaü zmienną typu Punkt. Robimy to podobnie jak wtedy, gdy deklarowaliĞmy zmienne typów prostych (np. short, int, char), czyli pisząc: typ_zmiennej nazwa_zmiennej; PoniewaĪ typem zmiennej jest nazwa klasy (klasa to definicja typu danych), to jeĞli nazwą zmiennej ma byü przykladowyPunkt, deklaracja przyjmie postaü: Punkt przykladowyPunkt; W ten sposób powstaáa zmienna odnoĞnikowa (referencyjna, obiektowa), która domyĞl- nie jest pusta, tzn. nie zawiera Īadnych danych. Dokáadniej rzecz ujmując, po dekla- racji zmienna taka zawiera wartoĞü specjalną null, która okreĞla, Īe nie ma ona odnie- sienia do Īadnego obiektu. Musimy wiĊc sami utworzyü obiekt klasy Punkt i przypisaü go tej zmiennej3. Obiekty tworzy siĊ za pomocą operatora new w postaci: new nazwa_klasy(); zatem caáa konstrukcja schematycznie wyglądaü bĊdzie nastĊpująco: nazwa_klasy nazwa_zmiennej = new nazwa_klasy(); a w przypadku naszej klasy Punkt: Punkt przykladowyPunkt = new Punkt(); OczywiĞcie, podobnie jak w przypadku zmiennych typów prostych (por. lekcja 5.), równieĪ i tutaj moĪna oddzieliü deklaracjĊ zmiennej od jej inicjalizacji, zatem równie poprawna jest konstrukcja w postaci: Punkt przykladowyPunkt; przykladowyPunkt = new Punkt(); Koniecznie trzeba sobie dobrze uzmysáowiü, Īe po wykonaniu tych instrukcji w pamiĊci powstają dwie róĪne struktury. Pierwszą z nich jest powstaáa na tak zwanym stosie (ang. stack) zmienna referencyjna przykladowyPunkt, drugą jest powstaáy na tak zwanej stercie (ang. heap) obiekt klasy (typu) Punkt. Zmienna przykladowyPunkt zawiera odniesienie do przypisanego jej obiektu klasy Punkt i tylko poprzez nią moĪemy siĊ do tego obiektu odwoáywaü. Schematycznie zobrazowano to na rysunku 3.2. 3 Osoby programujące w C++ powinny zwróciü na to uwagĊ, gdyĪ w tym jĊzyku juĪ sama deklaracja zmiennej typu klasowego powoduje wywoáanie domyĞlnego konstruktora i utworzenie obiektu. Rozdziaä 3. i Programowanie obiektowe 121 Rysunek 3.2. ZaleĪnoĞü miĊdzy zmienną odnoĞnikową a wskazywanym przez nią obiektem JeĞli chcemy odwoáaü siĊ do danego pola klasy, korzystamy z operatora . (kropka), czyli uĪywamy konstrukcji: nazwa_zmiennej_obiektowej.nazwa_pola_obiektu Przykáadowo przypisanie wartoĞci 100 polu x obiektu klasy Punkt reprezentowanego przez zmienną przykladowyPunkt bĊdzie wyglądaáo nastĊpująco: przykladowyPunkt.x = 100; Jak uĔyè klasy? Spróbujmy teraz siĊ przekonaü, Īe obiekt klasy Punkt faktycznie jest w stanie przecho- wywaü dane. Jak wiadomo z poprzednich rozdziaáów, aby program mógá zostaü uru- chomiony, musi zawieraü metodĊ Main (wiĊcej o metodach juĪ w kolejnym podpunkcie, a o metodzie Main w jednej z kolejnych lekcji). Dopiszmy wiĊc do klasy Punkt taką metodĊ, która utworzy obiekt, przypisze jego polom pewne wartoĞci oraz wyĞwietli je na ekranie. Kod programu realizującego takie zadanie jest widoczny na listingu 3.2. Listing 3.2. UĪ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); } } 122 C#. Praktyczny kurs Struktura klasy Punkt jest taka sama jak w przypadku listingu 3.1, z tą róĪnicą, Īe do jej treĞci zostaáa dodana metoda Main. W tej metodzie deklarujemy zmienną klasy Punkt o nazwie punkt1 i przypisujemy jej nowo utworzony obiekt tej klasy. Dokonujemy zatem jednoczesnej deklaracji i inicjalizacji. Od tej chwili zmienna punkt1 wskazuje na obiekt klasy Punkt, moĪemy siĊ wiĊc posáugiwaü nią tak, jakbyĞmy posáugiwali siĊ samym obiektem. Pisząc punkt1.x = 100, przypisujemy wartoĞü 100 polu x, a pisząc punkt.y = 200, przypisujemy wartoĞü 200 polu y. W ostatnich dwóch liniach korzystamy z instrukcji Console.WriteLine, aby wyĞwietliü wartoĞü obu pól na ekranie. Efekt jest widoczny na rysunku 3.3. Rysunek 3.3. Wynik dziaáania klasy Punkt z listingu 3.2 Metody klas Klasy oprócz pól przechowujących dane zawierają takĪe metody, które wykonują zapi- sane przez programistĊ operacje. Definiujemy je w ciele (czyli wewnątrz) klasy pomiĊdzy znakami nawiasu klamrowego. KaĪda metoda moĪe przyjmowaü argumenty oraz zwracaü wynik. Schematyczna deklaracja metody wygląda nastĊpująco: typ_wyniku nazwa_metody(argumenty_metody) { instrukcje metody } Po umieszczeniu w ciele klasy deklaracja taka bĊdzie natomiast wyglądaáa tak: class nazwa_klasy { typ_wyniku nazwa_metody(argumenty_metody) { instrukcje metody } } JeĞli metoda nie zwraca Īadnego wyniku, jako typ wyniku naleĪy zastosowaü sáowo void; jeĞli natomiast nie przyjmuje Īadnych parametrów, pomiĊdzy znakami nawiasu okrągáego nie naleĪy nic wpisywaü. Aby zobaczyü, jak to wygląda w praktyce, do klasy Punkt dodamy prostą metodĊ, której zadaniem bĊdzie wyĞwietlenie wartoĞci wspóá- rzĊdnych x i y na ekranie. Nadamy jej nazwĊ WyswietlWspolrzedne, zatem jej wygląd bĊdzie nastĊpujący: Rozdziaä 3. i Programowanie obiektowe 123 void WyswietlWspolrzedne() { Console.WriteLine( wspóđrzúdna x = + x); Console.WriteLine( wspóđrzúdna y = + y); } Sáowo void oznacza, Īe metoda nie zwraca Īadnego wyniku, a brak argumentów pomiĊdzy znakami nawiasu okrągáego wskazuje, Īe metoda ta Īadnych argumentów nie przyjmuje. W ciele metody znajdują siĊ dwie dobrze nam znane instrukcje, które wyĞwie- tlają na ekranie wspóárzĊdne punktu. Po umieszczeniu powyĪszego kodu wewnątrz klasy Punkt przyjmie ona postaü widoczną 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óđrzúdna x = + x); Console.WriteLine( wspóđrzúdna y = + y); } } Po utworzeniu obiektu danej klasy moĪemy wywoáaü (uruchomiü) metodĊ w taki sam sposób, w jaki odwoáujemy siĊ do pól klasy, tzn. korzystając z operatora . (kropka). JeĞli zatem przykáadowa zmienna punkt1 zawiera referencjĊ do obiektu klasy Punkt, prawidáowym wywoáaniem metody WyswietlWspolrzedne bĊdzie: punkt1.WyswietlWspolrzedne(); Ogólnie wywoáanie metody wygląda nastĊpująco: nazwa_zmiennej.nazwa_metody(argumenty_metody); OczywiĞcie, jeĞli dana metoda nie ma argumentów, po prostu je pomijamy. Przy czym termin wywoáanie oznacza wykonanie kodu (instrukcji) zawartego w metodzie. UĪyjmy zatem metody Main do przetestowania nowej konstrukcji. W tym celu zmody- fikujemy program z listingu 3.2 tak, aby wykorzystywaá metodĊ WyswietlWspolrzedne. Odpowiedni kod jest zaprezentowany na listingu 3.4. Wynik jego dziaáania jest áatwy do przewidzenia (rysunek 3.4). Listing 3.4. Wywoáanie metody WyswietlWspolrzedne using System; class Punkt { C#. Praktyczny kurs 124 Rysunek 3.4. Wynik dziaáania metody WyswietlWspolrzedne klasy Punkt int x; int y; void WyswietlWspolrzedne() { Console.WriteLine( wspóđrzúdna x = + x); Console.WriteLine( wspóđrzúdna y = + y); } public static void Main() { Punkt punkt1 = new Punkt(); punkt1.x = 100; punkt1.y = 200; punkt1.WyswietlWspolrzedne(); } } Przedstawiony kod jest w istocie záoĪeniem przykáadów z listingów 3.2 i 3.3. Klasa Punkt z listingu 3.3 zostaáa uzupeániona o nieco zmodyfikowany kod metody Main, pobrany z listingu 3.2. W metodzie tej jest wiĊc tworzony nowy obiekt typu Punkt i ustalane są wartoĞci jego pól x i y. Do wyĞwietlenia wartoĞci zapisanych w x i y jest natomiast uĪywana metoda WyswietlWspolrzedne. Zobaczmy teraz, w jaki sposób napisaü metody, które bĊdą mogáy zwracaü wyniki. Typ wyniku naleĪy podaü przed nazwą metody, zatem jeĞli ma ona zwracaü liczbĊ typu int, deklaracja powinna wyglądaü nastĊpująco: int nazwa_metody() { //instrukcje metody } Sam wynik zwracamy natomiast przez zastosowanie instrukcji return. Najlepiej zoba- czyü to na praktycznym przykáadzie. Do klasy Punkt dodamy zatem dwie metody — jedna bĊdzie podawaáa wartoĞü wspóárzĊdnej x, druga y. Nazwiemy je odpowiednio PobierzX i PobierzY. Wygląd metody PobierzX bĊdzie nastĊpujący: int PobierzX() { return x; } Przed nazwą metody znajduje siĊ okreĞlenie typu zwracanego przez nią wyniku — skoro jest to int, oznacza to, Īe metoda ta musi zwróciü jako wynik liczbĊ caákowitą z prze- dziaáu okreĞlonego przez typ int (por. tabela 2.1). Wynik jest zwracany dziĊki instrukcji return. Zapis return x oznacza zwrócenie przez metodĊ wartoĞci zapisanej w polu x. Rozdziaä 3. i Programowanie obiektowe 125 Jak áatwo siĊ domyĞliü, metoda PobierzY bĊdzie wyglądaáa analogicznie, z tym Īe bĊdzie w niej zwracana wartoĞü zapisana w polu y. Peány kod klasy Punkt po dodaniu tych dwóch metod bĊdzie wyglądaá tak, jak przedstawiono na listingu 3.5. Listing 3.5. Metody zwracające wyniki using System; class Punkt { int x; int y; int PobierzX() { return x; } int PobierzY() { return y; } void WyswietlWspolrzedne() { Console.WriteLine( wspóđrzúdna x = + x); Console.WriteLine( wspóđrzúdna y = + y); } } JeĞli teraz zechcemy przekonaü siĊ, jak dziaáają nowe metody, moĪemy wyposaĪyü klasĊ Punkt w metodĊ Main testującą ich dziaáanie. Mogáaby ona mieü postaü widoczną na listingu 3.6. Listing 3.6. Metoda Main testująca dziaá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óđrzúdna x = + wspX); Console.WriteLine( wspóđrzúdna y = + wspY); } Początek kodu jest tu taki sam jak we wczeĞniej prezentowanych przykáadach — powstaje obiekt typu Punkt i są w nim zapisywane przykáadowe wspóárzĊdne. NastĊpnie tworzone są dwie zmienne typu int: wspX i wspY. Pierwszej przypisywany jest efekt dziaáania (zwrócona wartoĞü) metody PobierzX, a drugiej — efekt dziaáania metody PobierzY. WartoĞci zapisane w zmiennych są nastĊpnie wyĞwietlane w standardowy sposób na ekranie. 126 C#. Praktyczny kurs Warto tu zauwaĪyü, Īe zmienne wspX i wspY peánią funkcjĊ pomocniczą — dziĊki nim kod jest czytelniejszy. Nic jednak nie stoi na przeszkodzie, aby wartoĞci zwrócone przez metody byáy uĪywane bezpoĞrednio w instrukcjach Console.WriteLine4. Metoda Main mogáaby wiĊc mieü równieĪ postaü przedstawioną na listingu 3.7. Efekt dziaáania byá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óđrzúdna x = + punkt1.PobierzX()); Console.WriteLine( wspóđrzúdna y = + punkt1.PobierzY()); } Jednostki kompilacji, przestrzenie nazw i zestawy KaĪdą klasĊ moĪna zapisaü w pliku o dowolnej nazwie. CzĊsto przyjmuje siĊ jednak, Īe nazwa pliku powinna byü zgodna z nazwą klasy. JeĞli zatem istnieje klasa Punkt, to jej kod powinien znaleĨü siĊ w pliku Punkt.cs. W jednym pliku moĪe siĊ teĪ znaleĨü kilka klas. Wówczas jednak zazwyczaj są to tylko jedna klasa gáówna oraz dodatkowe klasy pomocnicze. W przypadku prostych aplikacji tych zasad nie trzeba przestrzegaü, ale w przypadku wiĊkszych programów umieszczenie caáej struktury kodu w jednym pliku spowodowaáoby duĪe trudnoĞci w zarządzaniu nim. Pojedynczy plik moĪna nazwaü jednostką kompilacji lub moduáem. Wszystkie dotychczasowe przykáady skáadaáy siĊ zawsze z jednej klasy zapisywanej w jednym pliku. Zobaczmy wiĊc, jak mogą wspóápracowaü ze sobą dwie klasy. Na listingu 3.8 znajduje siĊ nieco zmodyfikowana treĞü klasy Punkt z listingu 3.1. Przed skáadowymi zostaáy dodane sáowa public, dziĊki którym bĊdzie istniaáa moĪliwoĞü odwoáywania siĊ do nich z innych klas. Ta kwestia zostanie wyjaĞniona dokáadniej w jed- nej z kolejnych lekcji. Na listingu 3.9 jest natomiast widoczny kod klasy Program, która korzysta z klasy Punkt. Tak wiĊc treĞü 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; } 4 Po wyjaĞnieniach przedstawionych w tej lekcji moĪna siĊ domyĞliü, Īe to, co do tej pory byáo nazywane instrukcją WriteLine, jest w rzeczywistoĞci wywoáaniem metody o nazwie WriteLine. Rozdziaä 3. i Programowanie obiektowe 127 Listing 3.9. Klasa Program korzystająca z obiektu klasy Punkt using System; public class Program { public static void Main() { Punkt punkt1 = new Punkt(); punkt1.x = 100; punkt1.y = 200; Console.WriteLine( punkt1.x = + punkt1.x); Console.WriteLine( punkt1.y = + punkt1.y); } } W klasie Program znajduje siĊ metoda Main, od której rozpoczyna siĊ wykonywanie kodu aplikacji. W tej metodzie tworzony jest obiekt punkt1 klasy Punkt, jego skáado- wym przypisywane są wartoĞci 100 i 200, a nastĊpnie są one wyĞwietlane na ekranie. Tego typu konstrukcje byáy wykorzystywane juĪ kilkukrotnie we wczeĞniejszych przykáadach. Jak teraz przetworzyü oba kody na plik wykonywalny? Nie jest to skomplikowane, po prostu nazwy obu plików (Program.cs i Punkt.cs) naleĪy zastosowaü jako argumenty wywoáania kompilatora, czyli w wierszu poleceĔ wydaü komendĊ: csc Program.cs Punkt.cs Trzeba teĪ wiedzieü, Īe plik wykonywalny powstaáy po kompilacji nie zawiera tylko kodu wykonywalnego. W rzeczywistoĞci kod wykonywany na platformie .NET skáada siĊ z tak zwanych zestawów (ang. assembly). Pojedynczy zestaw skáada siĊ z manifestu, metadanych oraz kodu jĊzyka poĞredniego IL. Manifest to wszelkie informacje o zesta- wie, takie jak nazwy plików skáadowych, odwoáania do innych zestawów, numer wersji itp. Metadane natomiast to opis danych i kodu jĊzyka poĞredniego w danym zestawie, zawierający m.in. definicje zastosowanych typów danych. Wszystko to moĪe byü umieszczone w jednym pliku lub teĪ w kilku plikach (exe, dll). We wszystkich przykáadach w tej ksiąĪce bĊdziemy mieli do czynienia tylko z zesta- wami jednoplikowymi i bĊdą to pliki wykonywalne typu exe, generowane automa- tycznie przez kompilator, tak Īe nie bĊdziemy musieli zagáĊbiaü siĊ w te kwestie. Nie moĪna jednak pominąü zagadnienia przestrzeni nazw. PrzestrzeĔ nazw to ograniczenie widocznoĞci danej nazwy, ograniczenie kontekstu, w którym jest ona rozpoznawana. Czemu to sáuĪy? OtóĪ pojedyncza aplikacja moĪe siĊ skáadaü z bardzo duĪej liczby klas, a jeszcze wiĊcej klas znajduje siĊ w bibliote- kach udostĊpnianych przez .NET. Co wiĊcej, nad jednym projektem zwykle pracują zespoáy programistów. W takiej sytuacji nietrudno o pojawianie siĊ konfliktów nazw, czyli powstawanie klas o takich samych nazwach. Tymczasem nazwa kaĪdej klasy musi byü unikatowa. Ten problem rozwiązują wáaĞnie przestrzenie nazw. JeĞli bowiem klasa zostanie umieszczona w danej przestrzeni, to bĊdzie widoczna tylko w niej. BĊdą 128 C#. Praktyczny kurs wiĊc mogáy istnieü klasy o takiej samej nazwie, o ile tylko zostaną umieszczone w róĪ- nych przestrzeniach nazw. Taką przestrzeĔ definiuje za pomocą sáowa namespace, a jej skáadowe naleĪy umieĞciü w wystĊpującym dalej nawiasie klamrowym. Schematycznie wygląda to tak: namespace nazwa_przestrzeni { elementy przestrzeni nazw } Przykáadowo jeden programista moĪe pracowaü nad biblioteką klas dotyczących grafiki trójwymiarowej, a drugi nad biblioteką klas wspomagających tworzenie grafiki na páasz- czyĨnie. MoĪna zatem przygotowaü dwie osobne przestrzenie nazw, np. o nazwach Grafika2D i Grafika3D. W takiej sytuacji kaĪdy programista bĊdzie mógá utworzyü wáasną klasĊ o nazwie Punkt i obie te klasy bĊdzie moĪna jednoczeĞnie wykorzystaü w jednej aplikacji. Klasy te mogáyby mieü definicje takie jak na listingach 3.10 i 3.11. Listing 3.10. Klasa Punkt w przestrzeni nazw Grafika2D namespace Grafika2D { class Punkt { public int x; public int y; } } Listing 3.11. Klasa Punkt w przestrzeni nazw Grafika3D namespace Grafika3D { class Punkt { public double x; public double y; } } Jak skorzystaü z jednej z tych klas w jakimĞ programie? Istnieją dwie moĪliwoĞci. Pierwsza z nich to podanie peánej nazwy klasy wraz z nazwą przestrzeni nazw. PomiĊ- dzy nazwą klasy a nazwą przestrzeni naleĪy umieĞciü znak kropki. Na przykáad odwo- áanie do klasy Punkt z przestrzeni Grafika2D miaáoby postaü: Grafika2D.Punkt Sposób ten zostaá przedstawiony na listingu 3.12. Listing 3.12. UĪycie klasy Punkt przestrzeni nazw Grafika2D using System; public class Program { Rozdziaä 3. i Programowanie obiektowe 129 public static void Main() { Grafika2D.Punkt punkt1 = new Grafika2D.Punkt(); punkt1.x = 100; punkt1.y = 200; Console.WriteLine( punkt1.x = + punkt1.x); Console.WriteLine( punkt1.y = + punkt1.y); } } Drugi sposób to uĪycie dyrektywy using w postaci: using nazwa_przestrzeni; NaleĪy ją umieĞciü na samym początku pliku. Nie oznacza ona nic innego, jak informa- cjĊ dla kompilatora, Īe chcemy korzystaü z klas zdefiniowanych w przestrzeni o nazwie nazwa_przestrzeni. Liczba umieszczonych na początku pliku instrukcji using nie jest ograniczona. JeĞli chcemy skorzystaü z kilku przestrzeni nazw, uĪywamy kilku dyrektyw using. Jasne jest wiĊc juĪ, co oznacza fragment: using System; wykorzystywany w praktycznie wszystkich dotychczasowych przykáadach. To dekla- racja, Īe chcemy korzystaü z przestrzeni nazw o nazwie System. Byáa ona niezbĊdna, gdyĪ w tej wáaĞnie przestrzeni jest umieszczona klasa Console zawierająca metody Write i WriteLine. àatwo siĊ domyĞliü, Īe moglibyĞmy pominąü dyrektywĊ using System, ale wtedy instrukcja wyĞwietlająca wiersz tekstu na ekranie musiaáaby przyjmowaü postaü: System.Console.WriteLine( tekst ); Tak wiĊc nasz pierwszy program z listingu 1.1 równie dobrze mógáby mieü postaü widoczną na listingu 3.13. Listing 3.13. PominiĊcie dyrektywy using System public class Program { public static void Main() { System.Console.WriteLine( Mój pierwszy program! ); } } Nie bĊdzie takĪe zaskoczeniem, Īe gdybyĞmy chcieli, aby w programie z listingu 3.12 nie trzeba byáo odwoáywaü siĊ do przestrzeni nazw Grafika2D przy kaĪdym wystąpieniu klasy Punkt, naleĪaáoby uĪyü instrukcji using Grafika2D, tak jak zostaáo to zaprezen- towane na listingu 3.14. Listing 3.14. UĪycie instrukcji using Grafika2D using System; using Grafika2D; public class Program 130 C#. Praktyczny kurs { public static void Main() { Punkt punkt1 = new Punkt(); punkt1.x = 100; punkt1.y = 200; Console.WriteLine( punkt1.x = + punkt1.x); Console.WriteLine( punkt1.y = + punkt1.y); } } Pozostaje jeszcze kwestia jednoczesnego uĪycia klas Punkt z przestrzeni Grafika2D i Grafika3D. MoĪna oczywiĞcie uĪyü dwóch nastĊpujących po sobie instrukcji using: using Grafika2D; using Grafika3D; W Īaden sposób nie rozwiąĪe to jednak problemu. Jak bowiem kompilator (ale takĪe i programista) miaáby wtedy ustaliü, o którą z klas chodzi, kiedy nazywają siĊ one tak samo? Dlatego teĪ w takim wypadku za kaĪdym razem trzeba w odwoáaniu podawaü, o którą przestrzeĔ nazw chodzi. JeĞli wiĊc chcemy zdefiniowaü dwa obiekty: punkt1 klasy Punkt z przestrzeni Grafika2D i punkt2 klasy Punkt z przestrzeni Grafika3D, naleĪy uĪyü instrukcji: Grafika2D.Punkt punkt1 = new Grafika2D.Punkt(); Grafika3D.Punkt punkt2 = new Grafika3D.Punkt(); çwiczenia do samodzielnego wykonania çwiczenie 14.1 Napisz przykáadową klasĊ LiczbaCalkowita, która bĊdzie przechowywaáa wartoĞü caákowitą. Klasa ta powinna zawieraü metodĊ WyswietlLiczbe, która bĊdzie wyĞwietlaáa na ekranie przechowywaną wartoĞü, oraz metodĊ PobierzLiczbe zwracającą prze- chowywaną wartoĞü. çwiczenie 14.2 Napisz kod przykáadowej klasy Prostokat zawierającej cztery pola przechowujące wspóá- rzĊdne czterech rogów prostokąta. çwiczenie 14.3 Do utworzonej w üwiczeniu 14.2 klasy Prostokat dopisz metody zwracające wspóá- rzĊdne wszystkich czterech rogów oraz metodĊ wyĞwietlającą wartoĞci wspóárzĊdnych. çwiczenie 14.4 Do klas LiczbaCalkowita i Prostokat dopisz przykáadową metodĊ Main testującą ich zachowanie. Rozdziaä 3. i Programowanie obiektowe 131 çwiczenie 14.5 Napisz klasĊ Protokat przechowującą jedynie wspóárzĊdne lewego górnego i prawego dolnego rogu (wystarczają one do jednoznacznego wyznaczenia prostokąta na páasz- czyĨnie). Dodaj metody podające wspóárzĊdne kaĪdego rogu. çwiczenie 14.6 Do klasy Prostokat z üwiczeĔ 14.2 i 14.3 dopisz metodĊ sprawdzającą, czy wprowa- dzone wspóárzĊdne faktycznie definiują prostokąt (cztery punkty na páaszczyĨnie dają dowolny czworokąt, który nie musi mieü ksztaátów prostokąta). Lekcja 15. Argumenty i przeciñĔanie metod O tym, Īe metody mogą mieü argumenty, wiadomo z lekcji 14. Czas dowiedzieü siĊ, jak siĊ nimi posáugiwaü. WáaĞnie temu tematowi zostaáa poĞwiĊcona caáa lekcja 15. BĊdzie w niej wyjaĞnione, w jaki sposób przekazuje siĊ metodom argumenty typów prostych oraz referencyjnych, bĊdzie teĪ omówione przeciąĪanie metod, czyli technika umoĪliwiająca umieszczenie w jednej klasie kilku metod o tej samej nazwie. Nieco miejsca zostanie takĪe poĞwiĊcone metodzie Main, od której zaczyna siĊ wykonywanie aplikacji. Zobaczymy równieĪ, w jaki sposób przekazaü aplikacji parametry z wiersza poleceĔ. Argumenty metod W lekcji 14. powiedziano, Īe kaĪda metoda moĪe mieü argumenty. Argumenty metody to inaczej dane, które moĪna jej przekazaü. Metoda moĪe mieü dowolną liczbĊ argu- mentów umieszczonych w nawiasie okrągáym za jej nazwą. Poszczególne argumenty oddzielamy od siebie znakiem przecinka. Schematycznie wygląda to nastĊpująco: typ_wyniku nazwa_metody(typ_argumentu_1 nazwa_argumentu_1, typ_argumentu_2 ´nazwa_argumentu_2, ... , typ_argumentu_N nazwa_argumentu_N) { /* treĞü metody */ } Przykáadowo w klasie Punkt przydaáyby siĊ metody umoĪliwiające ustawianie wspóá- rzĊdnych. Jest tu moĪliwych kilka wariantów — zacznijmy od najprostszych: napi- szemy dwie metody, UstawX i UstawY. Pierwsza bĊdzie odpowiedzialna za przypisanie przekazanej jej wartoĞci polu x, a druga — polu y. Zgodnie z podanym powyĪej sche- matem pierwsza z nich powinna wyglądaü nastĊpująco: void UstawX(int wspX) { x = wspX; } 132 C#. Praktyczny kurs natomiast druga: void UstawY(int wspY) { y = wspY; } Metody te nie zwracają Īadnych wyników, co sygnalizuje sáowo void, przyjmują natomiast jeden parametr typu int. W ciele kaĪdej z metod nastĊpuje z kolei przypi- sanie wartoĞci przekazanej w parametrze odpowiedniemu polu: x w przypadku metody UstawX oraz y w przypadku metody UstawY. W podobny sposób moĪna napisaü metodĊ, która bĊdzie jednoczeĞnie ustawiaáa pola x i y klasy Punkt. OczywiĞcie bĊdzie ona przyjmowaáa dwa argumenty, które w deklaracji naleĪy oddzieliü przecinkiem. Zatem caáa konstrukcja bĊdzie wyglądaáa nastĊpująco: void UstawXY(int wspX, int wspY) { x = wspX; y = wspY; } Metoda UstawXY nie zwraca Īadnego wyniku, ale przyjmuje dwa argumenty: wspX, wspY, oba typu int. W ciele tej metody argument wspX (dokáadniej — jego wartoĞü) zostaje przypisany polu x, a wspY — polu y. JeĞli teraz dodamy do klasy Punkt wszystkie trzy powstaáe wyĪej metody, otrzymamy kod widoczny na listingu 3.15. Listing 3.15. Metody ustawiające pola klasy Punkt using System; class Punkt { int x; int y; int PobierzX() { return x; } int PobierzY() { return y; } void UstawX(int wspX) { x = wspX; } void UstawY(int wspY) { y = wspY; } void UstawXY(int wspX, int wspY) { x = wspX; y = wspY; Rozdziaä 3. i Programowanie obiektowe 133 } void WyswietlWspolrzedne() { Console.WriteLine( wspóđrzúdna x = + x); Console.WriteLine( wspóđrzúdna y = + y); } } Warto teraz napisaü dodatkową metodĊ Main, która przetestuje nowe metody klasy Punkt. DziĊki temu bĊdziemy mogli sprawdziü, czy wszystkie trzy dziaáają zgodnie z naszymi zaáoĪeniami. Taka przykáadowa metoda jest widoczna na listingu 3.165. Listing 3.16. Metoda Main testująca metody ustawiające wspóárzĊdne public static void Main() { Punkt pierwszyPunkt = new Punkt(); Punkt drugiPunkt = new Punkt(); pierwszyPunkt.UstawX(100); pierwszyPunkt.UstawY(100); Console.WriteLine( pierwszyPunkt: ); pierwszyPunkt.WyswietlWspolrzedne(); drugiPunkt.UstawXY(200, 200); Console.WriteLine( drugiPunkt: ); drugiPunkt.WyswietlWspolrzedne(); } Na początku tworzymy dwa obiekty typu (klasy) Punkt, jeden z nich przypisujemy zmiennej o nazwie pierwszyPunkt, drugi zmiennej o nazwie drugiPunkt6. NastĊpnie wykorzystujemy metody UstawX i UstawY do przypisania polom obiektu pierwszyPunkt wartoĞci 100. W kolejnym kroku za pomocą metody WyswietlWspolrzedne wyĞwietlamy te wartoĞci na ekranie. Dalej wykorzystujemy metodĊ UstawXY, aby przypisaü polom obiektu drugiPunkt wartoĞci 200, oraz wyĞwietlamy je na ekranie, równieĪ za pomocą metody WyswietlWspolrzedne. Po skompilowaniu i uruchomieniu tego programu otrzy- mamy widok jak na rysunku 3.5. Obiekt jako argument Argumentem przekazanym metodzie moĪe byü równieĪ obiekt (ĞciĞlej: referencja do obiektu), nie musimy ograniczaü siĊ jedynie do typów prostych. Podobnie metoda moĪe zwracaü obiekt w wyniku swojego dziaáania. W obu wymienionych sytuacjach 5 Na listingach zamieszczonych na páycie CD znajduje siĊ peány kod klasy Punkt, zawierający widoczną metodĊ Main. 6 W rzeczywistoĞci zmiennym zostaáy przypisane referencje (odniesienia) do utworzonych na stercie obiektów. MoĪna jednak stosowaü przedstawioną tu uproszczoną terminologiĊ, w której referencjĊ utoĪsamia siĊ z obiektem. 134 Rysunek 3.5. Efekt wykonania programu z listingu 3.16 C#. Praktyczny kurs postĊpowanie jest takie same jak w przypadku typów prostych. Przykáadowo metoda UstawXY w klasie Punkt mogáaby przyjmowaü jako argument obiekt tej klasy, a nie dwie liczby typu int, tak jak zostaáo to zaprogramowane we wczeĞniejszych przykáadach (listing 3.15). Metoda taka wyglądaáaby nastĊpująco: void UstawXY(Punkt punkt) { x = punkt.x; y = punkt.y; } Argumentem jest w tej chwili obiekt punkt klasy Punkt. W ciele metody nastĊpuje skopiowanie wartoĞci pól z obiektu przekazanego jako argument do obiektu bieĪącego, czyli przypisanie polu x wartoĞci zapisanej w punkt.x, a polu y wartoĞci zapisanej w punkt.y. Podobnie moĪemy umieĞciü w klasie Punkt metodĊ o nazwie PobierzXY, która zwróci w wyniku nowy obiekt klasy Punkt o wspóárzĊdnych takich, jakie zostaáy zapisane w polach obiektu bieĪącego. Metoda taka bĊdzie miaáa postaü: Punkt PobierzXY() { Punkt punkt = new Punkt(); punkt.x = x; punkt.y = y; return punkt; } Jak widaü, nie przyjmuje ona Īadnych argumentów, nie ma przecieĪ takiej potrzeby; z deklaracji wynika jednak, Īe zwraca obiekt klasy Punkt. W ciele metody najpierw tworzymy nowy obiekt klasy Punkt, przypisując go zmiennej referencyjnej o nazwie punkt, a nastĊpnie przypisujemy jego polom wartoĞci pól x i y z obiektu bieĪącego. Ostatecznie za pomocą instrukcji return powodujemy, Īe obiekt punkt staje siĊ warto- Ğcią zwracaną przez metodĊ. Klasa Punkt po wprowadzeniu takich modyfikacji bĊdzie miaáa postaü widoczną na listingu 3.17. Listing 3.17. Nowe metody klasy Punkt using System; class Punkt { int x; int y; Rozdziaä 3. i Programowanie obiektowe 135 int PobierzX() { return x; } int PobierzY() { return y; } void UstawX(int wspX) { x = wspX; } void UstawY(int wspY) { y = wspY; } void UstawXY(Punkt punkt) { x = punkt.x; y = punkt.y; } Punkt PobierzXY() { Punkt punkt = new Punkt(); punkt.x = x; punkt.y = y; return punkt; } void WyswietlWspolrzedne() { Console.WriteLine( wspóđrzúdna x = + x); Console.WriteLine( wspóđrzúdna y = + y); } } Aby lepiej uzmysáowiü sobie sposób dziaáania wymienionych metod, napiszemy teraz kod metody Main, który bĊdzie je wykorzystywaá. NaleĪy go dodaü do klasy najnowszej wersji klasy Punkt z listingu 3.17. Kod ten zostaá zaprezentowany na listingu 3.18. Listing 3.18. Kod metody Main public static void Main() { Punkt pierwszyPunkt = new Punkt(); Punkt drugiPunkt; pierwszyPunkt.UstawX(100); pierwszyPunkt.UstawY(100); Console.WriteLine( Obiekt pierwszyPunkt ma wspóđrzúdne: ); pierwszyPunkt.WyswietlWspolrzedne(); Console.Write( ); drugiPunkt = pierwszyPunkt.PobierzXY(); Console.WriteLine( Obiekt drugiPunkt ma wspóđrzúdne: ); 136 C#. Praktyczny kurs drugiPunkt.WyswietlWspolrzedne(); Console.Write( ); Punkt trzeciPunkt = new Punkt(); trzeciPunkt.UstawXY(drugiPunkt); Console.WriteLine( Obiekt trzeciPunkt ma wspóđrzúdne: ); trzeciPunkt.WyswietlWspolrzedne(); Console.Write( ); } Na początku deklarujemy zmienne pierwszyPunkt oraz drug
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

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