Darmowy fragment publikacji:
IDZ DO
IDZ DO
PRZYK£ADOWY ROZDZIA£
PRZYK£ADOWY ROZDZIA£
SPIS TREœCI
SPIS TREœCI
KATALOG KSI¥¯EK
KATALOG KSI¥¯EK
KATALOG ONLINE
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
TWÓJ KOSZYK
Jêzyk C#. Szko³a
programowania
Autor: Klaus Michelsen
T³umaczenie: Krystyna Ziêba, Marzena Latawiec,
Marek Bury, Piotr Lubicz
ISBN: 83-246-0358-1
Tytu³ orygina³u: C# Primer Plus
Format: B5, stron: 1128
DODAJ DO KOSZYKA
DODAJ DO KOSZYKA
Poznaj C# i rozpocznij podró¿ po œwiecie programowania
CENNIK I INFORMACJE
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
ZAMÓW INFORMACJE
O NOWOœCIACH
O NOWOœCIACH
ZAMÓW CENNIK
ZAMÓW CENNIK
CZYTELNIA
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Koœciuszki 1c
44-100 Gliwice
tel. 032 230 98 63
e-mail: helion@helion.pl
(cid:129) Poznaj elementy jêzyka i zasady programowania obiektowego.
(cid:129) Wykorzystaj mo¿liwoœci platformy .NET.
(cid:129) Napisz i uruchom w³asne aplikacje.
C# to jeden z jêzyków programowania wchodz¹cych w sk³ad platformy .NET.
Wed³ug za³o¿eñ producenta — firmy Microsoft — ma stanowiæ podstawowe narzêdzie
programistyczne dla tej platformy. C#, ³¹cz¹cy w sobie najlepsze cechy jêzyków Visual
Basic, C++ i Java, jest ³atwy do opanowania, a daje ogromne mo¿liwoœci. Oparty na
komponentach i obiektach doskonale nadaje siê zarówno do tworzenia aplikacji dla
komputerów osobistych, jak i dla urz¹dzeñ typu PocketPC. Twórcy aplikacji w C# mog¹
wybieraæ miêdzy doskona³ym œrodowiskiem Visual Studio .NET a kilkoma narzêdziami
dostêpnymi na licencji open-source.
Ksi¹¿ka „Jêzyk C#. Szko³a programowania” to podrêcznik, który wprowadzi Ciê
w arkana sztuki pisania programów w tym jêzyku. Poznasz elementy jêzyka C#
i dowiesz siê, na czym polega programowanie obiektowe. Nauczysz siê korzystaæ
z zaawansowanych mo¿liwoœci oferowanych przez technologiê obiektow¹, takich jak
polimorfizm, interfejsy i struktury. Przeczytasz tu tak¿e o obs³udze wyj¹tków, tworzeniu
dokumentacji w formacie XML w oparciu o komentarze w kodzie oraz o operacjach
wejœcia i wyjœcia na plikach.
(cid:129) Kompilowanie i uruchamianie programów w C#
(cid:129) Typy i operatory
(cid:129) Instrukcje warunkowe i pêtle
(cid:129) Tablice
(cid:129) Klasy i obiekty
(cid:129) Dziedziczenie
(cid:129) Obs³uga zdarzeñ
(cid:129) Rekurencja
SPIS TREŚCI
O autorze ....................................................................................................................19
Wprowadzenie ...........................................................................................................21
Rozdział 1. Komputery i ich programowanie — podstawowe pojęcia ...........29
C# — obiektowy język programowania .......................................................31
Organizacja komputera ..............................................................................32
Sprzęt ...................................................................................................................32
Właściwości pamięci operacyjnej .............................................................34
Systemy liczbowe ........................................................................................36
Bajty ...............................................................................................................37
Pliki ................................................................................................................38
Oprogramowanie ..............................................................................................38
Ogólny proces wykonywania programu C# .........................................38
System operacyjny ......................................................................................39
Języki programowania i kompilatory ......................................................40
Wprowadzenie do .NET ............................................................................41
Kompilacja kodu źródłowego C# w .NET .............................................42
Podsumowanie ..................................................................................................45
Pytania kontrolne ..............................................................................................46
Rozdział 2. Twój pierwszy program C# ..............................................................47
Rozwój oprogramowania .................................................................................48
Proces tworzenia oprogramowania ...............................................................48
Algorytmy i pseudokod ...................................................................................50
Trzy rodzaje błędów .........................................................................................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 użytkownika ...................................................................64
6
JĘZYK C#. SZKOŁA PROGRAMOWANIA
Biblioteka klas środowiska .NET Framework ...............................................66
C# — historia i cele projektowania ................................................................67
Pochodzenie C# ................................................................................................67
Cele utworzenia C# ..........................................................................................70
Jakiego rodzaju programy można pisać za pomocą C#? .............................71
Mechanizmy tworzenia programu C# ..........................................................73
Przed rozpoczęciem ..........................................................................................74
Wybór edytora tekstu .......................................................................................75
Siedem kroków do napisania prostego programu C# ...............................75
Otwieranie i używanie konsoli poleceń (krok 1.) ..................................76
Wpisywanie i zapisywanie kodu źródłowego C# (krok 2.) .................77
Przekształcanie kodu źródłowego w plik PE (.exe) (krok 3.) ...............80
Jeżeli kompilator wykryje błędy składniowe (krok 4.) .........................80
Uruchamianie programu (krok 5.) ............................................................81
Sprawdzanie wyników (krok 6.) ...............................................................82
Czas na świętowanie (krok 7.) ...................................................................82
Krótka analiza kodu źródłowego ...................................................................82
Uwaga o błędach składniowych i kompilatorach ........................................83
Podsumowanie ..................................................................................................84
Pytania kontrolne ..............................................................................................85
Ćwiczenia z programowania ...........................................................................86
Rozdział 3. C# — wycieczka z przewodnikiem, część I ....................................87
Wstęp ...................................................................................................................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 spostrzeżeń .......................................................... 113
Podsumowanie ................................................................................................ 118
Pytania kontrolne ............................................................................................ 119
Ćwiczenia z programowania ......................................................................... 120
Rozdział 4. C# — wycieczka z przewodnikiem, część II ................................ 123
Wstęp ................................................................................................................. 123
Zasadnicze elementy SimpleCalculator.cs .................................................. 124
Prezentacja SimpleCalculator.cs ............................................................. 124
Bliższe spojrzenie na SimpleCalculator.cs ............................................ 126
Upraszczanie kodu za pomocą metod ......................................................... 139
Metody jako budowanie bloków — hermetyzacja metod
pomocniczych za pomocą słowa kluczowego private .......................... 140
SPIS TREŚCI
7
Podsumowanie ................................................................................................ 142
Pytania kontrolne ............................................................................................ 143
Ćwiczenia z programowania ......................................................................... 144
Rozdział 5. Twój pierwszy program obiektowy w C# .................................... 145
Wstęp ................................................................................................................. 146
Struktura leksykalna ....................................................................................... 146
Identyfikatory i style stosowania wielkich liter .................................... 146
Literały ........................................................................................................ 147
Komentarze i dokumentacja kodu źródłowego ................................... 148
Separatory .................................................................................................. 148
Operatory ................................................................................................... 149
Słowa kluczowe ......................................................................................... 150
Pewne przemyślenia na temat symulacji windy ....................................... 150
Pojęcia, cele i rozwiązania w programie symulacji windy
— zbieranie cennych danych statystycznych do oceny
systemu wind ............................................................................................. 150
Programowanie obiektowe — przykład praktyczny ................................ 152
Prezentacja SimpleElevatorSimulation.cs ............................................. 153
Ogólna struktura programu .................................................................... 156
Głębsza analiza SimpleElevatorSimulation.cs ...................................... 159
Związki klas i UML ................................................................................... 170
Podsumowanie ................................................................................................ 174
Pytania kontrolne ............................................................................................ 175
Ćwiczenia z programowania ......................................................................... 175
Rozdział 6. Typy, część I — typy proste ............................................................. 177
Wstęp ................................................................................................................. 178
Typy w C# — przegląd ................................................................................. 178
Co to jest typ? ............................................................................................ 179
Język z silną kontrolą typów ................................................................... 179
Zalety typów .............................................................................................. 182
Typy w C# ................................................................................................. 183
Typy proste ...................................................................................................... 189
Przegląd typów prostych ......................................................................... 191
Typy liczb całkowitych ............................................................................. 196
Zegar Blipos ...................................................................................................... 212
Typy zmiennoprzecinkowe ..................................................................... 222
Typ decimal ................................................................................................ 229
Zgodność wartości zmiennoprzecinkowych,
decimal i całkowitoliczbowych ......................................................... 231
Jawne konwersje typów ........................................................................... 231
Stałe — nazwy symboliczne dla literałów ............................................. 233
Formatowanie wartości liczbowych ....................................................... 237
Typ bool — krótkie omówienie .............................................................. 240
8
JĘZYK C#. SZKOŁA PROGRAMOWANIA
Podsumowanie ................................................................................................ 241
Pytania kontrolne ............................................................................................ 243
Ćwiczenia z programowania ......................................................................... 244
Rozdział 7. Typy, część II — operatory, wyliczenia i łańcuchy znakowe ......... 245
Wstęp ................................................................................................................. 246
Operatory arytmetyczne i wyrażenia arytmetyczne ................................. 246
Operatory dwuargumentowe ................................................................. 247
Asocjacyjność ................................................................................................... 251
Nawiasy i pierwszeństwo .............................................................................. 252
Operator modulo ( ) ..................................................................................... 254
Operatory jednoargumentowe ..................................................................... 259
Jednoargumentowy plus i jednoargumentowy minus ....................... 260
Operatory inkrementacji i dekrementacji ............................................. 261
Określanie typu wyrażenia ........................................................................... 265
Konwersje i operatory jednoargumentowe plus lub minus .............. 266
Łączenie różnych typów w jednym wyrażeniu ......................................... 268
Dostęp do metadanych komponentu — krótkie wprowadzenie ........... 272
Stałe wyliczeniowe .......................................................................................... 277
Operatory dla zmiennych wyliczanych ...................................................... 281
Konwersje ......................................................................................................... 282
Metody typu System.Enum ........................................................................... 282
Znaki i tekst ...................................................................................................... 283
Typ char ............................................................................................................ 283
Podwójne życie char ................................................................................. 286
Typ string .......................................................................................................... 287
Literały i obiekty typu string ................................................................... 288
Łańcuchy dosłowne .................................................................................. 289
Praca z łańcuchami ................................................................................... 289
Wstawianie sformatowanych liczb do łańcucha .................................. 294
Praca z łańcuchami ................................................................................... 298
Podsumowanie ................................................................................................ 316
Pytania kontrolne ............................................................................................ 317
Ćwiczenia z programowania ......................................................................... 318
Rozdział 8. Sterowanie, część I — instrukcje warunkowe
i pojęcia pokrewne ................................................................................321
Wprowadzenie do sterowania przebiegiem ............................................... 322
Rozgałęzianie za pomocą instrukcji if .......................................................... 324
Prosta instrukcja if ..................................................................................... 324
Instrukcje złożone ..................................................................................... 327
Opcjonalny warunek else ........................................................................ 327
Operatory porównania i wyrażenia logiczne ............................................. 330
Zagnieżdżone instrukcje if ............................................................................ 334
Instrukcje if-else o wielu gałęziach ............................................................... 339
SPIS TREŚCI
9
Operatory logiczne ......................................................................................... 344
Operator logiczny AND (I) — .......................................................... 346
Operator logiczny OR (LUB) — || ........................................................ 350
Skrócone wyznaczanie wartości wyrażeń i operatory
na poziomie bitowym, oraz | ........................................................ 352
Operator na poziomie bitowym Exclusive OR
(alternatywa wykluczająca) — ^ ..................................................... 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
Przeglądanie, analiza i generowanie sekwencji danych ............................. 385
Instrukcja sterująca (pętla) while .................................................................. 386
Instrukcja pętli do-while ................................................................................ 390
Instrukcja pętli for ........................................................................................... 394
Instrukcje sterujące break i continue ........................................................... 402
Instrukcja break ......................................................................................... 402
Instrukcja continue ................................................................................... 404
Programowanie strukturalne i konstrukcje strukturalne ....................... 405
Operatory połączonego przypisania ............................................................ 409
Zagnieżdżone 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 dostępu do poszczególnych elementów tablicy ................ 432
Przekroczony zakres indeksu ........................................................................ 438
Wprowadzanie poprawki na indeks tabeli zaczynający się od zera ...... 442
Inicjowanie tablicy .......................................................................................... 443
Przemierzanie całej tablicy za pomocą instrukcji foreach .......................... 445
10
JĘZYK C#. SZKOŁA PROGRAMOWANIA
System.Array jest typem referencyjnym ..................................................... 447
Tablice i równość ............................................................................................. 450
Tablice i metody .............................................................................................. 453
Elementy tablic jako argumenty metod ................................................ 453
Referencje do tablic jako argumenty metod ......................................... 455
Klonowanie obiektu tablicy ..................................................................... 458
Metoda wykonywania porównania tablic w sensie równości wartości ........463
Argumenty wiersza poleceń .......................................................................... 465
Używanie tablic jako wartości zwracanych przez metody ...................... 467
Tablice i klasy ............................................................................................. 472
Elementy tablicy odnoszące się do obiektów ............................................. 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 więcej niż dwoma wymiarami ..................................................... 518
Uzyskiwanie dostępu do tablicy wielowymiarowej
w pętli foreach ..................................................................................... 521
Metody wbudowane w klasę System.Array ............................................... 522
Techniki rozwiązywania problemów 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 — doświadczenia
ze statycznymi składowymi klas i metodami .................................. 551
Podstawy anatomii klasy ............................................................................... 552
Składowe danych ............................................................................................ 555
Zmienne instancji ...................................................................................... 555
Zmienne statyczne .................................................................................... 557
Składowe stałe ........................................................................................... 565
Składowe tylko do odczytu ..................................................................... 566
Deklarowanie danych składowych ........................................................ 566
SPIS TREŚCI
11
Składowe 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 pamięci .................................................................... 611
Konstruktory instancji .................................................................................... 612
Dlaczego potrzebne są konstruktory instancji? ................................... 612
Praca z konstruktorami instancji ............................................................ 616
Przeciążenie konstruktorów instancji .................................................... 621
Inicjalizator konstruktora ......................................................................... 628
Prywatne konstruktory instancji ............................................................ 631
Konstruktory statyczne .................................................................................. 631
Składowe tylko do odczytu ........................................................................... 632
Zbieranie nieużytków — automatyczne dynamiczne
zarządzanie pamięcią ............................................................................... 634
Jak sprawić, by obiekty stały się nieosiągalne? ..................................... 635
Zadania mechanizmu zbierania nieużytków ....................................... 639
Zwalnianie brakujących zasobów innych niż pamięć ........................ 641
Podsumowanie ................................................................................................ 658
Pytania kontrolne ............................................................................................ 660
Ćwiczenia z programowania ......................................................................... 661
Rozdział 14. Anatomia klasy, część III — pisanie intuicyjnego kodu ............. 663
Właściwości ...................................................................................................... 665
Właściwości a metody dostępowe .......................................................... 665
Właściwości są szybkie ............................................................................. 672
Implementacja opóźnionej inicjalizacji i leniwych aktualizacji
z właściwościami ................................................................................. 674
Indeksery — używanie obiektów podobnie jak tablic ................................ 679
Wywoływanie indeksera z wnętrza obiektu, w którym
rezyduje ................................................................................................ 683
Przeciążanie indekserów — wielokrotne indeksery
w tej samej klasie ................................................................................. 684
Unikanie nadużywania indekserów ...................................................... 689
Przeciążenie operatora ................................................................................... 690
Przeciążenie operatora zdefiniowane przez użytkownika ................ 692
Zdefiniowane przez użytkownika konwersje niejawne i jawne ............ 701
Dwa przypadki wymagające konwersji zdefiniowanych
przez użytkownika ............................................................................ 702
Używanie technik konwersji niezdefiniowanych
przez użytkownika ............................................................................. 704
12
JĘZYK C#. SZKOŁA PROGRAMOWANIA
Składnia konwersji zdefiniowanych przez użytkownika .................. 704
Łączenie konwersji zdefiniowanej przez użytkownika i niejawnej ........711
Typy zagnieżdżone ......................................................................................... 713
Zalety klas zagnieżdżonych .................................................................... 714
Przykład prostej klasy zagnieżdżonej ................................................... 714
Podsumowanie ................................................................................................ 715
Pytania kontrolne ............................................................................................ 717
Ćwiczenia z programowania ......................................................................... 719
Rozdział 15. Przestrzenie nazw, jednostki kompilacji i zestawy ..................... 721
Definiowanie własnej przestrzeni nazw ..................................................... 722
Globalna nienazwana przestrzeń nazw ...................................................... 723
Przestrzenie nazw i jednostki kompilacji .................................................... 723
Zagnieżdżone przestrzenie nazw ................................................................. 726
Składnia przestrzeni nazw ............................................................................. 729
Więcej 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 zestawów ................................... 741
Badanie zestawów za pomocą narzędzia Ildasm ....................................... 744
Podsumowanie ................................................................................................ 746
Pytania kontrolne ............................................................................................ 747
Ćwiczenia z programowania ......................................................................... 749
Rozdział 16. Dziedziczenie, część I — podstawowe pojęcia ............................ 751
Potrzeba dziedziczenia ................................................................................... 753
Życie bez dziedziczenia ............................................................................ 754
Podstawy dziedziczenia ................................................................................. 760
Przesłanianie definicji funkcji ................................................................. 765
Modyfikatory dostępu a dziedziczenie ....................................................... 771
Modyfikator dostępu protected .............................................................. 771
Accessing private... .................................................................................... 771
Modyfikator dostępu internal protected ............................................... 773
Przegląd modyfikatorów dostępu .......................................................... 774
Konstruktory klas wyprowadzonych .......................................................... 774
Również indeksery są dziedziczone i mogą być przesłaniane ................ 780
Wywoływanie przesłoniętych funkcji klasy bazowej ............................... 783
Wielokrotne wykorzystanie biblioteki klas .NET Framework
za pomocą dziedziczenia ......................................................................... 786
Wielopoziomowe wyprowadzanie klas ...................................................... 788
Przesłanianie metod i przeciążanie to różne mechanizmy ...................... 792
SPIS TREŚCI
13
Podsumowanie ................................................................................................ 794
Pytania kontrolne ............................................................................................ 796
Ćwiczenia z programowania ......................................................................... 797
Rozdział 17. Dziedziczenie, część II — funkcje abstrakcyjne,
polimorfizm oraz interfejsy ............................................................. 801
Abstrakcyjne metody, właściwości, indeksery oraz klasy ........................ 802
Polimorfizm ...................................................................................................... 807
Obiekt klasy potomnej ma więcej niż jeden typ .................................. 807
Wiązanie dynamiczne metod wirtualnych oraz akcesorów
(get, set) ................................................................................................. 808
Studium — prosty program do rysowania ........................................... 810
Tracenie i odzyskiwanie informacji o typie ................................................ 818
Operator is .................................................................................................. 819
Rzutowanie obiektów ............................................................................... 820
Operator as ................................................................................................. 823
System.Object — elementarna klasa bazowa ............................................. 823
Ukrywanie metod ........................................................................................... 830
Tworzenie wersji poprzez użycie słów kluczowych new i override ...... 832
Dziedziczenie wielokrotne ............................................................................ 836
Interfejsy ........................................................................................................... 837
Definiowanie interfejsu ............................................................................ 840
Implementacja interfejsu ......................................................................... 841
O programowaniu z interfejsami ........................................................... 845
Budowanie hierarchii interfejsów .......................................................... 850
Konwersje interfejsów .............................................................................. 850
Przeciążanie wirtualnych implementacji interfejsów ......................... 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 słowem kluczowym new oraz bez niego ............ 866
Typy wartościowe a typy referencyjne ....................................................... 867
Podsumowanie ................................................................................................ 869
Pytania kontrolne ............................................................................................ 869
Ćwiczenia z programowania ......................................................................... 870
Rozdział 19. Obsługa wyjątków ............................................................................ 871
Obsługa wyjątków — krótki przegląd ......................................................... 872
Rzeczywistość bez try-catch-finally .............................................................. 873
Bloki try oraz catch .......................................................................................... 875
14
JĘZYK C#. SZKOŁA PROGRAMOWANIA
Przechwytywanie obiektów wyjątków w wyższych ogniwach
łańcucha wywołań .................................................................................... 878
Wieloskładnikowe bloki catch ....................................................................... 880
Blok finally ........................................................................................................ 881
Zagnieżdżone bloki try .................................................................................. 884
throw — jawne wyrzucanie wyjątków ....................................................... 886
Pisanie własnych wyjątków .......................................................................... 889
Podsumowanie ................................................................................................ 892
Pytania kontrolne ............................................................................................ 892
Ćwiczenia z programowania ......................................................................... 893
Rozdział 20. Delegaty i zdarzenia ......................................................................... 895
Delegaty ............................................................................................................ 896
Tablice delegatów oraz delegaty przekazywane
jako argument wywołań metod ....................................................... 900
Delegaty grupowe ..................................................................................... 905
Zdarzenie .......................................................................................................... 908
Pisanie programów działających w oparciu o zdarzenia ................... 909
Podsumowanie ................................................................................................ 917
Pytania kontrolne ............................................................................................ 917
Ćwiczenia z programowania ......................................................................... 918
Rozdział 21. Przetwarzanie wstępne, dokumentacja XML oraz atrybuty ..... 919
Dyrektywy preprocesora ............................................................................... 920
Wyłączanie i dołączanie kodu za pomocą #define, #if
oraz #endif ........................................................................................... 920
#undef — usuwanie definicji identyfikatorów ................................... 923
#elif oraz #else .......................................................................................... 923
#error oraz #warning .............................................................................. 924
#region oraz #endregion ........................................................................ 924
#line ............................................................................................................ 924
Dokumentacja XML ........................................................................................ 924
Prosty przykład dokumentacji XML ...................................................... 925
Atrybuty ............................................................................................................ 927
Prosty przykład oznaczania atrybutami ................................................ 930
Podsumowanie ................................................................................................ 933
Pytania kontrolne ............................................................................................ 934
Ćwiczenia z programowania ......................................................................... 936
Rozdział 22. Wejście i wyjście z wykorzystaniem plików ................................. 939
Wejście/wyjście z wykorzystaniem plików i podstawy strumieni .......... 940
Pliki tekstowe i pliki binarne ................................................................... 940
Przegląd klas wejścia/wyjścia z wykorzystaniem plików ...................... 941
Klasa FileInfo .................................................................................................... 942
Realizacja wejścia do plików tekstowych i wyjścia z nich
poprzez StreamReader oraz StreamWriter ........................................... 946
SPIS TREŚCI
15
Realizacja binarnego wejścia i wyjścia za pomocą klasy FileStream ...... 951
Podsumowanie ................................................................................................ 955
Pytania kontrolne ............................................................................................ 955
Ćwiczenia z programowania ......................................................................... 956
Rozdział 23. Podstawy rekurencji ......................................................................... 959
Oczekujące instancje metody w różnych metodach ................................. 960
Oczekujące instancje metody w ramach tej samej metody ................... 962
Działanie 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 rozwiązania ćwiczeń ............................. 977
Rozdział 1 ......................................................................................................... 977
Odpowiedzi na pytania kontrolne z rozdziału 1 ................................. 977
Rozdział 2 ......................................................................................................... 978
Odpowiedzi na pytania kontrolne z rozdziału 2 ................................. 978
Odpowiedzi do ćwiczeń z programowania z rozdziału 2 .................. 980
Rozdział 3 ......................................................................................................... 981
Odpowiedzi na pytania kontrolne z rozdziału 3 ................................. 981
Odpowiedzi do ćwiczeń z programowania z rozdziału 3 .................. 982
Rozdział 4 ......................................................................................................... 983
Odpowiedzi na pytania kontrolne z rozdziału 4 ................................. 983
Odpowiedzi do ćwiczeń z programowania z rozdziału 4 .................. 984
Rozdział 5 ......................................................................................................... 987
Odpowiedzi na pytania kontrolne z rozdziału 5 ................................. 987
Odpowiedzi do ćwiczeń z programowania z rozdziału 5 .................. 988
Rozdział 6 ......................................................................................................... 989
Odpowiedzi na pytania kontrolne z rozdziału 6 ................................. 989
Odpowiedzi do ćwiczeń z programowania z rozdziału 6 .................. 990
Rozdział 7 ......................................................................................................... 996
Odpowiedzi na pytania kontrolne z rozdziału 7 ................................. 996
Odpowiedzi do ćwiczeń z programowania z rozdziału 7 .................. 998
Rozdział 8 ....................................................................................................... 1000
Odpowiedzi na pytania kontrolne z rozdziału 8 ............................... 1000
Odpowiedzi do ćwiczeń z programowania z rozdziału 8 ................ 1002
Rozdział 9 ....................................................................................................... 1004
Odpowiedzi na pytania kontrolne z rozdziału 9 ............................... 1004
Odpowiedzi do ćwiczeń z programowania z rozdziału 9 ................ 1005
Rozdział 10 ..................................................................................................... 1007
Odpowiedzi na pytania kontrolne z rozdziału 10 ............................. 1007
Odpowiedzi do ćwiczeń z programowania z rozdziału 10 .............. 1008
16
JĘZYK C#. SZKOŁA PROGRAMOWANIA
Rozdział 11 ..................................................................................................... 1011
Odpowiedzi na pytania kontrolne z rozdziału 11 ............................. 1011
Odpowiedzi do ćwiczeń z programowania z rozdziału 11 .............. 1012
Rozdział 12 ..................................................................................................... 1018
Odpowiedzi na pytania kontrolne z rozdziału 12 ............................. 1018
Odpowiedzi do ćwiczeń z programowania z rozdziału 12 .............. 1019
Rozdział 13 ..................................................................................................... 1022
Odpowiedzi na pytania kontrolne z rozdziału 13 ............................. 1022
Odpowiedzi do ćwiczeń z programowania z rozdziału 13 .............. 1024
Rozdział 14 ..................................................................................................... 1026
Odpowiedzi na pytania kontrolne z rozdziału 14 ............................. 1026
Odpowiedzi do ćwiczeń z programowania z rozdziału 14 .............. 1027
Rozdział 15 ..................................................................................................... 1032
Odpowiedzi na pytania kontrolne z rozdziału 15 ............................. 1032
Odpowiedzi do ćwiczeń z programowania z rozdziału 15 .............. 1033
Rozdział 16 ..................................................................................................... 1036
Odpowiedzi na pytania kontrolne z rozdziału 16 ............................. 1036
Odpowiedzi do ćwiczeń z programowania z rozdziału 16 .............. 1037
Rozdział 17 ..................................................................................................... 1040
Odpowiedzi na pytania kontrolne z rozdziału 17 ............................. 1040
Odpowiedzi do ćwiczeń z programowania z rozdziału 17 .............. 1042
Rozdział 18 ..................................................................................................... 1047
Odpowiedzi na pytania kontrolne z rozdziału 18 ............................. 1047
Odpowiedzi do ćwiczeń z programowania z rozdziału 18 .............. 1047
Rozdział 19 ..................................................................................................... 1049
Odpowiedzi na pytania kontrolne z rozdziału 19 ............................. 1049
Odpowiedzi do ćwiczeń z programowania z rozdziału 19 .............. 1050
Rozdział 20 ..................................................................................................... 1051
Odpowiedzi na pytania kontrolne z rozdziału 20 ............................. 1051
Odpowiedzi do ćwiczeń z programowania z rozdziału 20 .............. 1052
Rozdział 21 ..................................................................................................... 1058
Odpowiedzi na pytania kontrolne z rozdziału 21 ............................. 1058
Odpowiedzi do ćwiczeń z programowania z rozdziału 21 .............. 1060
Rozdział 22 ..................................................................................................... 1063
Odpowiedzi na pytania kontrolne z rozdziału 22 ............................. 1063
Odpowiedzi do ćwiczeń z programowania z rozdziału 22 .............. 1063
Rozdział 23 ..................................................................................................... 1066
Odpowiedzi na pytania kontrolne z rozdziału 23 ............................. 1066
Odpowiedzi do ćwiczeń z programowania z rozdziału 23 .............. 1067
Dodatek B Kolejność operatorów ..................................................................... 1069
Dodatek C Zarezerwowane słowa w C# ........................................................ 1073
SPIS TREŚCI
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
pomiędzy systemami liczbowymi ........................................................ 1085
Ujemne liczby binarne .................................................................................. 1090
Dodatek E Zestaw znaków Unicode ................................................................ 1093
Dodatek F Wykorzystanie poleceń systemu DOS w oknie konsoli ........... 1099
Skorowidz .............................................................................................................. 1099
5
TWÓJ PIERWSZY PROGRAM
OBIEKTOWY W C#
W tym rozdziale dowiesz się:
(cid:122) Jakie niepodzielne elementy
zawiera program źródłowy C#,
(cid:122) Jakie konwencjonalne style
nazywania klas, metod
i zmiennych funkcjonują podczas
programowania w C#,
(cid:122) Na jakiej zasadzie działają
operatory, argumenty i wyrażenia,
(cid:122) Jak pisać i tworzyć instancje
swoich własnych klas,
(cid:122) Jak można wdrożyć teoretyczną
dyskusję obiektową o klasach
Elevators i Person
z rozdziału 3., „C# — wycieczka
z przewodnikiem, część I”,
aby utworzyć w pełni działający
program C#,
(cid:122) Jak wygląda prosty program
obiektowy i jego ważne elementy,
(cid:122) Jak inicjalizować zmienne
instancji nowo utworzonych
obiektów,
(cid:122) W jaki sposób obiekty osiągają
zdolność do zawierania
zmiennych instancji, które
zawierają inne obiekty,
(cid:122) Jak programiści implementują
zależności między klasami,
aby umożliwić im współpracę
i tworzyć programy obiektowe,
(cid:122) Po co utworzono zunifikowany
język modelowania (Unified
Modeling Language — UML)
i jak można go zastosować
do ilustracji graficznej
oraz modelowania zależności
między klasami,
(cid:122) W jaki sposób asocjacja,
agregacja i kompozycja regulują
zależności między klasami.
146
JĘZYK C#. SZKOŁA PROGRAMOWANIA
Wstęp
Dotychczas zapoznaliśmy się z dwoma programami źródłowymi przedstawionymi
w listingach 3.1 w rozdziale 3. i 4.1 w rozdziale 4. Przedstawione tam konstrukcje
języka C# w pewnym stopniu zależały od treści poszczególnych wierszy kodu
i w rezultacie zajmowały się jednocześnie wieloma różnorodnymi, ale wzajemnie
związanymi ze sobą aspektami. Aby nadrobić braki tej szybkiej wycieczki po C#,
pierwsza część tego rozdziału będzie poświęcona przeglądowi podstawowych ele-
mentów C#.
W ostatniej części rozdziału zobaczymy pierwszy w tej książce program obiektowy C#.
Jest on oparty na poprzednich teoretycznych dyskusjach obiektowych, a zwłaszcza
na omówieniu symulacji windy na początku rozdziału 3. Pozwala m.in. zaobser-
wować, jak omówiony wcześniej związek między klasami Elevator i Person jest
implementowany w C#.
Struktura leksykalna
Kiedy kompilator C# otrzymuje kawałek kodu źródłowego do kompilacji, staje przed
pozornie zniechęcającym zadaniem rozszyfrowania długiej listy znaków (dokład-
niej, znaków Unicode, przedstawionych w dodatku E, „Zestaw znaków Unicode”)
i przekształcenia ich na odpowiedni MSIL o znaczeniu dokładnie tym samym, co
oryginalny kod źródłowy. Aby znaleźć sens tej masy kodu źródłowego, musi roz-
poznać niepodzielne elementy C# — niedające się rozbić części tworzące kod źró-
dłowy C#. Przykładami takich niepodzielnych elementów są: nawias klamrowy ({),
nawias (() oraz słowa kluczowe, np. class i if. Zadanie, które wykonuje kompi-
lator, związane z rozróżnieniem otwierających i zamykających nawiasów klamro-
wych, słów kluczowych, nawiasów itd., nazywa się analizą leksykalną. W zasadzie,
kwestie leksykalne, którymi zajmuje się kompilator, odnoszą się do tego, jak znaki
kodu źródłowego można przetłumaczyć na znaki zrozumiałe dla kompilatora.
Programy C# są zbiorem identyfikatorów, słów kluczowych, odstępów, komentarzy,
literałów, operatorów i separatorów. Z większością tych elementów C# już spotka-
liśmy się. W dalszym ciągu rozdziału dokonamy ich przeglądu, a także wprowadzimy
jeszcze kilka innych aspektów.
Identyfikatory i style stosowania wielkich liter
Identyfikatory służą do nazywania klas, metod i zmiennych. Dowiedzieliśmy się już,
jakich zasad należy przestrzegać, aby identyfikator był prawidłowy, oraz tego, że
dobrze wybrane identyfikatory mogą poprawić klarowność kodu źródłowego i spra-
wić, że kod będzie samodokumentujący. Teraz wprowadzimy inny aspekt związany
z identyfikatorami, a mianowicie styl stosowania wielkich liter.
Rozdział 5. • TWÓJ PIERWSZY PROGRAM OBIEKTOWY W C# 147
Programiści często wybierają identyfikatory składające się z kilku słów, aby kod
źródłowy był bardziej klarowny i samodokumentujący. Można by np. zastosować
słowa „urodzenia rocznie”. Jednakże kompilator reaguje na odstęp i każdy identy-
fikator podzielony na słowa za pomocą odstępu będzie błędnie interpretowany.
Przykładowo zmiennej, która ma przedstawiać średnią prędkość na godzinę, nie
można nazwać srednia predkosc na godzine1. Musimy wyrzucić odstępy,
aby utworzyć jedną prawidłową nazwę, zachowując styl pozwalający czytelnikowi
kodu źródłowego rozróżniać poszczególne słowa identyfikatora. Niektóre języki
komputerowe akceptują konwencję srednia_predkosc_na_godzine. Natomiast
w C# większość programistów stosuje uzgodnioną sekwencję dużych i małych liter
w celu rozróżnienia poszczególnych słów identyfikatora.
W świecie C# istnieje wiele ważnych stylów używania wielkich liter:
► Styl Pascal — pierwsza litera każdego słowa w nazwie jest dużą literą, np. Sred-
niaPredkoscNaGodzine,
► Styl Camel — tak jak Pascal, z tym wyjątkiem, że całe pierwsze słowo identyfi-
katora jest pisane małymi literami, np. sredniaPredkoscNaGodzine.
Styl Pascal jest zalecany do nazywania klas i metod, a styl Camel służy do nazywania
zmiennych.
Wskazówka
Nie wszystkie języki komputerowe odróżniają małe i wielkie litery. W takich języ-
kach słowa Srednia i srednia są identyczne dla kompilatora. W celu uzyskania
kompatybilności z tymi językami, należy unikać sytuacji, w których wielkość liter
decyduje o rozróżnialności identyfikatorów typu public, które są dostępne dla
innych języków.
Literały
Rozważmy dwa następujące wiersze kodu źródłowego:
int number;
number = 10;
number jest wyraźnie zmienną. W pierwszym wierszu deklarujemy, że number ma
być typu int. W drugim wierszu przypisujemy number wartość 10. Ale co to jest 10?
No właśnie, 10 nie może zmieniać swojej wartości i nazywa się literałem. Literały to
nie tylko liczby. Mogą to być również znaki, takie jak B, $ i z, a także tekst, np. To
1 W wielu językach programowania pojawiają się kłopoty przy korzystaniu w identyfikatorach
z polskich znaków diakrytycznych (ę, ś, ć itp.). Jeśli więc używamy polskich nazw, warto takich liter
unikać — przyp. tłum.
148
JĘZYK C#. SZKOŁA PROGRAMOWANIA
jest literał. Literały mogą być przechowywane w dowolnej zmiennej, której
typ jest kompatybilny z typem literału.
Komentarze i dokumentacja kodu źródłowego
Główną cechą komentarzy jest to, że są całkowicie ignorowane przez kompilator.
Dotychczas poznaliśmy dwa sposoby tworzenia komentarzy; jednowierszowe ozna-
czamy za pomocą //, a wielowierszowe — przy użyciu /* */.
Istnieje jeszcze trzeci typ, który umożliwia zapisywanie dokumentacji jako części
kodu źródłowego, co będzie pokazane w tym rozdziale, przy czym dodatkowo można
umieścić tę dokumentację w osobnych plikach eXtensible Markup Language (XML).
W tej chwili wystarczy docenić szczególnie przydatny wynik końcowy tej właściwości;
trzeba tylko zajrzeć do dokumentacji bibliotek klas .NET Framework, która została
stworzona przez utworzenie plików XML z komentarzy/dokumentacji znajdujących
się w oryginalnym kodzie źródłowym.
Separatory
W języku C# separatory służą do oddzielania od siebie różnych elementów. Spo-
tkaliśmy już wiele z nich. Przykładem może być powszechnie stosowany średnik ;,
który jest wymagany do zakończenia instrukcji. W tabeli 5.1 zebrano separatory, które
już poznaliśmy.
Tabela 5.1. Ważne separatory w C#
Nazwa
Nawiasy
klamrowe
Nawiasy
Symbol
{ }
Cel
Służą do zamknięcia bloku kodu dla klas, metod oraz, co pokażemy
później, instrukcji rozgałęzień i pętli.
Zawierają listy parametrów formalnych w nagłówkach metod oraz
listy argumentów w instrukcjach wywoływania metod. W nawiasie
muszą znajdować się również wyrażenia logiczne (boole’owskie)
w instrukcji if, a także w instrukcjach rozgałęzień i pętli, co będzie
pokazane później.
Kończy instrukcję.
Oddziela parametry formalne w nawiasie nagłówka metody i oddziela
argumenty w instrukcji wywołania metody.
Służy do wyznaczania przestrzeni nazw zawartych wewnątrz innych
przestrzeni i do określania klas wewnątrz tych przestrzeni, i metod
(o ile są dostępne) wewnątrz klas i obiektów. Może być również
stosowana do określania zmiennych instancji wewnątrz klas i obiektów
(o ile są dostępne), ale tej praktyki należy unikać.
( )
Średnik
Przecinek
Kropka
;
,
.
Rozdział 5. • TWÓJ PIERWSZY PROGRAM OBIEKTOWY W C# 149
Operatory
Operatory są przedstawiane za pomocą symboli, takich jak +, =, == i *. Operatory
działają na argumenty, które znajdują się obok operatora, np.:
sumTotal + 10
zawiera operator + otoczony dwoma argumentami, sumTotal i 10. W tym kontek-
ście operator + łączy dwa argumenty w celu uzyskania wyniku, a więc jest to opera-
tor dwuargumentowy. Niektóre operatory działają na tylko jeden argument; nazywa
się je więc operatorami jednoargumentowymi.
Operatory wraz ze swoimi argumentami tworzą wyrażenia. Sam literał lub zmienna
są również wyrażeniami, tak jak kombinacje literałów i zmiennych z operatorami.
W rezultacie wyrażenia mogą być stosowane jako argumenty pod warunkiem, że są
spełnione zasady, które mają zastosowanie do każdego operatora, co pokazano na
następującym przykładzie:
a, 5 i 10, d to są wyrażenia, na które działa operator +. Natomiast
(a + 5) i (10 + d)
są również wyrażeniami, na które działa operator *. Na koniec,
(a + 5) · (10 + d)
można uważać za jedno wyrażenie. Operator przypisania = działa na to ostatnie
wyrażenie i wyrażenie mySum. Wyrażenia są często zagnieżdżone w sobie nawzajem,
tworząc hierarchię wyrażeń, tak jak w poprzednim przykładzie.
Operatory można podzielić na następujące kategorie: operatory przypisania, aryt-
metyczne, jednoargumentowe, równości, porównania, logiczne, warunkowe, prze-
sunięcia i podstawowe.
W dalszych rozdziałach poświęcimy trochę więcej czasu na omówienie operatorów,
ale na razie podsumujmy szybko te, które dotychczas napotkaliśmy.
► Operator przypisania (=) — powoduje, że argument po jego lewej stronie zmienia
swoją wartość na wyrażenie znajdujące się po prawej, jak w wierszu
29: sumTotal = a + b;
gdzie a + b można uważać za jeden argument.
150
JĘZYK C#. SZKOŁA PROGRAMOWANIA
► Dwuargumentowe operatory arytmetyczne (+ i *) — w następującym przykładzie
a * b
występuje mnożenie a i b bez zmiany ich wartości.
► Operator konkatenacji (+) — łączy dwa łańcuchy znakowe w jeden łańcuch.
► Operator równości (==) — porównuje dwa wyrażenia, aby sprawdzić, czy są
równe, np.:
leftExpression == rightExpression
to prawda tylko wtedy, gdy oba wyrażenia będą równe; w przeciwnym razie będzie
to fałsz.
Słowa kluczowe
W dodatku C podano 77 słów kluczowych C# (wszystkie). Dotychczas spotkaliśmy
słowa kluczowe, takie jak if, cla
Pobierz darmowy fragment (pdf)