You are on page 1of 46

IDZ DO

PRZYKADOWY ROZDZIA
SPIS TRECI

KATALOG KSIEK
KATALOG ONLINE
ZAMW DRUKOWANY KATALOG

Jzyk C#. Szkoa


programowania
Autor: Klaus Michelsen
Tumaczenie: Krystyna Ziba, Marzena Latawiec,
Marek Bury, Piotr Lubicz
ISBN: 83-246-0358-1
Tytu oryginau: C# Primer Plus
Format: B5, stron: 1128

TWJ KOSZYK
DODAJ DO KOSZYKA

CENNIK I INFORMACJE
ZAMW INFORMACJE
O NOWOCIACH
ZAMW CENNIK

CZYTELNIA
FRAGMENTY KSIEK ONLINE

Wydawnictwo Helion
ul. Kociuszki 1c
44-100 Gliwice
tel. 032 230 98 63
e-mail: helion@helion.pl

Poznaj C# i rozpocznij podr po wiecie programowania


Poznaj elementy jzyka i zasady programowania obiektowego.
Wykorzystaj moliwoci platformy .NET.
Napisz i uruchom wasne aplikacje.
C# to jeden z jzykw programowania wchodzcych w skad platformy .NET.
Wedug zaoe producenta firmy Microsoft ma stanowi podstawowe narzdzie
programistyczne dla tej platformy. C#, czcy w sobie najlepsze cechy jzykw Visual
Basic, C++ i Java, jest atwy do opanowania, a daje ogromne moliwoci. Oparty na
komponentach i obiektach doskonale nadaje si zarwno do tworzenia aplikacji dla
komputerw osobistych, jak i dla urzdze typu PocketPC. Twrcy aplikacji w C# mog
wybiera midzy doskonaym rodowiskiem Visual Studio .NET a kilkoma narzdziami
dostpnymi na licencji open-source.
Ksika Jzyk C#. Szkoa programowania to podrcznik, ktry wprowadzi Ci
w arkana sztuki pisania programw w tym jzyku. Poznasz elementy jzyka C#
i dowiesz si, na czym polega programowanie obiektowe. Nauczysz si korzysta
z zaawansowanych moliwoci oferowanych przez technologi obiektow, takich jak
polimorfizm, interfejsy i struktury. Przeczytasz tu take o obsudze wyjtkw, tworzeniu
dokumentacji w formacie XML w oparciu o komentarze w kodzie oraz o operacjach
wejcia i wyjcia na plikach.
Kompilowanie i uruchamianie programw w C#
Typy i operatory
Instrukcje warunkowe i ptle
Tablice
Klasy i obiekty
Dziedziczenie
Obsuga zdarze
Rekurencja

SPIS TRECI
O autorze .................................................................................................................... 19
Wprowadzenie ........................................................................................................... 21
Rozdzia 1. Komputery i ich programowanie podstawowe pojcia ........... 29
C# obiektowy jzyk programowania ....................................................... 31
Organizacja komputera .............................................................................. 32
Sprzt ................................................................................................................... 32
Waciwoci pamici operacyjnej ............................................................. 34
Systemy liczbowe ........................................................................................ 36
Bajty ............................................................................................................... 37
Pliki ................................................................................................................ 38
Oprogramowanie .............................................................................................. 38
Oglny proces wykonywania programu C# ......................................... 38
System operacyjny ...................................................................................... 39
Jzyki programowania i kompilatory ...................................................... 40
Wprowadzenie do .NET ............................................................................ 41
Kompilacja kodu rdowego C# w .NET ............................................. 42
Podsumowanie .................................................................................................. 45
Pytania kontrolne .............................................................................................. 46
Rozdzia 2. Twj pierwszy program C# .............................................................. 47
Rozwj oprogramowania ................................................................................. 48
Proces tworzenia oprogramowania ............................................................... 48
Algorytmy i pseudokod ................................................................................... 50
Trzy rodzaje bdw ......................................................................................... 53
Programowanie obiektowe pierwsze spotkanie ..................................... 54
Programowanie procesowe i jego wrodzone problemy ....................... 55
Programowanie obiektowe i jego zalety ................................................. 55
Ponowne wykorzystanie oprogramowania .................................................. 60
Zestaw, podstawowa jednostka ponownego wykorzystania
kodu w .NET ................................................................................................ 62
Punkt widzenia programisty ..................................................................... 63
Punkt widzenia uytkownika ................................................................... 64

JZYK C#. SZKOA PROGRAMOWANIA

Biblioteka klas rodowiska .NET Framework ............................................... 66


C# historia i cele projektowania ................................................................ 67
Pochodzenie C# ................................................................................................ 67
Cele utworzenia C# .......................................................................................... 70
Jakiego rodzaju programy mona pisa za pomoc C#? ............................. 71
Mechanizmy tworzenia programu C# .......................................................... 73
Przed rozpoczciem .......................................................................................... 74
Wybr edytora tekstu ....................................................................................... 75
Siedem krokw do napisania prostego programu C# ............................... 75
Otwieranie i uywanie konsoli polece (krok 1.) .................................. 76
Wpisywanie i zapisywanie kodu rdowego C# (krok 2.) ................. 77
Przeksztacanie kodu rdowego w plik PE (.exe) (krok 3.) ............... 80
Jeeli kompilator wykryje bdy skadniowe (krok 4.) ......................... 80
Uruchamianie programu (krok 5.) ............................................................ 81
Sprawdzanie wynikw (krok 6.) ............................................................... 82
Czas na witowanie (krok 7.) ................................................................... 82
Krtka analiza kodu rdowego ................................................................... 82
Uwaga o bdach skadniowych i kompilatorach ........................................ 83
Podsumowanie .................................................................................................. 84
Pytania kontrolne .............................................................................................. 85
wiczenia z programowania ........................................................................... 86
Rozdzia 3. C# wycieczka z przewodnikiem, cz I .................................... 87
Wstp ................................................................................................................... 88
Abstrakcja i hermetyzacja ................................................................................ 88
Abstrakcja ..................................................................................................... 88
Hermetyzacja ............................................................................................... 90
Uwaga o uczeniu si programowania obiektowego ............................. 96
Program interakcyjny Hello World! ............................................................... 97
Tre Hello.cs ............................................................................................... 97
Podstawowe elementy Hello.cs .............................................................. 100
Kilka podstawowych spostrzee .......................................................... 113
Podsumowanie ................................................................................................ 118
Pytania kontrolne ............................................................................................ 119
wiczenia z programowania ......................................................................... 120
Rozdzia 4. C# wycieczka z przewodnikiem, cz II ................................ 123
Wstp ................................................................................................................. 123
Zasadnicze elementy SimpleCalculator.cs .................................................. 124
Prezentacja SimpleCalculator.cs ............................................................. 124
Blisze spojrzenie na SimpleCalculator.cs ............................................ 126
Upraszczanie kodu za pomoc metod ......................................................... 139
Metody jako budowanie blokw hermetyzacja metod
pomocniczych za pomoc sowa kluczowego private .......................... 140

SPIS TRECI

Podsumowanie ................................................................................................ 142


Pytania kontrolne ............................................................................................ 143
wiczenia z programowania ......................................................................... 144
Rozdzia 5. Twj pierwszy program obiektowy w C# .................................... 145
Wstp ................................................................................................................. 146
Struktura leksykalna ....................................................................................... 146
Identyfikatory i style stosowania wielkich liter .................................... 146
Literay ........................................................................................................ 147
Komentarze i dokumentacja kodu rdowego ................................... 148
Separatory .................................................................................................. 148
Operatory ................................................................................................... 149
Sowa kluczowe ......................................................................................... 150
Pewne przemylenia na temat symulacji windy ....................................... 150
Pojcia, cele i rozwizania w programie symulacji windy
zbieranie cennych danych statystycznych do oceny
systemu wind ............................................................................................. 150
Programowanie obiektowe przykad praktyczny ................................ 152
Prezentacja SimpleElevatorSimulation.cs ............................................. 153
Oglna struktura programu .................................................................... 156
Gbsza analiza SimpleElevatorSimulation.cs ...................................... 159
Zwizki klas i UML ................................................................................... 170
Podsumowanie ................................................................................................ 174
Pytania kontrolne ............................................................................................ 175
wiczenia z programowania ......................................................................... 175
Rozdzia 6. Typy, cz I typy proste ............................................................. 177
Wstp ................................................................................................................. 178
Typy w C# przegld ................................................................................. 178
Co to jest typ? ............................................................................................ 179
Jzyk z siln kontrol typw ................................................................... 179
Zalety typw .............................................................................................. 182
Typy w C# ................................................................................................. 183
Typy proste ...................................................................................................... 189
Przegld typw prostych ......................................................................... 191
Typy liczb cakowitych ............................................................................. 196
Zegar Blipos ...................................................................................................... 212
Typy zmiennoprzecinkowe ..................................................................... 222
Typ decimal ................................................................................................ 229
Zgodno wartoci zmiennoprzecinkowych,
decimal i cakowitoliczbowych ......................................................... 231
Jawne konwersje typw ........................................................................... 231
Stae nazwy symboliczne dla literaw ............................................. 233
Formatowanie wartoci liczbowych ....................................................... 237
Typ bool krtkie omwienie .............................................................. 240

JZYK C#. SZKOA PROGRAMOWANIA

Podsumowanie ................................................................................................ 241


Pytania kontrolne ............................................................................................ 243
wiczenia z programowania ......................................................................... 244
Rozdzia 7. Typy, cz II operatory, wyliczenia i acuchy znakowe ......... 245
Wstp ................................................................................................................. 246
Operatory arytmetyczne i wyraenia arytmetyczne ................................. 246
Operatory dwuargumentowe ................................................................. 247
Asocjacyjno ................................................................................................... 251
Nawiasy i pierwszestwo .............................................................................. 252
Operator modulo (%) ..................................................................................... 254
Operatory jednoargumentowe ..................................................................... 259
Jednoargumentowy plus i jednoargumentowy minus ....................... 260
Operatory inkrementacji i dekrementacji ............................................. 261
Okrelanie typu wyraenia ........................................................................... 265
Konwersje i operatory jednoargumentowe plus lub minus .............. 266
czenie rnych typw w jednym wyraeniu ......................................... 268
Dostp do metadanych komponentu krtkie wprowadzenie ........... 272
Stae wyliczeniowe .......................................................................................... 277
Operatory dla zmiennych wyliczanych ...................................................... 281
Konwersje ......................................................................................................... 282
Metody typu System.Enum ........................................................................... 282
Znaki i tekst ...................................................................................................... 283
Typ char ............................................................................................................ 283
Podwjne ycie char ................................................................................. 286
Typ string .......................................................................................................... 287
Literay i obiekty typu string ................................................................... 288
acuchy dosowne .................................................................................. 289
Praca z acuchami ................................................................................... 289
Wstawianie sformatowanych liczb do acucha .................................. 294
Praca z acuchami ................................................................................... 298
Podsumowanie ................................................................................................ 316
Pytania kontrolne ............................................................................................ 317
wiczenia z programowania ......................................................................... 318
Rozdzia 8. Sterowanie, cz I instrukcje warunkowe
i pojcia pokrewne ................................................................................ 321
Wprowadzenie do sterowania przebiegiem ............................................... 322
Rozgazianie za pomoc instrukcji if .......................................................... 324
Prosta instrukcja if ..................................................................................... 324
Instrukcje zoone ..................................................................................... 327
Opcjonalny warunek else ........................................................................ 327
Operatory porwnania i wyraenia logiczne ............................................. 330
Zagniedone instrukcje if ............................................................................ 334
Instrukcje if-else o wielu gaziach ............................................................... 339

SPIS TRECI

Operatory logiczne ......................................................................................... 344


Operator logiczny AND (I) && .......................................................... 346
Operator logiczny OR (LUB) || ........................................................ 350
Skrcone wyznaczanie wartoci wyrae i operatory
na poziomie bitowym, & oraz | ........................................................ 352
Operator na poziomie bitowym Exclusive OR
(alternatywa wykluczajca) ^ ..................................................... 354
Operator logiczny NOT (NIE) ! ......................................................... 355
Zakres zmiennych ........................................................................................... 358
Zakres i czas ycia zmiennych ................................................................ 361
Instrukcja goto ................................................................................................. 362
Instrukcja switch ............................................................................................. 364
Zasada 1. ..................................................................................................... 369
Zasada 2. ..................................................................................................... 370
Zasada 3. ..................................................................................................... 373
Zasada 4. ..................................................................................................... 376
Praca z instrukcjami switch ..................................................................... 376
Operator warunkowy ..................................................................................... 378
Podsumowanie ................................................................................................ 379
Pytania kontrolne ............................................................................................ 380
wiczenia z programowania ......................................................................... 382
Rozdzia 9. Sterowanie, cz II instrukcje iteracyjne ................................. 383
Przegldanie, analiza i generowanie sekwencji danych ............................. 385
Instrukcja sterujca (ptla) while .................................................................. 386
Instrukcja ptli do-while ................................................................................ 390
Instrukcja ptli for ........................................................................................... 394
Instrukcje sterujce break i continue ........................................................... 402
Instrukcja break ......................................................................................... 402
Instrukcja continue ................................................................................... 404
Programowanie strukturalne i konstrukcje strukturalne ....................... 405
Operatory poczonego przypisania ............................................................ 409
Zagniedone instrukcje iteracyjne ............................................................. 410
wiczenia z programowania ......................................................................... 418
Podsumowanie ................................................................................................ 420
Pytania kontrolne ............................................................................................ 421
wiczenia z programowania ......................................................................... 423
Rozdzia 10. Tablice, cz I podstawy ............................................................ 425
Deklarowanie i definiowanie tablicy ........................................................... 427
Uzyskiwanie dostpu do poszczeglnych elementw tablicy ................ 432
Przekroczony zakres indeksu ........................................................................ 438
Wprowadzanie poprawki na indeks tabeli zaczynajcy si od zera ...... 442
Inicjowanie tablicy .......................................................................................... 443
Przemierzanie caej tablicy za pomoc instrukcji foreach .......................... 445

10

JZYK C#. SZKOA PROGRAMOWANIA

System.Array jest typem referencyjnym ..................................................... 447


Tablice i rwno ............................................................................................. 450
Tablice i metody .............................................................................................. 453
Elementy tablic jako argumenty metod ................................................ 453
Referencje do tablic jako argumenty metod ......................................... 455
Klonowanie obiektu tablicy ..................................................................... 458
Metoda wykonywania porwnania tablic w sensie rwnoci wartoci ........463
Argumenty wiersza polece .......................................................................... 465
Uywanie tablic jako wartoci zwracanych przez metody ...................... 467
Tablice i klasy ............................................................................................. 472
Elementy tablicy odnoszce si do obiektw ............................................. 472
Tablice jako zmienne instancji w klasach .................................................... 476
Studium program symulacji banku .................................................. 478
Podsumowanie ................................................................................................ 486
Pytania kontrolne ............................................................................................ 488
wiczenia z programowania ......................................................................... 490
Rozdzia 11. Tablice, cz II tablice wielowymiarowe,
przeszukiwanie i sortowanie tablic ............................................... 491
Tablice wielowymiarowe ............................................................................... 492
Tablice dwuwymiarowe ........................................................................... 493
Tablice wyszczerbione .............................................................................. 514
Tablice z wicej ni dwoma wymiarami ..................................................... 518
Uzyskiwanie dostpu do tablicy wielowymiarowej
w ptli foreach ..................................................................................... 521
Metody wbudowane w klas System.Array ............................................... 522
Techniki rozwizywania problemw tablicowych .................................... 525
Sortowanie .................................................................................................. 525
Przeszukiwanie ................................................................................................ 535
Przeszukiwanie sekwencyjne ................................................................. 536
Przeszukiwanie binarne ........................................................................... 538
Przeszukiwanie za pomoc metody IndexOf() klasy
System.Array ........................................................................................ 544
Podsumowanie ................................................................................................ 546
Pytania kontrolne ............................................................................................ 547
wiczenia z programowania ......................................................................... 548
Rozdzia 12. Anatomia klasy, cz I dowiadczenia
ze statycznymi skadowymi klas i metodami .................................. 551
Podstawy anatomii klasy ............................................................................... 552
Skadowe danych ............................................................................................ 555
Zmienne instancji ...................................................................................... 555
Zmienne statyczne .................................................................................... 557
Skadowe stae ........................................................................................... 565
Skadowe tylko do odczytu ..................................................................... 566
Deklarowanie danych skadowych ........................................................ 566

SPIS TRECI

11

Skadowe funkcyjne ....................................................................................... 567


Metody ........................................................................................................ 567
Metody statyczne ...................................................................................... 570
Podsumowanie ................................................................................................ 605
Pytania kontrolne ............................................................................................ 606
wiczenia z programowania ......................................................................... 609
Rozdzia 13. Anatomia klasy, cz II tworzenie obiektu
i odzyskiwanie pamici .................................................................... 611
Konstruktory instancji .................................................................................... 612
Dlaczego potrzebne s konstruktory instancji? ................................... 612
Praca z konstruktorami instancji ............................................................ 616
Przecienie konstruktorw instancji .................................................... 621
Inicjalizator konstruktora ......................................................................... 628
Prywatne konstruktory instancji ............................................................ 631
Konstruktory statyczne .................................................................................. 631
Skadowe tylko do odczytu ........................................................................... 632
Zbieranie nieuytkw automatyczne dynamiczne
zarzdzanie pamici ............................................................................... 634
Jak sprawi, by obiekty stay si nieosigalne? ..................................... 635
Zadania mechanizmu zbierania nieuytkw ....................................... 639
Zwalnianie brakujcych zasobw innych ni pami ........................ 641
Podsumowanie ................................................................................................ 658
Pytania kontrolne ............................................................................................ 660
wiczenia z programowania ......................................................................... 661
Rozdzia 14. Anatomia klasy, cz III pisanie intuicyjnego kodu ............. 663
Waciwoci ...................................................................................................... 665
Waciwoci a metody dostpowe .......................................................... 665
Waciwoci s szybkie ............................................................................. 672
Implementacja opnionej inicjalizacji i leniwych aktualizacji
z waciwociami ................................................................................. 674
Indeksery uywanie obiektw podobnie jak tablic ................................ 679
Wywoywanie indeksera z wntrza obiektu, w ktrym
rezyduje ................................................................................................ 683
Przecianie indekserw wielokrotne indeksery
w tej samej klasie ................................................................................. 684
Unikanie naduywania indekserw ...................................................... 689
Przecienie operatora ................................................................................... 690
Przecienie operatora zdefiniowane przez uytkownika ................ 692
Zdefiniowane przez uytkownika konwersje niejawne i jawne ............ 701
Dwa przypadki wymagajce konwersji zdefiniowanych
przez uytkownika ............................................................................ 702
Uywanie technik konwersji niezdefiniowanych
przez uytkownika ............................................................................. 704

12

JZYK C#. SZKOA PROGRAMOWANIA

Skadnia konwersji zdefiniowanych przez uytkownika .................. 704


czenie konwersji zdefiniowanej przez uytkownika i niejawnej ........711
Typy zagniedone ......................................................................................... 713
Zalety klas zagniedonych .................................................................... 714
Przykad prostej klasy zagniedonej ................................................... 714
Podsumowanie ................................................................................................ 715
Pytania kontrolne ............................................................................................ 717
wiczenia z programowania ......................................................................... 719
Rozdzia 15. Przestrzenie nazw, jednostki kompilacji i zestawy ..................... 721
Definiowanie wasnej przestrzeni nazw ..................................................... 722
Globalna nienazwana przestrze nazw ...................................................... 723
Przestrzenie nazw i jednostki kompilacji .................................................... 723
Zagniedone przestrzenie nazw ................................................................. 726
Skadnia przestrzeni nazw ............................................................................. 729
Wicej na temat dyrektywy using ................................................................ 731
Aliasy klas i przestrzeni nazw ................................................................. 731
Jednostki kompilacji, przestrzenie nazw oraz zestawy ................................. 733
Kompilowanie kilku jednostek kompilacji do jednego zestawu ...... 734
Wielokrotne wykorzystywanie przestrzeni nazw
zawartych w zestawie ......................................................................... 738
Dzielenie przestrzeni nazw do kilku zestaww ................................... 741
Badanie zestaww za pomoc narzdzia Ildasm ....................................... 744
Podsumowanie ................................................................................................ 746
Pytania kontrolne ............................................................................................ 747
wiczenia z programowania ......................................................................... 749
Rozdzia 16. Dziedziczenie, cz I podstawowe pojcia ............................ 751
Potrzeba dziedziczenia ................................................................................... 753
ycie bez dziedziczenia ............................................................................ 754
Podstawy dziedziczenia ................................................................................. 760
Przesanianie definicji funkcji ................................................................. 765
Modyfikatory dostpu a dziedziczenie ....................................................... 771
Modyfikator dostpu protected .............................................................. 771
Accessing private... .................................................................................... 771
Modyfikator dostpu internal protected ............................................... 773
Przegld modyfikatorw dostpu .......................................................... 774
Konstruktory klas wyprowadzonych .......................................................... 774
Rwnie indeksery s dziedziczone i mog by przesaniane ................ 780
Wywoywanie przesonitych funkcji klasy bazowej ............................... 783
Wielokrotne wykorzystanie biblioteki klas .NET Framework
za pomoc dziedziczenia ......................................................................... 786
Wielopoziomowe wyprowadzanie klas ...................................................... 788
Przesanianie metod i przecianie to rne mechanizmy ...................... 792

SPIS TRECI

13

Podsumowanie ................................................................................................ 794


Pytania kontrolne ............................................................................................ 796
wiczenia z programowania ......................................................................... 797
Rozdzia 17. Dziedziczenie, cz II funkcje abstrakcyjne,
polimorfizm oraz interfejsy ............................................................. 801
Abstrakcyjne metody, waciwoci, indeksery oraz klasy ........................ 802
Polimorfizm ...................................................................................................... 807
Obiekt klasy potomnej ma wicej ni jeden typ .................................. 807
Wizanie dynamiczne metod wirtualnych oraz akcesorw
(get, set) ................................................................................................. 808
Studium prosty program do rysowania ........................................... 810
Tracenie i odzyskiwanie informacji o typie ................................................ 818
Operator is .................................................................................................. 819
Rzutowanie obiektw ............................................................................... 820
Operator as ................................................................................................. 823
System.Object elementarna klasa bazowa ............................................. 823
Ukrywanie metod ........................................................................................... 830
Tworzenie wersji poprzez uycie sw kluczowych new i override ...... 832
Dziedziczenie wielokrotne ............................................................................ 836
Interfejsy ........................................................................................................... 837
Definiowanie interfejsu ............................................................................ 840
Implementacja interfejsu ......................................................................... 841
O programowaniu z interfejsami ........................................................... 845
Budowanie hierarchii interfejsw .......................................................... 850
Konwersje interfejsw .............................................................................. 850
Przecianie wirtualnych implementacji interfejsw ......................... 851
Jawna implementacja funkcji interfejsu ................................................ 852
Podsumowanie ................................................................................................ 855
Pytania kontrolne ............................................................................................ 857
wiczenia z programowania ......................................................................... 858
Rozdzia 18. Struktury ............................................................................................. 861
Definiowanie struktur .................................................................................... 862
Pakowanie i odpakowywanie ....................................................................... 865
Tworzenie struktur ze sowem kluczowym new oraz bez niego ............ 866
Typy wartociowe a typy referencyjne ....................................................... 867
Podsumowanie ................................................................................................ 869
Pytania kontrolne ............................................................................................ 869
wiczenia z programowania ......................................................................... 870
Rozdzia 19. Obsuga wyjtkw ............................................................................ 871
Obsuga wyjtkw krtki przegld ......................................................... 872
Rzeczywisto bez try-catch-finally .............................................................. 873
Bloki try oraz catch .......................................................................................... 875

14

JZYK C#. SZKOA PROGRAMOWANIA

Przechwytywanie obiektw wyjtkw w wyszych ogniwach


acucha wywoa .................................................................................... 878
Wieloskadnikowe bloki catch ....................................................................... 880
Blok finally ........................................................................................................ 881
Zagniedone bloki try .................................................................................. 884
throw jawne wyrzucanie wyjtkw ....................................................... 886
Pisanie wasnych wyjtkw .......................................................................... 889
Podsumowanie ................................................................................................ 892
Pytania kontrolne ............................................................................................ 892
wiczenia z programowania ......................................................................... 893
Rozdzia 20. Delegaty i zdarzenia ......................................................................... 895
Delegaty ............................................................................................................ 896
Tablice delegatw oraz delegaty przekazywane
jako argument wywoa metod ....................................................... 900
Delegaty grupowe ..................................................................................... 905
Zdarzenie .......................................................................................................... 908
Pisanie programw dziaajcych w oparciu o zdarzenia ................... 909
Podsumowanie ................................................................................................ 917
Pytania kontrolne ............................................................................................ 917
wiczenia z programowania ......................................................................... 918
Rozdzia 21. Przetwarzanie wstpne, dokumentacja XML oraz atrybuty ..... 919
Dyrektywy preprocesora ............................................................................... 920
Wyczanie i doczanie kodu za pomoc #define, #if
oraz #endif ........................................................................................... 920
#undef usuwanie definicji identyfikatorw ................................... 923
#elif oraz #else .......................................................................................... 923
#error oraz #warning .............................................................................. 924
#region oraz #endregion ........................................................................ 924
#line ............................................................................................................ 924
Dokumentacja XML ........................................................................................ 924
Prosty przykad dokumentacji XML ...................................................... 925
Atrybuty ............................................................................................................ 927
Prosty przykad oznaczania atrybutami ................................................ 930
Podsumowanie ................................................................................................ 933
Pytania kontrolne ............................................................................................ 934
wiczenia z programowania ......................................................................... 936
Rozdzia 22. Wejcie i wyjcie z wykorzystaniem plikw ................................. 939
Wejcie/wyjcie z wykorzystaniem plikw i podstawy strumieni .......... 940
Pliki tekstowe i pliki binarne ................................................................... 940
Przegld klas wejcia/wyjcia z wykorzystaniem plikw ...................... 941
Klasa FileInfo .................................................................................................... 942
Realizacja wejcia do plikw tekstowych i wyjcia z nich
poprzez StreamReader oraz StreamWriter ........................................... 946

