Programuj w C#!
- Zanim zaczniesz programować, czyli podstawowe koncepcje i uruchomienie programu
- Elementy języka, czyli od typów danych do zmiennych, operatorów i instrukcji
- Programowanie obiektowe, czyli obiekty, klasy, dziedziczenie i cała reszta
C# należy do rodziny obiektowych języków programowania. Co to oznacza? Otóż znajduje się on w doborowym towarzystwie Javy, C++ i wielu innych języków, za pomocą których można tworzyć wspaniałe aplikacje, ale jednocześnie jest od nich odrobinę łatwiejszy. Jeśli dopiero zaczynasz przygodę z programowaniem, szybciej uda Ci się go opanować, a jeśli jest to dla Ciebie któryś kolejny język, zrozumienie jego składni i reguł nie powinno sprawić Ci większych trudności — szczególnie jeśli do nauki wykorzystasz tę książkę.
Ten znakomity praktyczny podręcznik pozwoli Ci przećwiczyć używanie i sposób działania wszystkich elementów C# — różnych typów danych, zmiennych i operatorów, instrukcji i tablic. Zobaczysz, jak korzystać z pętli i jak zachowują się obiekty. Poznasz najróżniejsze rodzaje klas, opanujesz wygodne korzystanie z dziedziczenia i nauczysz się obsługiwać błędy. W dalszej części książki znajdziesz zaawansowane zagadnienia programowania obiektowego i odkryjesz, jak projektować aplikacje z interfejsem graficznym. Krótko mówiąc, po starannym wykonaniu ćwiczeń będziesz w stanie zaprojektować i zbudować własną aplikację z użyciem języka C#!
- Typy danych, zmienne i instrukcje sterujące
- Tablice i pętle
- Klasy i obiekty
- Dziedziczenie
- Obsługa błędów i wyjątków
- System wejścia-wyjścia
- Polimorfizm i interfejsy
- Klasy zagnieżdżone i typy uogólnione
- Aplikacje z interfejsem graficznym
Rozdziały:
Wstęp (9)
- Czym jest C#? (9)
- Dla kogo jest ta książka? (9)
- Standardy C# (10)
Rozdział 1. Zanim zaczniesz programować (11)
- Lekcja 1. Podstawowe koncepcje C# i .NET (11)
- Jak to działa? (11)
- Narzędzia (12)
- Instalacja narzędzi (13)
- Lekcja 2. Pierwsza aplikacja, kompilacja i uruchomienie programu (16)
- .NET Framework (16)
- Visual Studio (19)
- Mono (22)
- MonoDevelop (Xamarin Studio) (23)
- Struktura kodu (26)
- Lekcja 3. Komentarze (27)
- Komentarz blokowy (27)
- Komentarz liniowy (28)
- Komentarz XML (29)
- Ćwiczenia do samodzielnego wykonania (30)
Rozdział 2. Elementy języka (31)
- Typy danych (31)
- Lekcja 4. Typy danych w C# (32)
- Typy danych w C# (32)
- Zapis wartości (literały) (36)
- Zmienne (39)
- Lekcja 5. Deklaracje i przypisania (39)
- Proste deklaracje (39)
- Deklaracje wielu zmiennych (41)
- Nazwy zmiennych (42)
- Zmienne typów odnośnikowych (42)
- Ćwiczenia do samodzielnego wykonania (43)
- Lekcja 6. Wyprowadzanie danych na ekran (43)
- Wyświetlanie wartości zmiennych (43)
- Wyświetlanie znaków specjalnych (46)
- Instrukcja Console.Write (48)
- Ćwiczenia do samodzielnego wykonania (49)
- Lekcja 7. Operacje na zmiennych (49)
- Operacje arytmetyczne (50)
- Operacje bitowe (57)
- Operacje logiczne (61)
- Operatory przypisania (63)
- Operatory porównywania (relacyjne) (64)
- Pozostałe operatory (65)
- Priorytety operatorów (65)
- Ćwiczenia do samodzielnego wykonania (66)
- Instrukcje sterujące (67)
- Lekcja 8. Instrukcja warunkowa if...else (67)
- Podstawowa postać instrukcji if...else (67)
- Zagnieżdżanie instrukcji if...else (69)
- Instrukcja if...else if (72)
- Ćwiczenia do samodzielnego wykonania (75)
- Lekcja 9. Instrukcja switch i operator warunkowy (76)
- Instrukcja switch (76)
- Przerywanie instrukcji switch (79)
- Operator warunkowy (81)
- Ćwiczenia do samodzielnego wykonania (82)
- Lekcja 10. Pętle (82)
- Pętla for (83)
- Pętla while (86)
- Pętla do...while (88)
- Pętla foreach (89)
- Ćwiczenia do samodzielnego wykonania (90)
- Lekcja 11. Instrukcje break i continue (91)
- Instrukcja break (91)
- Instrukcja continue (95)
- Ćwiczenia do samodzielnego wykonania (96)
- Tablice (97)
- Lekcja 12. Podstawowe operacje na tablicach (98)
- Tworzenie tablic (98)
- Inicjalizacja tablic (101)
- Właściwość Length (102)
- Ćwiczenia do samodzielnego wykonania (103)
- Lekcja 13. Tablice wielowymiarowe (104)
- Tablice dwuwymiarowe (104)
- Tablice tablic (107)
- Tablice dwuwymiarowe i właściwość Length (109)
- Tablice nieregularne (111)
- Ćwiczenia do samodzielnego wykonania (115)
Rozdział 3. Programowanie obiektowe (117)
- Podstawy (117)
- Lekcja 14. Klasy i obiekty (118)
- Podstawy obiektowości (118)
- Pierwsza klasa (119)
- Jak użyć klasy? (121)
- Metody klas (122)
- Jednostki kompilacji, przestrzenie nazw i zestawy (126)
- Ćwiczenia do samodzielnego wykonania (130)
- Lekcja 15. Argumenty i przeciążanie metod (131)
- Argumenty metod (131)
- Obiekt jako argument (134)
- Przeciążanie metod (138)
- Argumenty metody Main (139)
- Sposoby przekazywania argumentów (140)
- Definicje metod za pomocą wyrażeń lambda (143)
- Ćwiczenia do samodzielnego wykonania (144)
- Lekcja 16. Konstruktory i destruktory (145)
- Czym jest konstruktor? (145)
- Argumenty konstruktorów (148)
- Przeciążanie konstruktorów (149)
- Słowo kluczowe this (151)
- Niszczenie obiektu (154)
- Ćwiczenia do samodzielnego wykonania (155)
- Dziedziczenie (156)
- Lekcja 17. Klasy potomne (156)
- Dziedziczenie (156)
- Konstruktory klasy bazowej i potomnej (160)
- Ćwiczenia do samodzielnego wykonania (164)
- Lekcja 18. Modyfikatory dostępu (164)
- Określanie reguł dostępu (165)
- Dlaczego ukrywamy wnętrze klasy? (170)
- Jak zabronić dziedziczenia? (174)
- Tylko do odczytu (175)
- Ćwiczenia do samodzielnego wykonania (178)
- Lekcja 19. Przesłanianie metod i składowe statyczne (179)
- Przesłanianie metod (179)
- Przesłanianie pól (182)
- Składowe statyczne (183)
- Ćwiczenia do samodzielnego wykonania (186)
- Lekcja 20. Właściwości i struktury (186)
- Właściwości (187)
- Struktury (196)
- Ćwiczenia do samodzielnego wykonania (200)
Rozdział 4. Wyjątki i obsługa błędów (203)
- Lekcja 21. Blok try...catch (203)
- Badanie poprawności danych (203)
- Wyjątki w C# (207)
- Ćwiczenia do samodzielnego wykonania (211)
- Lekcja 22. Wyjątki to obiekty (212)
- Dzielenie przez zero (212)
- Wyjątek jest obiektem (213)
- Hierarchia wyjątków (214)
- Przechwytywanie wielu wyjątków (215)
- Zagnieżdżanie bloków try...catch (218)
- Ćwiczenia do samodzielnego wykonania (220)
- Lekcja 23. Własne wyjątki (220)
- Zgłaszanie wyjątków (221)
- Ponowne zgłoszenie przechwyconego wyjątku (223)
- Tworzenie własnych wyjątków (225)
- Wyjątki warunkowe (226)
- Sekcja finally (228)
- Ćwiczenia do samodzielnego wykonania (231)
Rozdział 5. System wejścia-wyjścia (233)
- Lekcja 24. Ciągi znaków (233)
- Znaki i łańcuchy znakowe (233)
- Znaki specjalne (237)
- Zamiana ciągów na wartości (238)
- Formatowanie danych (240)
- Przetwarzanie ciągów (242)
- Ćwiczenia do samodzielnego wykonania (247)
- Lekcja 25. Standardowe wejście i wyjście (247)
- Klasa Console i odczyt znaków (248)
- Wczytywanie tekstu z klawiatury (255)
- Wprowadzanie liczb (256)
- Ćwiczenia do samodzielnego wykonania (257)
- Lekcja 26. Operacje na systemie plików (258)
- Klasa FileSystemInfo (258)
- Operacje na katalogach (259)
- Operacje na plikach (266)
- Ćwiczenia do samodzielnego wykonania (271)
- Lekcja 27. Zapis i odczyt plików (271)
- Klasa FileStream (272)
- Podstawowe operacje odczytu i zapisu (274)
- Operacje strumieniowe (278)
- Ćwiczenia do samodzielnego wykonania (287)
Rozdział 6. Zaawansowane zagadnienia programowania obiektowego (289)
- Polimorfizm (289)
- Lekcja 28. Konwersje typów i rzutowanie obiektów (289)
- Konwersje typów prostych (290)
- Rzutowanie typów obiektowych (291)
- Rzutowanie na typ Object (295)
- Typy proste też są obiektowe! (297)
- Ćwiczenia do samodzielnego wykonania (299)
- Lekcja 29. Późne wiązanie i wywoływanie metod klas pochodnych (299)
- Rzeczywisty typ obiektu (300)
- Dziedziczenie a wywoływanie metod (302)
- Dziedziczenie a metody prywatne (307)
- Ćwiczenia do samodzielnego wykonania (308)
- Lekcja 30. Konstruktory oraz klasy abstrakcyjne (309)
- Klasy i metody abstrakcyjne (309)
- Wywołania konstruktorów (313)
- Wywoływanie metod w konstruktorach (316)
- Ćwiczenia do samodzielnego wykonania (318)
- Interfejsy (319)
- Lekcja 31. Tworzenie interfejsów (319)
- Czym są interfejsy? (319)
- Interfejsy a hierarchia klas (322)
- Interfejsy i właściwości (324)
- Ćwiczenia do samodzielnego wykonania (326)
- Lekcja 32. Implementacja kilku interfejsów (326)
- Implementowanie wielu interfejsów (327)
- Konflikty nazw (328)
- Dziedziczenie interfejsów (331)
- Ćwiczenia do samodzielnego wykonania (333)
- Klasy zagnieżdżone (334)
- Lekcja 33. Klasa wewnątrz klasy (334)
- Tworzenie klas zagnieżdżonych (334)
- Kilka klas zagnieżdżonych (336)
- Składowe klas zagnieżdżonych (338)
- Obiekty klas zagnieżdżonych (339)
- Rodzaje klas wewnętrznych (342)
- Dostęp do składowych klasy zewnętrznej (344)
- Ćwiczenia do samodzielnego wykonania (345)
- Typy uogólnione (346)
- Lekcja 34. Kontrola typów i typy uogólnione (346)
- Jak zbudować kontener? (346)
- Przechowywanie dowolnych danych (350)
- Problem kontroli typów (352)
- Korzystanie z typów uogólnionych (353)
- Ćwiczenia do samodzielnego wykonania (356)
Rozdział 7. Aplikacje z interfejsem graficznym (359)
- Lekcja 35. Tworzenie okien (359)
- Pierwsze okno (359)
- Klasa Form (361)
- Tworzenie menu (366)
- Ćwiczenia do samodzielnego wykonania (370)
- Lekcja 36. Delegacje i zdarzenia (371)
- Koncepcja zdarzeń i delegacji (371)
- Tworzenie delegacji (371)
- Delegacja jako funkcja zwrotna (375)
- Delegacja powiązana z wieloma metodami (379)
- Zdarzenia (381)
- Ćwiczenia do samodzielnego wykonania (391)
- Lekcja 37. Komponenty graficzne (392)
- Wyświetlanie komunikatów (392)
- Obsługa zdarzeń (393)
- Menu (395)
- Etykiety (397)
- Przyciski (399)
- Pola tekstowe (401)
- Listy rozwijane (404)
- Ćwiczenia do samodzielnego wykonania (407)
Zakończenie (409)
Skorowidz (410)
Najniższa cena z 30 dni przed obniżką 44,25zł
|
