Java to język przeznaczony do realizacji najtrudniejszych programistycznych zadań. Świetnie sprawdza się wszędzie tam, gdzie wymagane są najwyższa wydajność, niezawodność i bezpieczeństwo. Dzięki jasno sprecyzowanym zasadom, przejrzystej składni i silnemu typowaniu jest językiem łatwym w nauce i odpornym na błędy początkujących programistów. Java ma jeszcze jedną zaletę — programiści znający ten język są poszukiwani na rynku pracy w każdej ilości. Chcesz dołączyć do tego grona?

To nie jest trudne! Na początek wystarczy Ci ta książka. Dzięki niej wejdziesz w świat Javy, klas, obiektów, polimorfizmu… Poznasz zalety i wady tego języka oraz to, jak wypada on na tle konkurencyjnych rozwiązań. Następnie zaznajomisz się ze składnią, typami danych, strukturą programu oraz mechanizmem wyjątków. Kolejne rozdziały zawierają bezcenne informacje na temat tworzenia interfejsu użytkownika, dokumentowania kodu i radzenia sobie z typowymi problemami. Ta książka gwarantuje bezbolesne rozpoczęcie przygody z językiem Java!

Zaprojektowana do łatwej nauki!

• Kluczowe umiejętności i koncepcje przedstawione na początku każdego rozdziału
• Ekspert odpowiada, czyli pytania i odpowiedzi zawierające dodatkowe informacje oraz pomocne wskazówki
• Przykłady i projekty, czyli ćwiczenia demonstrujące, jak wykorzystać w praktyce zdobyte umiejętności
• Testy sprawdzające, czyli pytania i zadania na końcu każdego rozdziału, pozwalające sprawdzić wiedzę
• Składnia ze wskazówkami, czyli przykłady kodu z komentarzami opisującymi wykorzystywane techniki programowania

Osoby które kupowały "Java. Przewodnik dla początkujących. Wydanie V", wybierały także:

• Wprowadzenie do Javy. Programowanie i struktury danych. Wydanie XII 193,23 zł, (59,90 zł -69%)
• Spring i Spring Boot. Kurs video. Testowanie aplikacji i bezpiecze 129,00 zł, (51,60 zł -60%)
• Metoda dziel i zwyci 89,00 zł, (35,60 zł -60%)
• JavaFX. Kurs video. Wzorce oraz typy generyczne 79,00 zł, (31,60 zł -60%)
• Platforma Xamarin. Kurs video. Poziom drugi. Zaawansowane techniki tworzenia aplikacji cross-platform 99,00 zł, (39,60 zł -60%)

Spis treści

Java. Przewodnik dla początkujących. Wydanie V -- spis treści

O autorze (11)

O redaktorze technicznym (11)

Wstęp (13)

Rozdział 1. Podstawy Javy (19)

• Pochodzenie Javy (20)
  
  • Java a języki C i C++ (21)
  • Java a C# (22)
• Java a Internet (22)
  
  • Aplety Java (22)
  • Bezpieczeństwo (23)
  • Przenośność (23)
• Magiczny kod bajtowy (24)
  
• Terminologia Javy (25)
  
• Programowanie obiektowe (26)
  
  • Hermetyzacja (27)
  • Polimorfizm (28)
  • Dziedziczenie (28)
• Java Development Kit (29)
  
• Pierwszy prosty program (30)
  
  • Wprowadzenie tekstu programu (30)
  • Kompilowanie programu (31)
  • Pierwszy program wiersz po wierszu (31)
• Obsługa błędów składni (34)
  
• Drugi prosty program (35)
  
• Inne typy danych (37)
  
• Przykład 1.1. Zamiana galonów na litry (38)
  
• Dwie instrukcje sterujące (39)
  
  • Instrukcja if (40)
  • Pętla for (41)
• Bloki kodu (43)
  
• Średnik i pozycja kodu w wierszu (44)
  
• Wcięcia (45)
  
• Przykład 1.2. Ulepszony konwerter galonów na litry (45)
  
• Słowa kluczowe języka Java (46)
  
• Identyfikatory (47)
  
• Biblioteki klas (48)
  
• Test sprawdzający (48)

Rozdział 2. Typy danych i operatory (49)

• Dlaczego typy danych są tak ważne (50)
  
• Typy podstawowe (50)
  
  • Typy całkowite (51)
  • Typy zmiennoprzecinkowe (52)
  • Znaki (53)
• Typ logiczny (54)
  
• Przykład 2.1. Jak daleko uderzył piorun? (55)
  
• Literały (56)
  
  • Literały szesnastkowe, ósemkowe i binarne (57)
  • Specjalne sekwencje znaków (57)
  • Literały łańcuchowe (58)
• Zmienne (59)
  
  • Inicjalizacja zmiennej (59)
  • Dynamiczna inicjalizacja (60)
• Zasięg deklaracji i czas istnienia zmiennych (60)
  
• Operatory (63)
  
• Operatory arytmetyczne (63)
  
  • Inkrementacja i dekrementacja (65)
• Operatory relacyjne i logiczne (66)
  
• Warunkowe operatory logiczne (67)
  
• Operator przypisania (69)
  
• Skrótowe operatory przypisania (69)
  
• Konwersje typów w instrukcjach przypisania (71)
  
• Rzutowanie typów niezgodnych (72)
  
• Priorytet operatorów (74)
  
• Przykład 2.2. Tabela prawdy dla operatorów logicznych (74)
  
• Wyrażenia (75)
  
  • Konwersja typów w wyrażeniach (76)
  • Odstępy i nawiasy (77)
• Test sprawdzający (78)

Rozdział 3. Instrukcje sterujące (79)

• Wprowadzanie znaków z klawiatury (79)
  
• Instrukcja if (81)
  
• Zagnieżdżanie instrukcji if (82)
  
• Drabinka if-else-if (83)
  
• Instrukcja switch (84)
  
• Zagnieżdżanie instrukcji switch (88)
  
• Przykład 3.1. Rozpoczynamy budowę systemu pomocy (88)
  
• Pętla for (90)
  
• Wariacje na temat pętli for (92)
  
• Brakujące elementy (93)
  
  • Pętla nieskończona (94)
• Pętle bez ciała (94)
  
• Deklaracja zmiennych sterujących wewnątrz pętli (95)
  
• Rozszerzona pętla for (96)
  
• Pętla while (96)
  
• Pętla do-while (97)
  
• Przykład 3.2. Ulepszamy system pomocy (99)
  
• Przerywanie pętli instrukcją break (102)
  
• Zastosowanie break jako formy goto (104)
  
• Zastosowanie instrukcji continue (108)
  
• Przykład 3.3. Końcowa wersja systemu pomocy (109)
  
• Pętle zagnieżdżone (112)
  
• Test sprawdzający (113)

Rozdział 4. Wprowadzenie do klas, obiektów i metod (115)

• Podstawy klas (116)
  
  • Ogólna postać klasy (116)
  • Definiowanie klasy (117)
• Jak powstają obiekty (120)
  
• Referencje obiektów i operacje przypisania (120)
  
• Metody (121)
  
  • Dodajemy metodę do klasy Vehicle (122)
• Powrót z metody (124)
  
• Zwracanie wartości (125)
  
• Stosowanie parametrów (127)
  
  • Dodajemy sparametryzowaną metodę do klasy Vehicle (128)
• Przykład 4.1. System pomocy jako klasa (130)
  
• Konstruktory (135)
  
• Konstruktory z parametrami (136)
  
• Dodajemy konstruktor do klasy Vehicle (137)
  
• Operator new (138)
  
• Odzyskiwanie nieużytków i metoda finalize() (139)
  
• Metoda finalize() (139)
  
• Przykład 4.2. Ilustracja działania odzyskiwania nieużytków i metody finalize() (140)
  
• Słowo kluczowe this (142)
  
• Test sprawdzający (144)

Rozdział 5. Więcej typów danych i operatorów (145)

• Tablice (145)
  
  • Tablice jednowymiarowe (146)
• Przykład 5.1. Sortowanie tablicy (149)
  
• Tablice wielowymiarowe (151)
  
  • Tablice dwuwymiarowe (151)
• Tablice nieregularne (152)
  
  • Tablice o trzech i więcej wymiarach (153)
  • Inicjalizacja tablic wielowymiarowych (153)
• Alternatywna składnia deklaracji tablic (155)
  
• Przypisywanie referencji tablic (155)
  
• Wykorzystanie składowej length (156)
  
• Przykład 5.2. Klasa Queue (158)
  
• Styl for-each pętli for (162)
  
  • Iteracje w tablicach wielowymiarowych (165)
  • Zastosowania rozszerzonej pętli for (166)
• Łańcuchy znaków (167)
  
  • Tworzenie łańcuchów (167)
  • Operacje na łańcuchach (168)
  • Tablice łańcuchów (170)
  • Łańcuchy są niezmienne (171)
  • Łańcuchy sterujące instrukcją switch (172)
• Wykorzystanie argumentów wywołania programu (173)
  
• Operatory bitowe (175)
  
  • Operatory bitowe AND, OR, XOR i NOT (175)
  • Operatory przesunięcia (179)
  • Skrótowe bitowe operatory przypisania (181)
• Przykład 5.3. Klasa ShowBits (182)
  
• Operator ? (184)
  
• Test sprawdzający (186)

Rozdział 6. Więcej o metodach i klasach (189)

• Kontrola dostępu do składowych klasy (189)
  
  • Modyfikatory dostępu w Javie (190)
• Przykład 6.1. Ulepszamy klasę Queue (194)
  
• Przekazywanie obiektów metodom (195)
  
  • Sposób przekazywania argumentów (196)
• Zwracanie obiektów (199)
  
• Przeciążanie metod (201)
  
• Przeciążanie konstruktorów (205)
  
• Przykład 6.2. Przeciążamy konstruktor klasy Queue (207)
  
• Rekurencja (210)
  
• Słowo kluczowe static (212)
  
  • Bloki static (215)
• Przykład 6.3. Algorytm Quicksort (216)
  
• Klasy zagnieżdżone i klasy wewnętrzne (218)
  
• Zmienne liczby argumentów (221)
  
  • Metody o zmiennej liczbie argumentów (222)
  • Przeciążanie metod o zmiennej liczbie argumentów (225)
  • Zmienna liczba argumentów i niejednoznaczność (226)
• Test sprawdzający (227)

Rozdział 7. Dziedziczenie (229)

• Podstawy dziedziczenia (230)
  
• Dostęp do składowych a dziedziczenie (232)
  
• Konstruktory i dziedziczenie (235)
  
• Użycie słowa kluczowego super do wywołania konstruktora klasy bazowej (237)
  
• Użycie słowa kluczowego super do dostępu do składowych klasy bazowej (240)
  
• Przykład 7.1. Tworzymy hierarchię klas Vehicle (241)
  
• Wielopoziomowe hierarchie klas (244)
  
• Kiedy wywoływane są konstruktory? (247)
  
• Referencje klasy bazowej i obiekty klasy pochodnej (248)
  
• Przesłanianie metod (252)
  
• Przesłanianie metod i polimorfizm (255)
  
• Po co przesłaniać metody? (257)
  
  • Zastosowanie przesłaniania metod w klasie TwoDShape (257)
• Klasy abstrakcyjne (260)
  
• Słowo kluczowe final (264)
  
  • final zapobiega przesłanianiu (264)
  • final zapobiega dziedziczeniu (265)
  • Użycie final dla zmiennych składowych (265)
• Klasa Object (267)
  
• Test sprawdzający (268)

Rozdział 8. Pakiety i interfejsy (269)

• Pakiety (269)
  
  • Definiowanie pakietu (270)
  • Wyszukiwanie pakietów i zmienna CLASSPATH (271)
  • Prosty przykład pakietu (272)
• Pakiety i dostęp do składowych (273)
  
  • Przykład dostępu do pakietu (274)
• Składowe protected (275)
  
• Import pakietów (277)
  
• Biblioteka klas Java używa pakietów (279)
  
• Interfejsy (279)
  
• Implementacje interfejsów (281)
  
• Referencje interfejsu (284)
  
• Przykład 8.1. Tworzymy interfejs Queue (286)
  
• Zmienne w interfejsach (290)
  
• Interfejsy mogą dziedziczyć (291)
  
• Test sprawdzający (293)

Rozdział 9. Obsługa wyjątków (295)

• Hierarchia wyjątków (296)
  
• Podstawy obsługi wyjątków (296)
  
  • Słowa kluczowe try i catch (297)
  • Prosty przykład wyjątku (298)
• Konsekwencje nieprzechwycenia wyjątku (300)
  
  • Wyjątki umożliwiają obsługę błędów (301)
  • Użycie wielu klauzul catch (302)
• Przechwytywanie wyjątków klas pochodnych (303)
  
• Zagnieżdżanie bloków try (304)
  
• Generowanie wyjątku (305)
  
  • Powtórne generowanie wyjątku (306)
• Klasa Throwable (307)
  
• Klauzula finally (309)
  
• Użycie klauzuli throws (311)
  
• Nowości w JDK 7 (312)
  
• Wyjątki wbudowane w Javę (313)
  