SPIS TRECI

15

Realizacja binarnego wejcia i wyjcia za pomoc klasy FileStream ...... 951


Podsumowanie ................................................................................................ 955
Pytania kontrolne ............................................................................................ 955
wiczenia z programowania ......................................................................... 956
Rozdzia 23. Podstawy rekurencji ......................................................................... 959
Oczekujce instancje metody w rnych metodach ................................. 960
Oczekujce instancje metody w ramach tej samej metody ................... 962
Dziaanie rekurencji obliczenie silni n .................................................... 965
Rekurencja a iteracja ....................................................................................... 969
Przeszukiwanie binarne za pomoc rekurencji ......................................... 970
Podsumowanie ................................................................................................ 974
Pytania kontrolne ............................................................................................ 974
wiczenia z programowania ......................................................................... 975
Dodatek A Odpowiedzi na pytania i rozwizania wicze ............................. 977
Rozdzia 1 ......................................................................................................... 977
Odpowiedzi na pytania kontrolne z rozdziau 1 ................................. 977
Rozdzia 2 ......................................................................................................... 978
Odpowiedzi na pytania kontrolne z rozdziau 2 ................................. 978
Odpowiedzi do wicze z programowania z rozdziau 2 .................. 980
Rozdzia 3 ......................................................................................................... 981
Odpowiedzi na pytania kontrolne z rozdziau 3 ................................. 981
Odpowiedzi do wicze z programowania z rozdziau 3 .................. 982
Rozdzia 4 ......................................................................................................... 983
Odpowiedzi na pytania kontrolne z rozdziau 4 ................................. 983
Odpowiedzi do wicze z programowania z rozdziau 4 .................. 984
Rozdzia 5 ......................................................................................................... 987
Odpowiedzi na pytania kontrolne z rozdziau 5 ................................. 987
Odpowiedzi do wicze z programowania z rozdziau 5 .................. 988
Rozdzia 6 ......................................................................................................... 989
Odpowiedzi na pytania kontrolne z rozdziau 6 ................................. 989
Odpowiedzi do wicze z programowania z rozdziau 6 .................. 990
Rozdzia 7 ......................................................................................................... 996
Odpowiedzi na pytania kontrolne z rozdziau 7 ................................. 996
Odpowiedzi do wicze z programowania z rozdziau 7 .................. 998
Rozdzia 8 ....................................................................................................... 1000
Odpowiedzi na pytania kontrolne z rozdziau 8 ............................... 1000
Odpowiedzi do wicze z programowania z rozdziau 8 ................ 1002
Rozdzia 9 ....................................................................................................... 1004
Odpowiedzi na pytania kontrolne z rozdziau 9 ............................... 1004
Odpowiedzi do wicze z programowania z rozdziau 9 ................ 1005
Rozdzia 10 ..................................................................................................... 1007
Odpowiedzi na pytania kontrolne z rozdziau 10 ............................. 1007
Odpowiedzi do wicze z programowania z rozdziau 10 .............. 1008

16

JZYK C#. SZKOA PROGRAMOWANIA

Rozdzia 11 ..................................................................................................... 1011


Odpowiedzi na pytania kontrolne z rozdziau 11 ............................. 1011
Odpowiedzi do wicze z programowania z rozdziau 11 .............. 1012
Rozdzia 12 ..................................................................................................... 1018
Odpowiedzi na pytania kontrolne z rozdziau 12 ............................. 1018
Odpowiedzi do wicze z programowania z rozdziau 12 .............. 1019
Rozdzia 13 ..................................................................................................... 1022
Odpowiedzi na pytania kontrolne z rozdziau 13 ............................. 1022
Odpowiedzi do wicze z programowania z rozdziau 13 .............. 1024
Rozdzia 14 ..................................................................................................... 1026
Odpowiedzi na pytania kontrolne z rozdziau 14 ............................. 1026
Odpowiedzi do wicze z programowania z rozdziau 14 .............. 1027
Rozdzia 15 ..................................................................................................... 1032
Odpowiedzi na pytania kontrolne z rozdziau 15 ............................. 1032
Odpowiedzi do wicze z programowania z rozdziau 15 .............. 1033
Rozdzia 16 ..................................................................................................... 1036
Odpowiedzi na pytania kontrolne z rozdziau 16 ............................. 1036
Odpowiedzi do wicze z programowania z rozdziau 16 .............. 1037
Rozdzia 17 ..................................................................................................... 1040
Odpowiedzi na pytania kontrolne z rozdziau 17 ............................. 1040
Odpowiedzi do wicze z programowania z rozdziau 17 .............. 1042
Rozdzia 18 ..................................................................................................... 1047
Odpowiedzi na pytania kontrolne z rozdziau 18 ............................. 1047
Odpowiedzi do wicze z programowania z rozdziau 18 .............. 1047
Rozdzia 19 ..................................................................................................... 1049
Odpowiedzi na pytania kontrolne z rozdziau 19 ............................. 1049
Odpowiedzi do wicze z programowania z rozdziau 19 .............. 1050
Rozdzia 20 ..................................................................................................... 1051
Odpowiedzi na pytania kontrolne z rozdziau 20 ............................. 1051
Odpowiedzi do wicze z programowania z rozdziau 20 .............. 1052
Rozdzia 21 ..................................................................................................... 1058
Odpowiedzi na pytania kontrolne z rozdziau 21 ............................. 1058
Odpowiedzi do wicze z programowania z rozdziau 21 .............. 1060
Rozdzia 22 ..................................................................................................... 1063
Odpowiedzi na pytania kontrolne z rozdziau 22 ............................. 1063
Odpowiedzi do wicze z programowania z rozdziau 22 .............. 1063
Rozdzia 23 ..................................................................................................... 1066
Odpowiedzi na pytania kontrolne z rozdziau 23 ............................. 1066
Odpowiedzi do wicze z programowania z rozdziau 23 .............. 1067
Dodatek B Kolejno operatorw ..................................................................... 1069
Dodatek C Zarezerwowane sowa w C# ........................................................ 1073

SPIS TRECI

17

Dodatek D Systemy liczbowe ............................................................................ 1075


Wprowadzenie .............................................................................................. 1075
System binarny .............................................................................................. 1076
Bity i bajty ....................................................................................................... 1078
System semkowy (oktalny) ....................................................................... 1078
System szesnastkowy (heksadecymalny) .................................................. 1080
Praktyczne zastosowanie liczb semkowych i szesnastkowych ........... 1082
Konwersja z systemu o podstawie 10 na systemy
o podstawie 2, 8 i 16 ................................................................................ 1084
Program do rekurencyjnej konwersji
pomidzy systemami liczbowymi ........................................................ 1085
Ujemne liczby binarne .................................................................................. 1090
Dodatek E Zestaw znakw Unicode ................................................................ 1093
Dodatek F Wykorzystanie polece systemu DOS w oknie konsoli ........... 1099
Skorowidz .............................................................................................................. 1099

5
TWJ PIERWSZY PROGRAM
OBIEKTOWY W C#
W tym rozdziale dowiesz si:
z
z

z
z
z

Jakie niepodzielne elementy


zawiera program rdowy C#,
Jakie konwencjonalne style
nazywania klas, metod
i zmiennych funkcjonuj podczas
programowania w C#,
Na jakiej zasadzie dziaaj
operatory, argumenty i wyraenia,
Jak pisa i tworzy instancje
swoich wasnych klas,
Jak mona wdroy teoretyczn
dyskusj obiektow o klasach
Elevators i Person
z rozdziau 3., C# wycieczka
z przewodnikiem, cz I,
aby utworzy w peni dziaajcy
program C#,
Jak wyglda prosty program
obiektowy i jego wane elementy,

Jak inicjalizowa zmienne


instancji nowo utworzonych
obiektw,
W jaki sposb obiekty osigaj
zdolno do zawierania
zmiennych instancji, ktre
zawieraj inne obiekty,
Jak programici implementuj
zalenoci midzy klasami,
aby umoliwi im wspprac
i tworzy programy obiektowe,
Po co utworzono zunifikowany
jzyk modelowania (Unified
Modeling Language UML)
i jak mona go zastosowa
do ilustracji graficznej
oraz modelowania zalenoci
midzy klasami,
W jaki sposb asocjacja,
agregacja i kompozycja reguluj
zalenoci midzy klasami.

146

JZYK C#. SZKOA PROGRAMOWANIA

Wstp
Dotychczas zapoznalimy si z dwoma programami rdowymi przedstawionymi
w listingach 3.1 w rozdziale 3. i 4.1 w rozdziale 4. Przedstawione tam konstrukcje
jzyka C# w pewnym stopniu zaleay od treci poszczeglnych wierszy kodu
i w rezultacie zajmoway si jednoczenie wieloma rnorodnymi, ale wzajemnie
zwizanymi ze sob aspektami. Aby nadrobi braki tej szybkiej wycieczki po C#,
pierwsza cz tego rozdziau bdzie powicona przegldowi podstawowych elementw C#.
W ostatniej czci rozdziau zobaczymy pierwszy w tej ksice program obiektowy C#.
Jest on oparty na poprzednich teoretycznych dyskusjach obiektowych, a zwaszcza
na omwieniu symulacji windy na pocztku rozdziau 3. Pozwala m.in. zaobserwowa, jak omwiony wczeniej zwizek midzy klasami Elevator i Person jest
implementowany w C#.

Struktura leksykalna
Kiedy kompilator C# otrzymuje kawaek kodu rdowego do kompilacji, staje przed
pozornie zniechcajcym zadaniem rozszyfrowania dugiej listy znakw (dokadniej, znakw Unicode, przedstawionych w dodatku E, Zestaw znakw Unicode)
i przeksztacenia ich na odpowiedni MSIL o znaczeniu dokadnie tym samym, co
oryginalny kod rdowy. Aby znale sens tej masy kodu rdowego, musi rozpozna niepodzielne elementy C# niedajce si rozbi czci tworzce kod rdowy C#. Przykadami takich niepodzielnych elementw s: nawias klamrowy ({),
nawias (() oraz sowa kluczowe, np. class i if. Zadanie, ktre wykonuje kompilator, zwizane z rozrnieniem otwierajcych i zamykajcych nawiasw klamrowych, sw kluczowych, nawiasw itd., nazywa si analiz leksykaln. W zasadzie,
kwestie leksykalne, ktrymi zajmuje si kompilator, odnosz si do tego, jak znaki
kodu rdowego mona przetumaczy na znaki zrozumiae dla kompilatora.
Programy C# s zbiorem identyfikatorw, sw kluczowych, odstpw, komentarzy,
literaw, operatorw i separatorw. Z wikszoci tych elementw C# ju spotkalimy si. W dalszym cigu rozdziau dokonamy ich przegldu, a take wprowadzimy
jeszcze kilka innych aspektw.

Identyfikatory i style stosowania wielkich liter


Identyfikatory su do nazywania klas, metod i zmiennych. Dowiedzielimy si ju,
jakich zasad naley przestrzega, aby identyfikator by prawidowy, oraz tego, e
dobrze wybrane identyfikatory mog poprawi klarowno kodu rdowego i sprawi, e kod bdzie samodokumentujcy. Teraz wprowadzimy inny aspekt zwizany
z identyfikatorami, a mianowicie styl stosowania wielkich liter.

Rozdzia 5. TWJ PIERWSZY PROGRAM OBIEKTOWY W C#

147

Programici czsto wybieraj identyfikatory skadajce si z kilku sw, aby kod


rdowy by bardziej klarowny i samodokumentujcy. Mona by np. zastosowa
sowa urodzenia rocznie. Jednake kompilator reaguje na odstp i kady identyfikator podzielony na sowa za pomoc odstpu bdzie bdnie interpretowany.
Przykadowo zmiennej, ktra ma przedstawia redni prdko na godzin, nie
mona nazwa srednia predkosc na godzine1. Musimy wyrzuci odstpy,
aby utworzy jedn prawidow nazw, zachowujc styl pozwalajcy czytelnikowi
kodu rdowego rozrnia poszczeglne sowa identyfikatora. Niektre jzyki
komputerowe akceptuj konwencj srednia_predkosc_na_godzine. Natomiast
w C# wikszo programistw stosuje uzgodnion sekwencj duych i maych liter
w celu rozrnienia poszczeglnych sw identyfikatora.
W wiecie C# istnieje wiele wanych stylw uywania wielkich liter:
Styl Pascal pierwsza litera kadego sowa w nazwie jest du liter, np. SredniaPredkoscNaGodzine,
Styl Camel tak jak Pascal, z tym wyjtkiem, e cae pierwsze sowo identyfikatora jest pisane maymi literami, np. sredniaPredkoscNaGodzine.
Styl Pascal jest zalecany do nazywania klas i metod, a styl Camel suy do nazywania
zmiennych.

Wskazwka
Nie wszystkie jzyki komputerowe odrniaj mae i wielkie litery. W takich jzykach sowa Srednia i srednia s identyczne dla kompilatora. W celu uzyskania
kompatybilnoci z tymi jzykami, naley unika sytuacji, w ktrych wielko liter
decyduje o rozrnialnoci identyfikatorw typu public, ktre s dostpne dla
innych jzykw.

Literay
Rozwamy dwa nastpujce wiersze kodu rdowego:
int number;
number = 10;

number jest wyranie zmienn. W pierwszym wierszu deklarujemy, e number ma


by typu int. W drugim wierszu przypisujemy number warto 10. Ale co to jest 10?
No wanie, 10 nie moe zmienia swojej wartoci i nazywa si literaem. Literay to
nie tylko liczby. Mog to by rwnie znaki, takie jak B, $ i z, a take tekst, np. To

W wielu jzykach programowania pojawiaj si kopoty przy korzystaniu w identyfikatorach


z polskich znakw diakrytycznych (, , itp.). Jeli wic uywamy polskich nazw, warto takich liter
unika przyp. tum.

148

JZYK C#. SZKOA PROGRAMOWANIA

jest litera. Literay mog by przechowywane w dowolnej zmiennej, ktrej


typ jest kompatybilny z typem literau.

Komentarze i dokumentacja kodu rdowego


Gwn cech komentarzy jest to, e s cakowicie ignorowane przez kompilator.
Dotychczas poznalimy dwa sposoby tworzenia komentarzy; jednowierszowe oznaczamy za pomoc //, a wielowierszowe przy uyciu /* */.
Istnieje jeszcze trzeci typ, ktry umoliwia zapisywanie dokumentacji jako czci
kodu rdowego, co bdzie pokazane w tym rozdziale, przy czym dodatkowo mona
umieci t dokumentacj w osobnych plikach eXtensible Markup Language (XML).
W tej chwili wystarczy doceni szczeglnie przydatny wynik kocowy tej waciwoci;
trzeba tylko zajrze do dokumentacji bibliotek klas .NET Framework, ktra zostaa
stworzona przez utworzenie plikw XML z komentarzy/dokumentacji znajdujcych
si w oryginalnym kodzie rdowym.

Separatory
W jzyku C# separatory su do oddzielania od siebie rnych elementw. Spotkalimy ju wiele z nich. Przykadem moe by powszechnie stosowany rednik ;,
ktry jest wymagany do zakoczenia instrukcji. W tabeli 5.1 zebrano separatory, ktre
ju poznalimy.

Tabela 5.1. Wane separatory w C#


Nazwa

Symbol

Cel

Nawiasy
klamrowe

{ }

Su do zamknicia bloku kodu dla klas, metod oraz, co pokaemy


pniej, instrukcji rozgazie i ptli.

Nawiasy

( )

Zawieraj listy parametrw formalnych w nagwkach metod oraz


listy argumentw w instrukcjach wywoywania metod. W nawiasie
musz znajdowa si rwnie wyraenia logiczne (booleowskie)
w instrukcji if, a take w instrukcjach rozgazie i ptli, co bdzie
pokazane pniej.

rednik

Koczy instrukcj.

Przecinek

Oddziela parametry formalne w nawiasie nagwka metody i oddziela


argumenty w instrukcji wywoania metody.

Kropka

Suy do wyznaczania przestrzeni nazw zawartych wewntrz innych


przestrzeni i do okrelania klas wewntrz tych przestrzeni, i metod
(o ile s dostpne) wewntrz klas i obiektw. Moe by rwnie
stosowana do okrelania zmiennych instancji wewntrz klas i obiektw
(o ile s dostpne), ale tej praktyki naley unika.

Rozdzia 5. TWJ PIERWSZY PROGRAM OBIEKTOWY W C#

149

Operatory
Operatory s przedstawiane za pomoc symboli, takich jak +, =, == i *. Operatory
dziaaj na argumenty, ktre znajduj si obok operatora, np.:
sumTotal + 10

zawiera operator + otoczony dwoma argumentami, sumTotal i 10. W tym kontekcie operator + czy dwa argumenty w celu uzyskania wyniku, a wic jest to operator dwuargumentowy. Niektre operatory dziaaj na tylko jeden argument; nazywa
si je wic operatorami jednoargumentowymi.
Operatory wraz ze swoimi argumentami tworz wyraenia. Sam litera lub zmienna
s rwnie wyraeniami, tak jak kombinacje literaw i zmiennych z operatorami.
W rezultacie wyraenia mog by stosowane jako argumenty pod warunkiem, e s
spenione zasady, ktre maj zastosowanie do kadego operatora, co pokazano na
nastpujcym przykadzie:

a, 5 i 10, d to s wyraenia, na ktre dziaa operator +. Natomiast


(a + 5) i (10 + d)
s rwnie wyraeniami, na ktre dziaa operator *. Na koniec,
(a + 5) (10 + d)
mona uwaa za jedno wyraenie. Operator przypisania = dziaa na to ostatnie
wyraenie i wyraenie mySum. Wyraenia s czsto zagniedone w sobie nawzajem,
tworzc hierarchi wyrae, tak jak w poprzednim przykadzie.
Operatory mona podzieli na nastpujce kategorie: operatory przypisania, arytmetyczne, jednoargumentowe, rwnoci, porwnania, logiczne, warunkowe, przesunicia i podstawowe.
W dalszych rozdziaach powicimy troch wicej czasu na omwienie operatorw,
ale na razie podsumujmy szybko te, ktre dotychczas napotkalimy.
Operator przypisania (=) powoduje, e argument po jego lewej stronie zmienia
swoj warto na wyraenie znajdujce si po prawej, jak w wierszu
29:

sumTotal = a + b;

gdzie a + b mona uwaa za jeden argument.

150

JZYK C#. SZKOA PROGRAMOWANIA

Dwuargumentowe operatory arytmetyczne (+ i *) w nastpujcym przykadzie


a * b

wystpuje mnoenie a i b bez zmiany ich wartoci.


Operator konkatenacji (+) czy dwa acuchy znakowe w jeden acuch.
Operator rwnoci (==) porwnuje dwa wyraenia, aby sprawdzi, czy s
rwne, np.:
leftExpression == rightExpression

to prawda tylko wtedy, gdy oba wyraenia bd rwne; w przeciwnym razie bdzie
to fasz.

Sowa kluczowe
W dodatku C podano 77 sw kluczowych C# (wszystkie). Dotychczas spotkalimy
sowa kluczowe, takie jak if, class, public, static, void, string, int i return.
Skadnia (zasady jzykowe) operatorw i separatorw poczonych ze sowami kluczowymi tworzy definicj jzyka C#.

Pewne przemylenia na temat symulacji windy


Program C# przedstawiony po poniszej analizie przypadku jest pierwsz prb
(prototypem) implementacji obiektowej symulacji windy. Analiza przypadku wprowadza kilka celw, problemw i rozwiza prostej symulacji windy i usiuje wprowadzi odpowiedni nastrj dla praktycznego przykadu C#. Jest to rwnie przypomnienie dyskusji o hermetyzacji na pocztku rozdziau 3.

Pojcia, cele i rozwizania w programie symulacji


windy zbieranie cennych danych statystycznych
do oceny systemu wind
Analiza przypadku bada strategi zbierania wanych informacji z danej symulacji
windy, aby odpowiedzie na pytanie: Czy system wind, ktry symulujemy, wykonuje
prawidowo zadanie przewoenia pasaerw midzy pitrami?. Innymi sowy,
gdybymy wzili rzeczywisty system wind, wycignli jego wszystkie stosowne cechy
i przeksztacili w symulacj komputerow, to jak dobrze dziaaby taki system?

Rozdzia 5. TWJ PIERWSZY PROGRAM OBIEKTOWY W C#

151

Statystyka
Liczbowy fakt lub dane, zwaszcza obliczone z prbki, nazywa si statystyk.
Statystyka jest nauk, ktra zajmuje si zbieraniem, klasyfikacj, analiz i interpretacj liczbowych faktw lub danych, i ktra, przy uyciu matematycznych teorii
prawdopodobiestwa, narzuca porzdek i regularno agregatw mniej lub bardziej
odmiennych elementw.
Termin statystyka stosuje si rwnie w odniesieniu do samych liczbowych faktw
lub danych.

Wikszo uytkownikw, oceniajc system wind, uwaa za wane dwie statystyki:


czas, przez jaki przecitna osoba musi czeka na pitrze po naciniciu przycisku
na przyjazd windy,
redni czas, jaki zajmuje podr na jedno pitro.
Prba zebrania tych wartoci z symulacji windy moe wyglda nastpujco.
Poniewa obiekty Person (osoba) podruj dziki systemowi wind, dla nich jest
oczywiste, e obiekty Elevator (winda) musz wiadczy usugi. W rezultacie obiekty
Person bd wiedziay, jak dobrze dziaa system i bd w stanie zebra niektre
z wymaganych, zasadniczych statystyk. Analogiczn strategi w wiecie rzeczywistym byoby przeprowadzenie wywiadw z uytkownikami systemu wind i zebranie
pewnych ich dowiadcze z tym systemem.
Kady obiekt Person programu symulacyjnego windy mona zaimplementowa
w taki sposb, aby mia par zmiennych instancji ledzcych jego cakowity czas
oczekiwania poza wind (jako odpowied na pierwszy wyrnik) i redni czas jazdy na
pitro (odnoszcy si do drugiego wyrnika). Wskazywayby one, jak dobrze dziaa
system wind i byyby czci statystyk zebranych dla kadej symulacji. Moglibymy
nazwa te zmienne totalWaitingTime (cakowity czas oczekiwania) i averageFloorTravelingTime (redni czas jazdy na pitro).
Obliczenie totalWaitingTime wymagaoby metody umieszczonej wewntrz
obiektu Person, zawierajcej polecenia uruchomienia stopera wbudowanego w komputer, za kadym razem gdy osoba nacinie przycisk na danym obiekcie Floor
(pitro), wzywajc wind. Gdy tylko przyjedzie obiekt Elevator, stoper zostanie
zatrzymany, a czas bdzie dodany do biecej wartoci totalWaitingTime.
I podobnie, averageFloorTravelingTime oblicza si inn metod wewntrz
Person, uruchamiajc stoper, gdy tylko obiekt Person wejdzie do obiektu Elevator. Kiedy Person dotrze do miejsca przeznaczenia, stoper jest zatrzymywany,
a czas jest dzielony przez liczb przebytych piter, aby uzyska redni czas jazdy
na pitro. Ten wynik jest przechowywany na licie razem z innymi wielkociami

152

JZYK C#. SZKOA PROGRAMOWANIA

averageFloorTravelingTime. Kiedy trzeba obliczy kocow statystyk averageFloorTravelingTime, metoda wyliczy redni z liczb przechowywanych
na licie.
Wszystkie te obliczenia wykorzystujce uruchamianie i zatrzymywanie stoperw,
sumowanie liczb, obliczanie rednich itd. nie s w aden sposb interesujce dla
innych obiektw w symulacji i nadmiernie komplikowayby sprawy innym programistom, gdyby je ujawniono. W konsekwencji powinnimy ukry wszystkie zaangaowane tutaj metody przez zadeklarowanie ich jako private.
Rwnie kady obiekt Person musi by w stanie poda swj totalWaitingTime
i averageFloorTravelingTime. Mona to zrobi za pomoc dwch metod
public, nazwanych arbitralnie getTotalWaitingTime() i getAverageFloorTravelingTime(). Kady inny obiekt wywoujcy ktr z tych metod otrzyma
odpowiedni statystyk.
Inny programista, ktry take pracuje nad tym projektem, pisze klas do zbierania
wanych statystyk kadej symulacji. Nazwa t klas StatisticsReporter. Musi
zapewni, aby na kocu symulacji przeprowadzono wywiad z wszystkimi obiektami
Person przez umoliwienie klasie StatisticsReporter zbierania ich statystyk
totalWaitingTime i averageFloorTravelingTime. Teraz StatisticsReporter moe to zrobi po prostu przez wywoanie metod getTotalWaitingTime() i getAverageFloorTravelingTime() kadego obiektu Person biorcego
udzia w danej symulacji.
Podsumowujc:
getTotalWaitingTime() i getAverageFloorTravelingTime() s czci
interfejsu, ktry ukrywa, czyli hermetyzuje wszystkie zoonoci, nieistotne dla
naszego programisty klasy StatisticsReporter.
Podobnie, zmienne instancji obiektw Person powinny by ukryte za pomoc
deklaracji private. Uniemoliwia to innym obiektom, ze StatisticsReporter wcznie, bdn zmian tych wielkoci. Innymi sowy, metody getTotalWaitingTime() i getAverageFloorTravelingTime() przykrywaj
zmienne instancji totalWaitingTime i averageFloorTravelingTime za
pomoc hermetyzacji, jak opakowanie, umoliwiajc klasie StatisticsReporter jedynie uzyskanie ich wartoci, bez moliwoci wprowadzania zmian.

Programowanie obiektowe przykad praktyczny


Dotychczas nasza rozmowa o programowaniu obiektowym jest raczej teoretyczna.
Omwilimy rnic midzy klasami a obiektami oraz to, jak trzeba tworzy instancje obiektw, zanim bd mogy rzeczywicie wykonywa jakiekolwiek czynnoci.

Rozdzia 5. TWJ PIERWSZY PROGRAM OBIEKTOWY W C#

153

Widzielimy par prostych klas w listingach 3.1 w rozdziale 3. i 4.1 w rozdziale 4.,
ale nie zawieray one adnych rzeczywistych obiektw; byy biernymi kontenerami,
utworzonymi jedynie po to, aby zawieray metod Main(). adnego z tych programw nie mona waciwie uwaa za obiektowy. Poniewa maj one tylko metody zawierajce sekwencje instrukcji wykonywanych jedna po drugiej, przypominaj
programy napisane w proceduralnym stylu programowania.
Przez zwyke dodanie wielu metod i instrukcji do klasy SimpleCalculator z listingu 4.1 moglibymy, aczkolwiek wyjtkowo nieefektywnie, napisa prawidow
i skomplikowan aplikacj arkusza obliczeniowego, nie martwic si o pisanie innych
klas, uczenie si teoretycznych zasad obiektowych lub nawet wykorzystanie jakichkolwiek dajcych si wymieni cech obiektowych C#. Struktura tego programu byaby
blisza programowi napisanemu w jzyku proceduralnym, takim jak C lub Pascal,
ni typowemu programowi obiektowemu C#.
I odwrotnie (oraz zadziwiajco), mona by byo rwnie napisa program obiektowy
w C lub Pascalu, ale byoby to niewygodne, poniewa te jzyki, w przeciwiestwie
do C#, nie maj wbudowanej obsugi tego paradygmatu.
Aby nasze dotychczasowe dyskusje obiektowe uczyni bardziej praktycznymi i unikn ryzyka skonstruowania nieobiektowego, duego programu arkusza obliczeniowego, przedstawi przykad ilustrujcy par wanych cech C#, cile zwizanych
z nasz teoretyczn dyskusj o klasach, obiektach i tworzeniu instancji.

Prezentacja SimpleElevatorSimulation.cs
Listing 5.1 zawiera kod rdowy dla prostego programu symulacyjnego windy. Jego
celem jest zilustrowanie, jak obiekt uytkownika wyglda w C# i jak jest tworzona
instancja obiektu klasy uytkownika. Szczeglnie pokazuje on, jak tworzony jest
obiekt klasy Elevator oraz jak wywouje on metod obiektu Person o nazwie
NewFloorRequest() (danie nowego pitra) i jak powoduje, e ta metoda zwraca
numer danego pitra, dziki czemu Elevator moe speni t prob.
Na etapie projektowania kodu rdowego w listingu 5.1 dokonano wielu abstrakcji,
umoliwiajcych uproszczenie programu i skoncentrowanie si na zasadniczych,
obiektowych czciach kodu rdowego.
Poniej podano krtki opis konfiguracji systemu windy, uytej dla tej symulacji,
z podkreleniem gwnych rnic w stosunku do rzeczywistego systemu wind.
Klasa Building (budynek) ma jeden obiekt klasy Elevator o nazwie elevatorA.
Jeden obiekt Person, rezydujcy w zmiennej passenger (pasaer), wykorzystuje elevatorA (wind A).
Obiekt Elevator moe jecha na dowolne pitro znajdujce si w zakresie
okrelonym przez typ int (od 2147483648 do 2147483647). Jednak obiekt Person
jest zaprogramowany na losowy wybr piter od 1 do 30.

154

JZYK C#. SZKOA PROGRAMOWANIA

Winda pojedzie natychmiast na pitro przeznaczenia.


Ruchy elevatorA bd wywietlane na konsoli.
passenger po wejciu do elevatorA pozostanie w elevatorA podczas
caej symulacji i po prostu bdzie wybiera nowe pitro, gdy jego poprzednie
danie zostanie ju spenione.
W tej symulacji zastosowano tylko klasy Elevator, Person i Building, natomiast pominito klasy Floor, StatisticsReporter i inne klasy uwaane
za wane dla penej symulacji.
Na kocu kadej symulacji na konsoli zostanie wywietlona cakowita liczba piter
przebytych przez elevatorA. Ta liczba moe by bardzo wan statystyk
w powanej symulacji windy.
Tak wic, mimo prostoty i wysokiej abstrakcji tej symulacji, moemy faktycznie wycign z niej jedn wan statystyk i bylibymy w stanie (bez zbyt wielu dodatkw)
utworzy ma, ale przydatn symulacj umoliwiajc uytkownikowi uzyskanie
cennego wgldu w rzeczywisty system windy.
Prosz powici chwil na zbadanie kodu rdowego z listingu 5.1. Sprbujmy
najpierw popatrze szerzej na kod. Prosz np. zwrci uwag na trzy definicje klas
(Elevator, Person i Building), ktre tworz cay program (oprcz wierszy od 1.
do 4.). Nastpnie zwrmy uwag na metody zdefiniowane w kadej z tych trzech
klas oraz zmienne instancji kadej z nich.

Uwaga!
Przypomnijmy sobie, e to, jak program jest wykonywany, nie zaley od kolejnoci,
w jakiej metody klasy s zapisane w kodzie rdowym. To samo dotyczy kolejnoci klas w programie. Mona wybra dowoln kolejno pasujc do naszego
stylu. W listingu 5.1 wstawiem klas zawierajc metod Main() jako ostatni,
a mimo to Main() jest pierwsz metod, jaka bdzie wykonana.

Typowy wynik listingu 5.1 jest pokazany pod listingiem. Poniewa numery danych
piter s wybierane losowo, "Odjedam z pitra" i "Jad na" oraz "Ilo
przebytych piter" bd inne przy kadym uruchomieniu programu (z wyjtkiem pierwszego opuszczanego pitra, ktrym zawsze bdzie pitro 1.).

LISTING 5.1. Kod rdowy dla SimpleElevatorSimulation.cs


01: // Prosta symulacja windy
02:
03: using System;
04:
05: class Elevator
06: {
07:
private int currentFloor = 1;

Rozdzia 5. TWJ PIERWSZY PROGRAM OBIEKTOWY W C#

08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:

155

private int requestedFloor = 0;


private int totalFloorsTraveled = 0;
private Person passenger;
public void LoadPassenger()
{
passenger = new Person();
}
public void InitiateNewFloorRequest()
{
requestedFloor = passenger.NewFloorRequest();
Console.WriteLine("Odjedam z pitra: " + currentFloor
+ " Jad na: " + requestedFloor);
totalFloorsTraveled = totalFloorsTraveled +
Math.Abs(currentFloor - requestedFloor);
currentFloor = requestedFloor;
}
public void ReportStatistic()
{
Console.WriteLine("Ilo przebytych piter: " +
totalFloorsTraveled);
}
}
class Person
{
private System.Random randomNumberGenerator;
public Person()
{
randomNumberGenerator = new System.Random();
}
public int NewFloorRequest()
{
// Zwr losowo wygenerowan liczb
return randomNumberGenerator.Next(1,30);
}
}
class Building
{
private static Elevator elevatorA;
public static void Main()
{
elevatorA = new Elevator();
elevatorA.LoadPassenger();

156

JZYK C#. SZKOA PROGRAMOWANIA

57:
58:
59:
60:
61:
62:
63:
64: }

elevatorA.InitiateNewFloorRequest();
elevatorA.InitiateNewFloorRequest();
elevatorA.InitiateNewFloorRequest();
elevatorA.InitiateNewFloorRequest();
elevatorA.InitiateNewFloorRequest();
elevatorA.ReportStatistic();
}

Odjedam z pitra: 1 Jad na: 2


Odjedam z pitra: 2 Jad na: 24
Odjedam z pitra: 24 Jad na: 15
Odjedam z pitra: 15 Jad na: 10
Odjedam z pitra: 10 Jad na: 21
Ilo przebytych piter: 48

Oglna struktura programu


Zanim bdziemy kontynuowa bardziej szczegow analiz programu, popatrzmy
na rysunek 5.1. czy on ilustracj uyt na rysunku 3.1 w rozdziale 3. z konkretnym
programem C# z listingu 5.1.
Klasy Elevator i Person z listingu 5.1 definiuj wersje naszych znajomych ju
odpowiednikw, wyowionych ze wiata rzeczywistego. S one pokazane graficznie obok swoich odpowiednikw C# na rysunku 5.1. Kada cz klas Elevator
i Person zapisana w kodzie rdowym C# (wskazywana nawiasami klamrowymi)
zostaa poczona strzak ze swoim odpowiednikiem graficznym. Prosz zwrci
uwag, jak metody public dwch klas (interfejs) hermetyzuj prywatne, ukryte
zmienne instancji. W tym przypadku nie byy potrzebne adne metody prywatne.
Klasa Building ma jedn wind (Elevator), ktra jest reprezentowana przez
zmienn instancji elevatorA, zadeklarowan w wierszu 51. Ma rwnie metod
Main(), gdzie zaczyna si aplikacja. Obiekt tej klasy nigdy nie jest tworzony w programie. Jest ona wykorzystywana przez rodowisko uruchomieniowe .NET w celu
uzyskania dostpu do Main() i uruchomienia programu.
Tak jak w poprzednich listingach, poniej przedstawiem krtkie objanienie wierszy w kodzie rdowym. Wiele wierszy pominem, poniewa byy ju omawiane
w poprzednim przykadzie.

LISTING 5.2. Krtka analiza listingu 5.1


05: Pocztek definicji klasy o nazwie Elevator
07: Deklaracja zmiennej instancji typu int o nazwie currentFloor;
ustawienie jej poziomu dostpu na private oraz jej pocztkowej
wartoci na 1.

Rozdzia 5. TWJ PIERWSZY PROGRAM OBIEKTOWY W C#

157

RYSUNEK 5.1.
Poczenie
rysunku 3.1
z rzeczywistym
programem C#

10: Deklaracja zmiennej passenger, ktra moe zawiera


obiekt klasy Person. O klasie Person mwi si, e odgrywa rol
pasaera w swoim zwizku z klas Elevator.
12: Pocztek definicji metody o nazwie LoadPassenger(). Zadeklarowanie
jej jako public to cz interfejsu klasy Elevator.

158

JZYK C#. SZKOA PROGRAMOWANIA

14: Tworzenie nowego obiektu klasy Person przy uyciu


sowa kluczowego new. Przypisanie tego obiektu do zmiennej
passenger.
17: Pocztek definicji metody o nazwie InitiateNewFloorRequest().
Zadeklarowanie jej jako public to cz interfejsu klasy Elevator.
19: Wywoanie metody NewFloorRequest() obiektu passenger; przypisanie
liczby zwracanej przez t metod do zmiennej requestedFloor.
20-21: Drukowanie informacji o "ruchu" operatora na konsoli polece.
22-23: Obliczanie liczby piter przebytych prze wind w czasie jednej,
konkretnej jazdy (wiersz 23.). Dodanie tego wyniku do cakowitej
liczby piter ju przebytych przez wind.
24: Zezwolenie na "jazd" windy na dane pitro przez przypisanie
wartoci requestedFloor do currentFloor.
29: Drukowanie zmiennej totalFloorsTraveled, za kadym razem gdy
wywoywana jest metoda ReportStatistics().
33: Pocztek definicji klasy o nazwie Person.
35: Deklaracja randomNumberGenerator jako zmiennej, ktra moe
zawiera obiekt klasy System.Random.
37: Pocztek definicji specjalnej metody, ktra bdzie wywoywana
automatycznie, za kadym razem kiedy bdzie tworzony nowy obiekt
klasy Person.
39: Tworzenie nowego obiektu klasy System.Random przy uyciu
sowa kluczowego C#: new; przypisanie tego obiektu do zmiennej
randomNumberGenerator.
42: Pocztek definicji metody o nazwie NewFloorRequest(). public
deklaruje j jako cz interfejsu klasy Person. int okrela, e
zwraca ona warto typu int.
45: Person decyduje, na ktre pitro chce jecha,
zwracajc losowo wybran liczb z zakresu od 1 do 30.
51: Klasa Building deklaruje zmienn instancji typu Elevator,
o nazwie elevatorA. O klasie Building mwi si, e ma zwizek
posiadania (lub agregacji) z klas Elevator.
53: Pocztek definicji metody Main(), gdzie zacznie si program.
55: Tworzenie obiektu klasy Elevator za pomoc sowa kluczowego new;
przypisanie tego obiektu do zmiennej elevatorA.

Rozdzia 5. TWJ PIERWSZY PROGRAM OBIEKTOWY W C#

159

56: Wywoanie metody LoadPassenger() obiektu elevatorA.


57-61: Wywoanie metody InitiateNewFloorRequest()
obiektu elevatorA, 5 razy.
62: Wywoanie metody ReportStatistic() obiektu elevatorA.

Gbsza analiza SimpleElevatorSimulation.cs


Poniej omwiono wane kwestie zwizane z listingiem 5.1.

Definiowanie klasy, ktra ma by skonkretyzowana w naszym wasnym


programie
Wiemy ju, jak definiuje si klas. Wci zwracam uwag na wiersz 5., poniewa
pierwszy raz definiujemy swoj wasn klas, ktra jest konkretyzowana, i dlatego
potem stosowana do tworzenia obiektu w naszym programie.
05: class Elevator

Inicjalizacja zmiennych
Nowa cecha przedstawiona w wierszu 7. jest kombinacj instrukcji deklaracji i instrukcji przypisania. Nazywamy to inicjalizacj. private int currentFloor;
jest prost deklaracj, a przez dodanie na kocu = 1, skutecznie przypisujemy 1 do
currentFloor podczas tworzenia lub zaraz po utworzenie obiektu, do ktrego
naley zmienna instancji.
07:

private int currentFloor = 1;

Zmienna czsto wymaga wartoci pocztkowej, zanim bdzie mona j wykorzysta


w obliczeniach, w ktrych bierze udzia. currentFloor w wierszu 7. jest dobrym
przykadem. Chcemy, aby winda ruszya z pitra numer 1, wic inicjalizujemy j t
wartoci.
Kiedy zmiennej przypisuje si warto przed jej udziaem w obliczeniach, to mwi
si, e zmienna jest inicjalizowana. Istniej dwie wane metody inicjalizacji zmiennej
instancji. Mona:
przypisa zmiennej warto pocztkow w jej deklaracji (jak w wierszu 7.) lub
wykorzysta cech C#, zwan konstruktorem. Kod rdowy zawarty w konstruktorze bdzie wykonywany wtedy, gdy jest tworzony obiekt klasy, bo to idealny moment dla wszelkich inicjalizacji. Z konstruktorami zapoznamy si
wkrtce.
Zmiennym instancji, ktre nie s wyranie inicjalizowane w kodzie rdowym, kompilator C# automatycznie przypisze warto domyln. Gdybymy np. nie przypisali
wartoci 1 do currentFloor w wierszu 7., C# nadaby domyln warto 0.

160

JZYK C#. SZKOA PROGRAMOWANIA

Warto wyranie inicjalizowa swoje zmienne


Nie naley zostawia kompilatorowi C# inicjalizacji swoich zmiennych. Wyrane
inicjalizacje sprawiaj, e kod jest bardziej klarowny, a poza tym lepiej nie polega na inicjalizacjach kompilatora i ich wartociach domylnych, ktre mog si
zmieni w przyszoci i wprowadzi bdy do kodu rdowego.

Wskazwka
Mona zadeklarowa skadow klasy bez wyranego podawania jej dostpnoci
dziki opuszczeniu sowa kluczowego public lub private. Wtedy dostpno
jest domylnie ustawiana na private.
Tym niemniej, lepiej uywa sowa kluczowego private w celu zadeklarowania
wszystkich prywatnych skadowych klasy, aby poprawi jej przejrzysto.

Deklarowanie zmiennej reprezentujcej obiekt danej klasy


W wierszu 10. stwierdzamy, e zmienna instancji passenger moe zawiera obiekt
utworzony z klasy Person.
10:

private Person passenger;

Jeszcze nie wstawilimy tutaj szczeglnego obiektu Person; aby to zrobi, potrzebowalibymy instrukcji przypisania, ktr zobaczymy troch pniej w tym rozdziale.
Dotd jedynie stwierdzamy, e obiekt Elevator moe transportowa jeden obiekt
passenger, ktry musi by klasy Person. Przykadowo w Elevator nie mog
by przechowywane obiekty Dog, Airplane czy Submarine, gdybymy kiedy
zdefiniowali takie klasy w naszym programie.
Teraz przeskoczmy na chwil do wierszy od 33. do 47. Przez zdefiniowanie w tych
wierszach klasy Person skutecznie utworzylimy nowy typ uytkownika. A wic,
oprcz moliwoci deklarowania, e zmienna bdzie typu int lub typu string,
moemy rwnie zadeklarowa, e bdzie ona typu Person, co wanie robimy
w wierszu 10.

Uwaga!
int i string s to wbudowane, wstpnie zdefiniowane typy. Klasy, ktre piszemy
i definiujemy w swoim kodzie rdowym, s typami uytkownika (ang. custommade types).

Prosz zwrci uwag, e wiersz 10. jest cile zwizany z wierszami 14., 19. i wierszami od 33. do 47. Wiersz 14. przypisuje nowy obiekt klasy Person do zmiennej
passenger; wiersz 19. wykorzystuje pewn funkcj zmiennej passenger, a wic

Rozdzia 5. TWJ PIERWSZY PROGRAM OBIEKTOWY W C#

161

obiektu Person przez wywoanie jednej z jego metod, a wiersze od 33. do 47 definiuj
klas Person.

Wskazwka
Kolejno deklaracji i definicji skadowych klasy jest dowolna. Jednak warto podzieli
skadowe klasy na sekcje zawierajce skadowe o podobnych modyfikatorach dostpu w celu poprawienia przejrzystoci.
Poniej przedstawiono przykad powszechnie stosowanego stylu:
class NazwaKlasy
{
// deklaracje prywatnych zmiennych instancji
// definicje metod prywatnych
// definicje metod publicznych
}

Zmienne instancji reprezentujce stan obiektu Elevator


Wiersze od 7. do 10. zawieraj list zmiennych instancji, ktre w tej symulacji uwaaem za istotne dla opisu obiektu Elevator.
07:
08:
09:
10:

private
private
private
private

int currentFloor = 1;
int requestedFloor = 0;
int totalFloorsTraveled = 0;
Person passenger;

Stan obiektu Elevator jest opisany przez zmienne instancji zadeklarowane w nastpujcych wierszach:
Wiersz 7. zmienna currentFloor ledzi pitro, na ktrym znajduje si obiekt
Elevator.
Wiersz 8. nowe danie pitra bdzie przechowywane w zmiennej requestedFloor; obiekt Elevator bdzie usiowa jak najszybciej speni to danie
(wiersz 24.), co zaley od szybkoci procesora naszego komputera.
Wiersz 9. kiedy tworzony jest obiekt Elevator, mona uwaa go za fabrycznie
nowy. On jeszcze nigdy nie jedzi do gry ani na d, wic totalFloorsTraveled musi na pocztku zawiera warto 0. Uzyskuje si to przez inicjalizacj
wartoci 0.
Liczba przebytych piter jest dodawana do totalFloorsTraveled (wiersze
od 22. do 23.) tu przed zakoczeniem jazdy (wiersz 24.).
Wiersz 10 pasaer (pasaerowie) windy podejmuje ostatecznie decyzj o numerach piter odwiedzanych przez wind. Obiekt Person rezydujcy w passenger
wybiera pitra, ktre musi odwiedzi nasz obiekt Elevator. danie jest uzyskiwane od passenger w wierszu 19. i przypisywane zmiennej requestedFloor.

162

JZYK C#. SZKOA PROGRAMOWANIA

Abstrakcja i wybr zmiennych instancji


Przypomnijmy sobie dyskusj o abstrakcji na pocztku rozdziau 3. Celem zwizanym z abstrakcj jest identyfikacja zasadniczych cech klasy obiektw, ktre s
istotne dla naszego programu komputerowego.
Podczas procesu podejmowania decyzji, ktre zmienne instancji wczy do definicji
klasy oraz deklarowania ich w kodzie rdowym, programista stosuje pojcie
abstrakcji w bardzo praktyczny sposb.
Mgbym np. sprbowa wczy do klasy Elevator zmienn instancji typu
string, tak jak kolor, deklarujc, co nastpuje:
Ale jaki uytek mog z tego zrobi? Mgbym, by moe, przypisa do niej string
czerwony i napisa metod, ktra po kadym wywoaniu drukowaaby na konsoli
polece:
Mj kolor to: czerwony

Ale byoby to cakowicie nieistotne dla celu, ktry prbujemy uzyska w naszej
maej, prostej symulacji, wic jest to nieekonomiczne i niepotrzebnie komplikuje
klas Elevator.
Inny programista mgby doczy zmienn instancji klasy Elevator, ktra
zlicza liczb jazd wykonywanych przez wind; mgby nazwa j totalTrips
i zadeklarowa nastpujco:
Klas Elevator mona by potem tak zaprojektowa, eby metoda dodawaa 1
do totalTrips, za kadym razem gdy danie zostao spenione. Ta zmienna
instancji umoliwiaaby ledzenie innej, by moe wanej statystyki, a wic potencjalnie moe by przydatna.
Jak wida, przy podejmowaniu decyzji, ktre zmienne instancji naley doczy,
mona stosowa wiele rnych sposobw przedstawiania obiektw wiata rzeczywistego. Wybr zmiennych instancji zaley od programisty oraz od tego, co
chce on zrobi z kadym obiektem.

Umoliwienie obiektowi klasy Elevator przyjcia nowego pasaera


Obiekt klasy Elevator musi by w stanie przyj nowy obiekt klasy Person. Uzyskuje si to za pomoc metody LoadPassenger() rezydujcej wewntrz obiektu
Elevator (patrz wiersz 12.). Metoda LoadPassenger() musi by zadeklarowana
jako public, aby by do niej dostp spoza obiektu. Wywoanie LoadPassenger()
odbywa si w wierszu 56. listingu 5.1.
12:

public void LoadPassenger()

Rozdzia 5. TWJ PIERWSZY PROGRAM OBIEKTOWY W C#

163

Opisywanie klas i obiektw


Rozwamy nastpujc instrukcj deklaracji:
private Person passenger;

Mona zastosowa wiele rnych, mniej lub bardziej prawidowych sposobw


opisania, o czym mwi to zdanie, a zwaszcza tego, jak identyfikuje obiekt. Wedug
mnie, dobry, chocia moe troch nieporczny, jest nastpujcy opis:
passenger jest zmienn zadeklarowan tak, aby zawieraa obiekt klasy Person.
Poniewa ten opis jest troch przydugi, czsto stosuj nastpujce wyraenie:
passenger jest zmienn zadeklarowan tak, aby zawieraa obiekt Person.
W rozdziale 6., Typy, cz I typy proste, dowiemy si, dlaczego najbardziej
prawidowym, ale rwnie najduszym jest nastpujcy opis:
passenger jest zmienn zadeklarowan tak, aby zawieraa referencj do obiektu
klasy Person.

Tworzenie nowego obiektu za pomoc sowa kluczowego new


Rka w rk z wierszem 10. idzie wiersz 14.
14:

passenger = new Person();

Wystpujce w tym wierszu sowo new (nowy) jest sowem kluczowym w C#, stosowanym w celu tworzenia nowego obiektu. Wytworzy ono now instancj (obiekt)
klasy Person. Ten nowy obiekt klasy Person jest nastpnie przypisany do zmiennej passenger. Teraz passenger zawiera obiekt Person, ktry mona wywoa
i zastosowa do wykonania czynnoci.

Uwaga!
Kiedy tworzy si instancj obiektu, czsto potrzebna jest inicjalizacja zmiennych
instancji tego obiektu. Konstruktor jest to metoda specjalnego rodzaju, ktra wykonuje zadanie inicjalizacji.
Metoda okrelana jako konstruktor musi mie tak sam nazw jak jej klasa. Tak
wic konstruktor dla klasy Person nazywa si Person() (patrz wiersz 37.).
Ilekro za pomoc sowa kluczowego new tworzony jest nowy obiekt Person,
automatycznie wywoywany jest konstruktor Person() w celu wykonania niezbdnych inicjalizacji. To wyjania obecno w wierszu 14. nawiasw, ktre s
wymagane zawsze, kiedy wywouje si dowoln metod i dowolny konstruktor.
(Zobacz rysunek na nastpnej stronie).

164

JZYK C#. SZKOA PROGRAMOWANIA

Umoliwienie odbierania i speniania da pasaerw przez obiekt Elevator


Przez wywoanie metody InitiateNewFloorRequest obiekt Elevator jest
instruowany, aby:
odebra nowe danie od passenger (wiersz 19.),
wydrukowa pitro, z ktrego odjeda i pitro przeznaczenia (wiersze 20. i 21.),
zaktualizowa statystyk totalFloorsTraveled (wiersze 22. i 23.),
speni danie obiektu klasy Person w zmiennej passenger (wiersz 24.).
17:
18:
19:
20:
21:
22:
23:
24:
25:

public void InitiateNewFloorRequest()


{
requestedFloor = passenger.NewFloorRequest();
Console.WriteLine("Odjedam z pitra: " + currentFloor
+ " Jad na: " + requestedFloor);
totalFloorsTraveled = totalFloorsTraveled +
Math.Abs(currentFloor - requestedFloor);
currentFloor = requestedFloor;
}

Zacznijmy od wiersza 19.:

Rozdzia 5. TWJ PIERWSZY PROGRAM OBIEKTOWY W C#

165

Tutaj stosujemy nastpujc, wprowadzon wczeniej skadni:

gdzie uyty jest operator kropki (.) w celu odwoania si do metody rezydujcej
wewntrz obiektu. Z operatora tego korzystalimy ju wiele razy, np. wystpowa
przy wywoywaniu metody WriteLine() z System.Console za pomoc System.Console.WriteLine("Pa, pa!"). Tym razem jednak, zamiast wywoywa
ju napisan metod z .NET Framework, wywoujemy wasn metod uytkownika
z klasy Person.

Uwaga!
W kodzie rdowym mona zauway sta definicj klasy. Natomiast obiekt
jest dynamiczny i oywia si podczas wykonywania programu.

Zamiast wywoywania metody rezydujcej w tym samym obiekcie, wywoujemy


metod rezydujc w innym obiekcie. Tutaj o obiekcie Elevator mwi si, e wysya
komunikat do obiektu Person. Wywoanie metody rezydujcej w innym obiekcie
jest podobne do wywoywania metody lokalnej. Na rysunku 5.2 poczyem rysunek 3.1 z mechanizmem oglnym, pokazanym na rysunku 4.1. Grna poowa rysunku
ilustruje wywoanie NewFloorRequest() przy zastosowaniu takiego samego stylu
graficznego, co na rysunku 4.1. Krok 1. symbolizuje wywoanie NewFloorRequest().
Poniewa dla NewFloorRequest() nie okrelono parametrw formalnych, wic
do metody nie s przekazywane adne argumenty. Ten krok jest rwnowany z krokiem 1. z dolnej poowy rysunku. Po zakoczeniu NewFloorRequest() metoda
zwraca warto typu int, co symbolizuje strzaka 2. Graficzny rwnowanik kroku 2.
jest pokazany w dolnej poowie tego rysunku. Jak widzielimy poprzednio (wiersz
18. listingu 4.1 w rozdziale 4.), po zakoczeniu kroku 2. mona zastpi passenger.NewFloorRequest() wartoci typu int. Na koniec t warto mona przypisa do zmiennej requestedFloor za pomoc operatora przypisania =.

166

JZYK C#. SZKOA PROGRAMOWANIA

RYSUNEK 5.2.
Wywoywanie
metody innego
obiektu

Po odebraniu przez wind nowego dania od obiektu klasy Person w zmiennej


passenger w wierszu 19. obecne pooenie obiektu Elevator znajduje si w zmiennej currentFloor, a inne pitro, do ktrego musi on dotrze, znajduje si w requestedFloor. Jeeli Elevator jest fabrycznie nowy i wanie zosta utworzony,
currentFloor bdzie mie warto 1. Jeeli Elevator odby ju jedn lub kilka
jazd, currentFloor bdzie rwny miejscu przeznaczenia ostatniej jazdy.
Wiersz 20. wydrukuje warto currentFloor przy uyciu znanej metody WriteLine(). W wierszu 21. jest nastpnie drukowane danie passenger.
Prosz zwrci uwag, e wiersze 22. i 23. przedstawiaj tylko jedn instrukcj.
Dowodzi tego jeden rednik znajdujcy si na kocu wiersza 23. Instrukcja zostaa
rozoona na dwa wiersze z powodu braku miejsca. Wiersz 23. zosta wcity w sposb
wskazujcy na powizanie z wierszem 22.; to wskazuje czytelnikowi, e zajmujemy
si tylko jedn instrukcj.

Rozdzia 5. TWJ PIERWSZY PROGRAM OBIEKTOWY W C#

167

Warto bezwzgldna
Wartoci bezwzgldn liczby dodatniej jest sama liczba.
Wartoci bezwzgldn liczby ujemnej jest liczba bez znaku minus.
Przykady:
Wartoci bezwzgldn (12) jest 12.
Wartoci bezwzgldn 12 jest 12.
W matematyce warto bezwzgldna jest podawana za pomoc dwch pionowych kresek otaczajcych litera lub zmienn, np.:
|-12| = 12

Zastosowanie Math.Abs()
Metoda Abs() klasy Math rezydujcej w .NET Framework zwraca warto
bezwzgldn wysanego do niej argumentu. W rezultacie wywoanie metody
Math.Abs(99) zwraca 99, podczas gdy Math.Abs(-34) zwraca 34.
Obliczajc odlego przebyt przez wind, jestemy zainteresowani dodatni liczb
przebytych piter, bez wzgldu na to, czy winda jedzie do gry, czy na d. Jeeli
liczb przebytych piter obliczymy za pomoc nastpujcego wyraenia:
currentFloor requestedFloor

to zawsze wtedy, gdy requestedFloor bdzie wiksze od currentFloor,


otrzymamy w wyniku ujemn liczb przebytych piter. Ta ujemna liczba jest nastpnie dodawana do totalFloorsTraveled; wic w tym przypadku liczba
przebytych piter nie bdzie dodana, lecz odjta od totalFloorsTraveled.
Tego problemu mona unikn przez dodawanie wartoci bezwzgldnej z (currentFloor requestedFloor), jak to zostao zrobione w wierszu 23.:
Math.Abs(currentFloor - requestedFloor);

Instrukcj t mona rozbi na nastpujce podinstrukcje:


1. Math.Abs(currentFloor - requestedFloor) obliczy liczb piter prze-

bytych przy nastpnej jedzie windy,


2. totalFloorsTraveled + Math.Abs(currentFloor - requestedFloor)

doda liczb piter przebytych przy nastpnej jedzie do biecej wartoci


totalFloorsTraveled,
3. Przypisa wynik z pkt. 2. do totalFloorsTraveled.

Wystpowanie totalFloorsTraveled po obu stronach operatora przypisania


moe na pocztku wydawa si troch dziwne. Jednak jest to bardzo przydatna
operacja dodawania liczby piter przebytych przy ostatniej jedzie windy do pocztkowej wartoci totalFloorsTraveled. Tu totalFloorsTraveled jest

168

JZYK C#. SZKOA PROGRAMOWANIA

licznikiem odlegoci windy, cay czas ledzcym cakowit ilo przebytych piter.
Ten typ instrukcji bdzie omwiony bardziej szczegowo w rozdziale 6.
Niespodziewanie prosta instrukcja przypisania w wierszu 24. reprezentuje jazd
windy. Spenia danie przekazane od passenger. Przez przypisanie wartoci
zmiennej requestedFloor do currentFloor moemy powiedzie, e winda
przesuna si z wartoci currentFloor, ktr zawieraa przed tym przypisaniem, do requestedFloor.

Klasa Person szablon dla pasaera windy


Wiersz 33. zaczyna definicj drugiej klasy uytkownika, ktra bdzie stosowana jako
szablon w celu utworzenia obiektu.
33: class Person

Jak wida, obiekt Person jest tworzony i przechowywany w obiekcie Elevator,


z ktrego jest wywoywana metoda NewFloorRequest(), przekazujca obiektowi
Elevator informacj, gdzie chce jecha jej pasaer (zmienna passenger przechowujca obiekt klasy Person).
W wierszu 35. obiektowi klasy Person umoliwiono danie pitra przez wyposaenie go w obiekt zawierajcy metod, ktra generuje losowe liczby. Obiekt jest przechowywany w zmiennej randomNumberGenerator. Klasa, z ktrej tworzony jest
obiekt, znajduje si w bibliotece klas .NET i nazywa si System.Random. W wierszu 35. deklarujemy, e randomNumberGenerator ma zawiera obiekt typu System.Random.
35:

private System.Random randomNumberGenerator;

Poniewa randomNumberGenerator jest zmienn instancji klasy Person, jest


zadeklarowana jako private. Prosz zwrci uwag, e po tej deklaracji randomNumberGenerator jest nadal pusta. aden obiekt nie zosta jeszcze przypisany
do tej zmiennej. Musimy przypisa obiekt do randomNumberGenerator, zanim
ta zmienna bdzie moga generowa liczby losowe. Wiersze od 37. do 40. speniaj
to wane zadanie, dziki temu, e zawieraj konstruktor dla klasy Person.
Pojcie konstruktora zostao ju omwione i nie bd dalej dry tego tematu. W tej
chwili nie jest wane, aby w peni zrozumie mechanizm konstruktora pod warunkiem,
e zdajemy sobie spraw, i zasadnicz czci jest wiersz 39., gdzie nowy obiekt klasy
System.Random jest przypisany do randomNumberGenerator kadego nowo
utworzonego obiektu klasy Person.
37:
38:
39:
40:

public Person()
{
randomNumberGenerator = new System.Random();
}

Rozdzia 5. TWJ PIERWSZY PROGRAM OBIEKTOWY W C#

169

NewFloorRequest() zdefiniowana w wierszach od 42. do 46. bdzie po wywoaniu generowaa i zwracaa liczb losow, ktra wskazuje nowe pitro dane przez
passenger. Wiersz 45. znajduje liczb losow z zakresu od 1 do 30 (podanego
w nawiasie .Next(1,30)). Sowo kluczowe return wysya t liczb losow z powrotem do wywoujcego, ktrym w tym przypadku jest metoda InitiateNewFloorRequest() obiektu Elevator. Nie bdziemy tutaj omawia bliszych szczegw
klasy System.Random. Zainteresowanych bliszym zbadaniem tej klasy odsyam
do dokumentacji .NET Framework.
42:
43:
44:
45:
46:

public int NewFloorRequest()


{
// Zwr losowo wygenerowan liczb
return randomNumberGenerator.Next(1,30);
}

Uwaga!
Programista, ktry implementuje klas Elevator, wykorzystuje metod NewFloorRequest() obiektu Person. Jednak nie musi zna definicji metody, aby j
zastosowa. Najprawdopodobniej nie bdzie go interesowa, w jaki sposb obiekt
Person decyduje o zwracanych wartociach i z powodzeniem moe nie zdawa
sobie sprawy z generatorw liczb losowych i tym podobnych. Nagwek metody
i krtki opis intencji metody w zupenoci mu wystarczy. Na informacje, w jaki
sposb jest realizowana intencja, nie ma tutaj miejsca.
Nagwek metody tworzy umow z jej uytkownikiem. Nadaje metodzie nazw
i decyduje o tym, ile argumentw naley wysa za pomoc wywoania metody.
Nastpnie metoda obiecuje, e albo nie zwrci adnej wartoci (jeeli jest okrelona jako void), albo zwrci jedn warto okrelonego typu.
Take pod warunkiem, e nie majstrujemy przy nagwku metody (nie zmieniamy nazwy metody, liczby ani typu jej parametrw formalnych lub typu zwracania), moemy tworzy wszystkie rodzaje zawiych procesw pozwalajcych
obiektowi Person decydowa o nastpnym pitrze przeznaczenia.

Metoda Main() prowadzenie symulacji


W wierszach od 53. do 63. znajduje si nasza stara znajoma, nieunikniona metoda
Main().
53:
54:
55:
56:
57:
58:
59:
60:

public static void Main()


{
elevatorA = new Elevator();
elevatorA.LoadPassenger();
elevatorA.InitiateNewFloorRequest();
elevatorA.InitiateNewFloorRequest();
elevatorA.InitiateNewFloorRequest();
elevatorA.InitiateNewFloorRequest();

170

JZYK C#. SZKOA PROGRAMOWANIA

61:
62:
63:

elevatorA.InitiateNewFloorRequest();
elevatorA.ReportStatistic();
}

Nawet wtedy, gdy Main() znajduje si, jak w tym przypadku, na kocu programu,
to zawsze zawiera instrukcje, ktre maj by wykonane jako pierwsze po uruchomieniu programu. Na Main() mona spojrze jak na punkt kontrolny caego programu.
Aby kierowa oglnym przebiegiem wykonania, wykorzystuje ona oglne funkcje
innych klas w programie.
W skrcie, metoda Main() tworzy pocztkowo obiekt Elevator i przypisuje go do
elevatorA (wiersz 55.); kae mu wpuci pasaera (wiersz 56.); prosi elevatorA,
aby zada nastpnego pitra i wykona to pi razy (wiersze od 57. do 61.); a na
koniec prosi obiekt Elevator, aby poda statystyk, ktr zebra w czasie tych piciu
jazd (wiersz 62.).
Prosz zwrci uwag, e metoda Main() stosunkowo atwo prowadzi t symulacj.
Wszystkie trudne, szczegowe prace s wykonywane w klasach Elevator i Person.

Zwizki klas i UML


Trzy klasy zdefiniowane przez uytkownika wraz z klas System.Random w listingu
5.1 wsppracuj ze sob, aby zapewni funkcjonalno naszego prostego programu symulacji windy. Klasa Building zawiera obiekt Elevator i wywouje jego
metody, obiekt Elevator zatrudnia obiekt Person do kierowania swoimi ruchami,
a obiekt Person wykorzystuje obiekt System.Random w celu decydowania o nastpnym pitrze. W dobrze skonstruowanych programach obiektowych klasy wsppracuj w podobny sposb kada za pomoc swoich wasnych unikatowych funkcji
przyczynia si do dziaania caego programu.
Jeeli dwie klasy maj wsppracowa, musi istnie zwizek (wspdziaanie) midzy
nimi. Midzy dwiema klasami moe istnie kilka zalenoci, a decyzja, jakie konkretne
zwizki powinny by zaimplementowane w danym programie, naley do projektanta programu. Ta faza projektowania zwykle ma miejsce podczas identyfikowania
klas programu (etap 2b procesu projektowania opisanego w rozdziale 2., Twj pierwszy program C#). W dalszej czci rozdziau omwiono kilka powszechnie stosowanych zwizkw.
Building-Elevator i Elevator-Person to dwa rodzaje zwizkw, ktre wykorzystamy jako przykady.

Zwizek Building-Elevator
Typowy budynek skada si z wielu rnych czci, takich jak pitra, ciany, sufity,
dach i czasami windy. W naszym przypadku mona powiedzie, e Building, ktry
symulujemy, posiada Elevator jako jedn ze swoich czci. Czasami nazywa si

Rozdzia 5. TWJ PIERWSZY PROGRAM OBIEKTOWY W C#

171

to zalenoci cao / cz. Zaimplementowalimy ten zwizek w listingu 5.1 przez


zadeklarowanie zmiennej instancji typu Elevator wewntrz klasy Building
(wiersz 51.):
51:

private static Elevator elevatorA;

Dziki temu Building moe zawiera obiekt Elevator i wywoywa jego metody
public. Klasa moe mie wiele rnych zmiennych instancji zawierajcych wiele
obiektw rnych klas. Moglibymy np. rwnie wyposay Building w zmienne
instancji reprezentujce liczb obiektw Floor. Ta idea konstruowania klasy (Building) za pomoc innych klas (Elevator lub Floor albo obu i wielu innych)
nazywa si oglnie agregacj, a towarzyszce jej zalenoci to zwizki agregacyjne.
Jeeli zwizek agregacyjny (jak w przypadku zwizku Building-Elevator) odzwierciedla sytuacj, gdzie jedna klasa jest integraln czci innej, moemy nazwa t
agregacj kompozycj. (Zaraz zobaczymy, dlaczego zwizek Elevator-Person jest
agregacj, ale nie jest kompozycj.) Zwizek kompozycyjny mona zilustrowa za
pomoc schematu klasy zunifikowanego jzyka modelowania (Unified Modeling
Language UML), pokazanego na rysunku 5.3. Dwie prostoktne ramki symbolizuj
klasy, a czca je linia z czarnym rombem (wskazujcym na ca klas) ilustruje zwizek kompozycyjny midzy klasami. Obie klasy s oznaczone liczb 1, aby wskaza,
e jeden Building (budynek) ma jedn Elevator (wind).

RYSUNEK 5.3.
Diagram UML
symbolizujcy
kompozycj

Zunifikowany jzyk modelowania (UML)


Lingua Franca modelowania obiektowego
Pseudokod jest przydatn pomoc w wyraaniu algorytmw, ktre s implementowane w pojedynczych metodach, poniewa czyta si je od gry do dou,
tak jak rodowisko uruchomieniowe wykonuje program i dlatego, e abstrahuje
on od sztywnego rygoru jzyka komputerowego (redniki, nawiasy itd.). Jednak
klasy mog skada si z wielu metod, a wiksze programy skadaj si z wielu
klas. Pseudokod nie jest odpowiednim narzdziem do ilustrowania modeli powiza klas programu, poniewa klasy zrywaj z sekwencyjnym, proceduralnym
sposobem mylenia (kada klasa moe potencjalnie mie zwizek z inn klas
zdefiniowan w programie) i dlatego, e format pseudokodu jest zbyt szczegowy,
aby zapewni przegld duego programu obiektowego.

172

JZYK C#. SZKOA PROGRAMOWANIA

Aby skutecznie zaprezentowa zwizki klas i ca architektur programu obiektowego, potrzebujemy jzyka, ktry umoliwia abstrahowanie od wewntrznych
szczegw metod, a zamiast tego zapewnia rodki do wyraania zwizkw klas
i poj obiektowych na odpowiednim poziomie szczegowoci. W tym celu wikszo programistw obiektowych, bez wzgldu na swj jzyk programowania, stosuje
obecnie jzyk przedstawiania graficznego o nazwie zunifikowany jzyk modelowania
(Unified Modeling Language UML). UML to jzyk o wielu cechach i potrzebna
jest caa ksika, aby go wystarczajco zaprezentowa; tu przedstawiono tylko
may podzestaw UML.
Szczegowe informacje o UML mona uzyska w niedochodowej organizacji Object
Management Group (OMG) (www.omg.org) na stronie www.omg.org/uml. Napisano
wiele dobrych ksiek o UML, m.in. The Unified Modeling Language User Guide,
ktr napisali twrcy UML, Grady Booch, James Rumbaugh i Ivar Jacobson.

Zwizek Elevator-Person
Przycisk jest integraln czci windy, ale pasaer ju nie. (Winda jest czynna bez
pasaera, ale nie bez przyciskw). Wic gdybymy nawet w naszej implementacji
(z powodw abstrakcyjnych) uczynili pasaera permanentn czci Elevator
(obiekt Person pozostaje wewntrz Elevator przez ca symulacj), nie jest to
zwizek kompozycyjny, a jedynie agregacja. Zwizek ten ilustruje UML na rysunku 5.4. Prosz zwrci uwag, e biay romb, w przeciwiestwie do czarnego rombu
na rysunku 5.3, symbolizuje agregacj.

RYSUNEK 5.4.
Diagram UML
symbolizujcy
agregacj

Cay schemat klasy UML dla programu z listingu 5.1 zosta pokazany na rysunku 5.5.
UML umoliwia, tak jak to pokazano, podzielenie prostokta reprezentujcego klas
na trzy przedziay grny przedzia zawiera nazw klasy, w rodkowym mieszcz
si zmienne instancji (lub atrybuty), a w dolnym metody (zachowanie) nalece
do klasy.

Asocjacje
Stae zwizki midzy klasami, takie jak zwizki agregacyjne i kompozycyjne, omwione w poprzednich rozdziaach, s oglnie nazywane zwizkami strukturalnymi lub,
bardziej oficjalnie, asocjacjami. Istniej jednak inne typy asocjacji, ktre nie s agregacjami (a wic nie s rwnie kompozycjami). Aby da przykad takiej asocjacji,
rozwamy nastpujcy scenariusz. Chcemy uczyni nasz symulacj windy bardziej
realistyczn, zatem zmieniamy pokazan wczeniej pocztkow list abstrakcji,

Rozdzia 5. TWJ PIERWSZY PROGRAM OBIEKTOWY W C#

173

RYSUNEK 5.5.
Diagram UML klas
z listingu 5.1

umoliwiajc wielu obiektom Person wchodzenie, podrowanie i wychodzenie


z obiektu Elevator, zamiast tylko jednego obiektu Person pozostajcego na stae
w windzie. Teraz ju o adnym obiekcie Person nie mona powiedzie, e jest sta
czci obiektu Elevator. Moemy po prostu powiedzie, e klasa Elevator jest
skojarzona z klas Person. Asocjacja jest pokazana za pomoc zwykej linii, tak jak
na rysunku 5.6.

RYSUNEK 5.6.
Asocjacja klas
Elevator/Person

Inne przykady asocjacji, ktre nie s agregacjami:


Pracownik pracuje w Firmie,
KlientBanku wsppracuje z KasjeremBanku.

174

JZYK C#. SZKOA PROGRAMOWANIA

Uwaga!
Asocjacje, ktre precyzyjnie cz dwie klasy, nazywaj si asocjacjami binarnymi; jest to najpopularniejszy rodzaj asocjacji.

Podsumowanie
Ten rozdzia skada si z dwch gwnych czci. Pierwsza dotyczy leksykalnej
struktury programu rdowego C#. W drugiej czci zamieszczono przykad programu obiektowego, ktry jest bezporednio zwizany z dyskusj z rozdziau 3.
o abstrakcji i hermetyzacji.
Poniej przedstawiono najwaniejsze zagadnienia omwione w tym rozdziale.
Na program rdowy C# mona popatrze jak na zbir identyfikatorw, sw kluczowych, odstpw, komentarzy, literaw, operatorw i separatorw.
C# jest jzykiem rozrniajcym mae i wielkie litery. Aby kod by klarowniejszy
dla innych czytelnikw, wane jest, aby zachowa pewien styl stosowania maych
i wielkich liter. Preferowanymi stylami, ktre s uywane w rnych konstrukcjach
C#, s style Pascal (ToJestStylPascal) i Camel (toJestStylCamel).
Litera ma warto, ktra jest zapisana w kodzie rdowym (co widzisz, to otrzymasz).
Przykadem literau moe by warto 10 lub warto To jest pies.
Separatory, takie jak redniki (;), przecinki (,) i kropki (.),w C# oddzielaj od siebie rne elementy.
Operatory dziaaj na argumenty. Argumenty cz si z operatorami, tworzc wyraenia.
Zmienne instancji musz by inicjalizowane przy tworzeniu obiektu. Odbywa si
to albo automatycznie, przez rodowisko uruchomieniowe, albo przez inicjalizacj
podczas deklaracji, albo za pomoc konstruktora klasy.
Obiekt moe zawiera referencj do innego obiektu w zmiennej instancji. Taki stay
zwizek nazywa si asocjacj.
Obiekt tworzy si przy uyciu sowa kluczowego new.
W programie obiektowym klasy wsppracuj w celu zapewnienia funkcjonalnoci
programu.
Dwie klasy mog wsppracowa poprzez pozostawanie w zwizku.
Czstymi zwizkami asocjacyjnymi s agregacje i kompozycje.

Rozdzia 5. TWJ PIERWSZY PROGRAM OBIEKTOWY W C#

175

Zunifikowany jzyk modelowania (ang. Unified Modeling Language UML) jest dotd
najpopularniejszym jzykiem modelowania graficznego, stosowanym do wyraania
i ilustrowania projektw programw obiektowych.

Pytania kontrolne
1. Co to jest analiza leksykalna?
2. Jakie s niepodzielne czci programu C#?
3. Co to s style Pascal i Camel? Dla jakich czci programu C# naley je stosowa?
4. Jaka jest gwna rnica midzy zmiennymi a literaami?
5. Co to s operatory i argumenty? Jaki jest midzy nimi zwizek?
6. Czy 50 jest wyraeniem? A (50 + x)? Czy jest typu public?
7. Podaj przykady typowych sw kluczowych w C#.
8. Dlaczego pseudokod nie nadaje si do wyraania oglnej konstrukcji programu

obiektowego?
9. Jakiego rodzaju zwizek istnieje midzy obiektem KlientBanku a obiektem

KasjerBanku? Jak to si wyraa w UML?


10. Jakiego rodzaju zwizek istnieje midzy obiektem Serce a obiektem Ludzkie-

Ciao? Jak to si wyraa w UML?


11. Jakiego rodzaju zwizek istnieje midzy obiektem Zarowka a obiektem Lampa?

Jak to si wyraa w UML?


12. Jak implementuje si zwizek asocjacyjny w C#?
13. Jak mona inicjalizowa zmienne instancji przy tworzeniu obiektu?
14. Opisz zmienn passenger, ktra jest zadeklarowana w nastpujcym wierszu:
private Person passenger;

wiczenia z programowania
Spraw poprzez zmian kodu rdowego, aby program z listingu 5.1 realizowa nastpujce funkcje.
1. Wydrukuj Zacza si symulacja na konsoli polece zaraz po uruchomieniu

programu.
2. Wydrukuj Symulacja skoczya si jako ostatni rzecz, tu przed zako-

czeniem programu.
3. Zamiast wybiera pitra z zakresu od 1 do 30, niech klasa Person wybiera pitra

od 0 do 50.

176

JZYK C#. SZKOA PROGRAMOWANIA

4. Przy pierwszej jedzie winda rusza z pitra numer 0 zamiast z pitra numer 1.
5. Obiekt Elevator wykonuje 10 jazd zamiast obecnych 5.
6. Obecnie Elevator zlicza wszystkie przebyte pitra za pomoc zmiennej to-

talFloorsTraveled. Zadeklaruj zmienn instancji w klasie Elevator, ktra


bdzie ledzi, ile jazd wykonuje ta winda. T zmienn naley nazwa totalTripsTraveled. Elevator powinien aktualizowa t zmienn, dodajc jeden
do totalTripsTraveled po kadej jedzie. Uaktualnij metod ReportStatistics klasy Elevator, aby drukowaa nie tylko totalFloorsTraveled,
ale take totalTripsTraveled, z wyjanieniem, po co jest to drukowane.
7. Dodaj zmienn instancji do klasy Elevator, aby moga zawiera nazw windy.

Mona j nazwa myName. Jakiego typu powinna by ta zmienna instancji? Czy


naley j zadeklarowa jako private czy public? Napisz konstruktor, przy
uyciu ktrego mona zadawa warto tej zmiennej przy tworzeniu obiektu
Elevator za pomoc new i przypisa go do zmiennej. (Uwaga! Konstruktor jest
metod i musi mie tak sam nazw jak jego klasa. Ten konstruktor w swoim
nagwku musi mie parametr formalny typu string). Ustaw wywoanie konstruktora, kiedy uywa si sowa kluczowego new, przez wstawienie nazwy windy
jako argumentu; midzy nawiasami zamiast new Elevator() wpisz
new Elevator("WindaA").

Za kadym razem gdy Elevator zakoczy jazd, powinien drukowa swoj


nazw razem z opuszczanym pitrem i pitrem docelowym. Innymi sowy, zamiast drukowa
Odjedam z pitra: 2 Jad na: 24

powinien drukowa:
WindaA: Odjedam z pitra: 2 Jad na: 24

gdzie WindaA jest jego nazw rezydujc wewntrz myName.

You might also like