Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00425 008385 10465840 na godz. na dobę w sumie
wyszukaj dokładnie | pobierz wtyczkę
Język C#. Szkoła programowania - książka
Język C#. Szkoła programowania - książka
Autor: Liczba stron: 1128
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0358-1 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> .net - programowanie
Porównaj ceny (książka, ebook, audiobook).
Czytaj online.
Komentuj

Poznaj C# i rozpocznij podróż po świecie programowania

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.

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

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)

Gdzie kupić całą publikację:

Język C#. Szkoła programowania
Autor:
Sklep
Format
Cena
Helion.pl Helion.pl
książka
99,00 zł
Idź do sklepu »

Opinie na temat publikacji:

Inne popularne pozycje z tej kategorii:

Czytaj również:

Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: