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)