• Tworzenie klas pochodnych wyjątków (315)
  
• Przykład 9.1. Wprowadzamy wyjątki w klasie Queue (317)
  
• Test sprawdzający (320)

Rozdział 10. Obsługa wejścia i wyjścia (323)

• Strumienie wejścia i wyjścia (324)
  
• Strumienie bajtowe i strumienie znakowe (324)
  
• Klasy strumieni bajtowych (325)
  
• Klasy strumieni znakowych (326)
  
• Strumienie predefiniowane (326)
  
• Używanie strumieni bajtowych (327)
  
  • Odczyt wejścia konsoli (328)
  • Zapis do wyjścia konsoli (329)
• Odczyt i zapis plików za pomocą strumieni bajtowych (330)
  
  • Odczyt z pliku (330)
  • Zapis w pliku (334)
• Automatyczne zamykanie pliku (336)
  
• Odczyt i zapis danych binarnych (339)
  
• Przykład 10.1. Narzędzie do porównywania plików (341)
  
• Pliki o dostępie swobodnym (343)
  
• Strumienie znakowe (345)
  
  • Odczyt konsoli za pomocą strumieni znakowych (345)
  • Obsługa wyjścia konsoli za pomocą strumieni znakowych (349)
• Obsługa plików za pomocą strumieni znakowych (350)
  
  • Klasa FileWriter (350)
  • Klasa FileReader (351)
• Zastosowanie klas opakowujących do konwersji łańcuchów numerycznych (352)
  
• Przykład 10.2. System pomocy wykorzystujący pliki (355)
  
• Test sprawdzający (361)

Rozdział 11. Programowanie wielowątkowe (363)

• Podstawy wielowątkowości (364)
  
• Klasa Thread i interfejs Runnable (365)
  
• Tworzenie wątku (365)
  
  • Drobne usprawnienia (369)
• Przykład 11.1. Tworzymy klasę pochodną klasy Thread (370)
  
• Tworzenie wielu wątków (372)
  
• Jak ustalić, kiedy wątek zakończył działanie? (375)
  
• Priorytety wątków (378)
  
• Synchronizacja (380)
  
• Synchronizacja metod (381)
  
• Synchronizacja instrukcji (384)
  
• Komunikacja międzywątkowa (386)
  
  • Przykład użycia metod wait() i notify() (387)
• Wstrzymywanie, wznawianie i kończenie działania wątków (392)
  
• Przykład 11.2. Wykorzystanie głównego wątku (396)
  
• Test sprawdzający (397)

Rozdział 12. Typy wyliczeniowe, automatyczne opakowywanie, import składowych statycznych i adnotacje (399)

• Wyliczenia (400)
  
  • Podstawy wyliczeń (400)
• Wyliczenia są klasami (403)
  
• Metody values() i valueOf() (403)
  
• Konstruktory, metody, zmienne instancji a wyliczenia (404)
  
  • Dwa ważne ograniczenia (406)
• Typy wyliczeniowe dziedziczą po klasie Enum (406)
  
• Przykład 12.1. Komputerowo sterowana sygnalizacja świetlna (408)
  
• Automatyczne opakowywanie (413)
  
• Typy opakowujące (413)
  
• Podstawy automatycznego opakowywania (415)
  
• Automatyczne opakowywanie i metody (416)
  
• Automatyczne opakowywanie i wyrażenia (418)
  
  • Przestroga (419)
• Import składowych statycznych (420)
  
• Adnotacje (metadane) (422)
  
• Test sprawdzający (425)

Rozdział 13. Generyczność (427)

• Podstawy generyczności (428)
  
• Prosty przykład generyczności (428)
  
  • Generyczność dotyczy tylko obiektów (432)
  • Typy generyczne różnią się dla różnych argumentów (432)
  • Klasa generyczna o dwóch parametrach (433)
  • Ogólna postać klasy generycznej (434)
• Ograniczanie typów (434)
  
• Stosowanie argumentów wieloznacznych (438)
  
• Ograniczanie argumentów wieloznacznych (440)
  
• Metody generyczne (443)
  
• Konstruktory generyczne (445)
  
• Interfejsy generyczne (445)
  
• Przykład 13.1. Generyczna klasa Queue (448)
  
• Typy surowe i tradycyjny kod (452)
  
• Wnioskowanie typów i operator diamentowy (455)
  
• Wymazywanie (456)
  
• Błędy niejednoznaczności (457)
  
• Ograniczenia związane z generycznością (458)
  
  • Zakaz tworzenia instancji parametru określającego typ (458)
  • Ograniczenia dla składowych statycznych (458)
  • Ograniczenia tablic generycznych (459)
  • Ograniczenia związane z wyjątkami (460)
• Dalsze studiowanie zagadnienia generyczności (460)
  
• Test sprawdzający (461)

Rozdział 14. Aplety, zdarzenia i pozostałe słowa kluczowe (463)

• Podstawy apletów (464)
  
• Organizacja apletów i podstawowe elementy (467)
  
• Architektura apletu (467)
  
• Kompletny szkielet apletu (468)
  
• Rozpoczęcie i zakończenie działania apletu (469)
  
• Żądanie odrysowania (470)
  
  • Metoda update() (471)
• Przykład 14.1. Prosty aplet wyświetlający baner (471)
  
• Wykorzystanie okna statusu (475)
  
• Parametry apletów (475)
  
• Klasa Applet (477)
  
• Obsługa zdarzeń (479)
  
• Model delegacji zdarzeń (479)
  
• Zdarzenia (479)
  
  • Źródła zdarzeń (479)
  • Słuchacze zdarzeń (480)
  • Klasy zdarzeń (480)
  • Interfejsy słuchaczy zdarzeń (480)
• Wykorzystanie modelu delegacji zdarzeń (481)
  
  • Obsługa zdarzeń myszy (482)
  • Prosty aplet obsługujący zdarzenia myszy (483)
• Inne słowa kluczowe Javy (486)
  
  • Modyfikatory transient i volatile (486)
  • Operator instanceof (486)
  • Słowo kluczowe strictfp (487)
  • Słowo kluczowe assert (487)
  • Metody natywne (488)
• Test sprawdzający (490)

Rozdział 15. Wprowadzenie do Swing (491)

• Pochodzenie i filozofia Swing (492)
  
• Komponenty i kontenery (494)
  
  • Komponenty (494)
  • Kontenery (495)
  • Panele kontenerów szczytowych (495)
• Menedżery układu (496)
  
• Pierwszy program wykorzystujący Swing (497)
  
  • Pierwszy program Swing wiersz po wierszu (498)
• Komponent JButton (502)
  
• Komponent JTextField (506)
  
• Komponent JCheckBox (509)
  
• Komponent JList (512)
  
• Przykład 15.1. Porównywanie plików - aplikacja Swing (516)
  
• Wykorzystanie anonimowych klas wewnętrznych do obsługi zdarzeń (521)
  
• Aplety Swing (522)
  
• Co dalej? (524)
  
• Test sprawdzający (525)

Dodatek A: Rozwiązania testów sprawdzających (527)

• Rozdział 1. Podstawy Javy (527)
  
• Rozdział 2. Typy danych i operatory (529)
  
• Rozdział 3. Instrukcje sterujące (531)
  
• Rozdział 4. Wprowadzenie do klas, obiektów i metod (533)
  
• Rozdział 5. Więcej typów danych i operatorów (535)
  
• Rozdział 6. Więcej o metodach i klasach (538)
  
• Rozdział 7. Dziedziczenie (543)
  
• Rozdział 8. Pakiety i interfejsy (545)
  
• Rozdział 9. Obsługa wyjątków (546)
  
• Rozdział 10. Obsługa wejścia i wyjścia (549)
  
• Rozdział 11. Programowanie wielowątkowe (552)
  
• Rozdział 12. Typy wyliczeniowe, automatyczne opakowywanie, import składowych statycznych i adnotacje (554)
  
• Rozdział 13. Generyczność (558)
  
• Rozdział 14. Aplety, zdarzenia i pozostałe słowa kluczowe (562)
  
• Rozdział 15. Wprowadzenie do Swing (567)

Dodatek B: Komentarze dokumentacyjne (573)

• Znaczniki javadoc (573)
  
  • @author (574)
  • {@code} (575)
  • @deprecated (575)
  • {@docRoot} (575)
  • @exception (575)
  • {@inheritDoc} (575)
  • {@link} (575)
  • {@linkplain} (576)
  • {@literal} (576)
  • @param (576)
  • @return (576)
  • @see (576)
  • @serial (577)
  • @serialData (577)
  • @serialField (577)
  • @since (577)
  • @throws (577)
  • {@value} (578)
  • @version (578)
• Ogólna postać komentarza dokumentacyjnego (578)
  
• Wynik działania programu javadoc (579)
  
• Przykład użycia komentarzy dokumentacyjnych (579)

Skorowidz (581)