Java. Przewodnik dla początkujących. Wydanie VI

 
Java. Przewodnik dla początkujących. Wydanie VI
Zawiera darmowych rozdziałów: 22
Stron w książce: 568 Udostępniono darmowych stron: 26
Data wydania: 2015-08-28Przejdź na stronę księgarni
Czytano online: 1Cena książki drukowanej: 89,00 zł
Język wydania: PolishWydawnictwo: Helion
Pobierz pdfCzytaj Alt+1Czytaj online
( Alt+1 )

Poznaj i wykorzystaj możliwości języka Java!

Java to najczęściej wybierany język programowania do zadań specjalnych. Jeżeli Twój projekt wymaga najwyższego poziomu bezpieczeństwa, ogromnej wydajności oraz sprawdzonych rozwiązań, to wybór może być tylko jeden! Właśnie Java jest najczęściej używana do tworzenia zaawansowanych systemów bankowych oraz aplikacji do zarządzania przedsiębiorstwami i finansami. Ale czy sprawdzi się w typowym projekcie? Oczywiście!

Rozpocznij własną przygodę z tym popularnym językiem programowania korzystając z tej książki. Kolejne wydanie zostało poprawione i zaktualizowane o nowości ze świata Javy. Każda strona zawiera bezcenną wiedzę na temat składni języka, stosowanych w nim konstrukcji, programowania obiektowego i nie tylko. Sprawdzisz tu, jak obsługiwać wyjątki, korzystać ze strumieni oraz wątków. Jeżeli masz ambicję stworzyć atrakcyjny interfejs użytkownika z użyciem JavaFX, również będziesz usatysfakcjonowany znalezionymi w tej książce informacjami. Jest to doskonała lektura dla wszystkich osób chcących poznać Javę — jeden z najbardziej cenionych języków programowania.

Dzięki tej książce:

  • poznasz składnię oraz typowe konstrukcje języka Java
  • zdobędziesz wiedzę na temat programowania obiektowego
  • obsłużysz sytuacje wyjątkowe w Twojej aplikacji
  • wykorzystasz możliwości JavaFX
  • opanujesz ceniony język programowania

Herbert Schildt — autorytet w świecie programistów Javy, C, C++ oraz C#. Jest autorem bestsellerów poświęconych programowaniu w tych językach. Swoją uwagę koncentruje na językach programowania, interpreterach, kompilatorach oraz sterowaniu robotami. Bierze aktywny udział w procesie standaryzacji języków programowania.

...

O autorze (13)

O redaktorze technicznym (14)

Wstęp (15)

1. Podstawy Javy (19)

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

2. Typy danych i operatory (43)

  • Dlaczego typy danych są tak ważne (43)
  • Typy proste (44)
    • Typy całkowite (44)
    • Typy zmiennoprzecinkowe (45)
    • Znaki (46)
  • Typ logiczny (47)
  • Literały (49)
    • Literały szesnastkowe, ósemkowe i binarne (49)
    • Specjalne sekwencje znaków (49)
    • Literały łańcuchowe (50)
  • Zmienne (51)
    • Inicjalizacja zmiennej (51)
    • Dynamiczna inicjalizacja (51)
  • Zasięg deklaracji i czas istnienia zmiennych (52)
  • Operatory (54)
  • Operatory arytmetyczne (54)
    • Inkrementacja i dekrementacja (55)
  • Operatory relacyjne i logiczne (56)
  • Warunkowe operatory logiczne (58)
  • Operator przypisania (59)
  • Skrótowe operatory przypisania (59)
  • Konwersje typów w instrukcjach przypisania (60)
  • Rzutowanie typów niezgodnych (61)
  • Priorytet operatorów (63)
  • Wyrażenia (64)
    • Konwersja typów w wyrażeniach (64)
    • Odstępy i nawiasy (66)
  • Test sprawdzający (66)

3. Instrukcje sterujące (67)

  • Wprowadzanie znaków z klawiatury (67)
  • Instrukcja if (68)
  • Zagnieżdżanie instrukcji if (69)
  • Drabinka if-else-if (70)
  • Instrukcja switch (71)
  • Zagnieżdżanie instrukcji switch (74)
  • Pętla for (76)
  • Wariacje na temat pętli for (77)
  • Brakujące elementy (78)
    • Pętla nieskończona (79)
  • Pętle bez ciała (79)
  • Deklaracja zmiennych sterujących wewnątrz pętli (80)
  • Rozszerzona pętla for (80)
  • Pętla while (81)
  • Pętla do-while (82)
  • Przerywanie pętli instrukcją break (86)
  • Zastosowanie break jako formy goto (87)
  • Zastosowanie instrukcji continue (91)
  • Pętle zagnieżdżone (94)
  • Test sprawdzający (95)

4. Wprowadzenie do klas, obiektów i metod (97)

  • Podstawy klas (97)
    • Ogólna postać klasy (98)
    • Definiowanie klasy (98)
  • Jak powstają obiekty (101)
  • Referencje obiektów i operacje przypisania (101)
  • Metody (102)
    • Dodajemy metodę do klasy Vehicle (102)
  • Powrót z metody (104)
  • Zwracanie wartości (105)
  • Stosowanie parametrów (106)
    • Dodajemy sparametryzowaną metodę do klasy Vehicle (108)
  • Konstruktory (113)
  • Konstruktory z parametrami (114)
  • Dodajemy konstruktor do klasy Vehicle (115)
  • Operator new (116)
  • Odzyskiwanie pamięci i metoda finalize() (116)
  • Metoda finalize() (117)
  • Słowo kluczowe this (119)
  • Test sprawdzający (121)

5. Więcej typów danych i operatorów (123)

  • Tablice (123)
    • Tablice jednowymiarowe (124)
  • Tablice wielowymiarowe (128)
    • Tablice dwuwymiarowe (128)
  • Tablice nieregularne (129)
    • Tablice o trzech i więcej wymiarach (130)
    • Inicjalizacja tablic wielowymiarowych (130)
  • Alternatywna składnia deklaracji tablic (131)
  • Przypisywanie referencji tablic (131)
  • Wykorzystanie składowej length (132)
  • Styl for-each pętli for (137)
    • Iteracje w tablicach wielowymiarowych (139)
    • Zastosowania rozszerzonej pętli for (140)
  • Łańcuchy znaków (141)
    • Tworzenie łańcuchów (141)
    • Operacje na łańcuchach (142)
    • Tablice łańcuchów (144)
    • Łańcuchy są niezmienne (144)
    • Łańcuchy sterujące instrukcją switch (145)
  • Wykorzystanie argumentów wywołania programu (146)
  • Operatory bitowe (147)
    • Operatory bitowe AND, OR, XOR i NOT (147)
    • Operatory przesunięcia (151)
    • Skrótowe bitowe operatory przypisania (153)
  • Operator ? (155)
  • Test sprawdzający (157)

6. Więcej o metodach i klasach (159)

  • Kontrola dostępu do składowych klasy (159)
    • Modyfikatory dostępu w Javie (160)
  • Przekazywanie obiektów do metod (164)
    • Sposób przekazywania argumentów (165)
  • Zwracanie obiektów (167)
  • Przeciążanie metod (169)
  • Przeciążanie konstruktorów (173)
  • Rekurencja (177)
  • Słowo kluczowe static (178)
    • Bloki static (181)
  • Klasy zagnieżdżone i klasy wewnętrzne (184)
  • Zmienne liczby argumentów (186)
    • Metody o zmiennej liczbie argumentów (187)
    • Przeciążanie metod o zmiennej liczbie argumentów (189)
    • Zmienna liczba argumentów i niejednoznaczność (190)
  • Test sprawdzający (191)

7. Dziedziczenie (193)

  • Podstawy dziedziczenia (193)
  • Dostęp do składowych a dziedziczenie (196)
  • Konstruktory i dziedziczenie (198)
  • Użycie słowa kluczowego super do wywołania konstruktora klasy bazowej (199)
  • Użycie słowa kluczowego super do dostępu do składowych klasy bazowej (203)
  • Wielopoziomowe hierarchie klas (206)
  • Kiedy wywoływane są konstruktory? (208)
  • Referencje klasy bazowej i obiekty klasy pochodnej (209)
  • Przesłanianie metod (213)
  • Przesłanianie metod i polimorfizm (215)
  • Po co przesłaniać metody? (216)
    • Zastosowanie przesłaniania metod w klasie TwoDShape (217)
  • Klasy abstrakcyjne (220)
  • Słowo kluczowe final (223)
    • final zapobiega przesłanianiu (223)
    • final zapobiega dziedziczeniu (223)
    • Użycie final dla zmiennych składowych (224)
  • Klasa Object (225)
  • Test sprawdzający (226)

8. Pakiety i interfejsy (227)

  • Pakiety (227)
    • Definiowanie pakietu (228)
    • Wyszukiwanie pakietów i zmienna CLASSPATH (228)
    • Prosty przykład pakietu (229)
  • Pakiety i dostęp do składowych (230)
    • Przykład dostępu do pakietu (230)
  • Składowe chronione (232)
  • Import pakietów (234)
  • Biblioteka klas Java używa pakietów (235)
  • Interfejsy (235)
  • Implementacje interfejsów (237)
  • Referencje interfejsu (239)
  • Zmienne w interfejsach (245)
  • Interfejsy mogą dziedziczyć (246)
  • Domyślne metody interfejsów (246)
    • Podstawowe informacje o metodach domyślnych (247)
    • Praktyczny przykład metody domyślnej (249)
    • Problemy wielokrotnego dziedziczenia (250)
  • Stosowanie metod statycznych w interfejsach (251)
    • Ostatnie uwagi o pakietach i interfejsach (252)
  • Test sprawdzający (252)

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

  • Hierarchia wyjątków (254)
  • Podstawy obsługi wyjątków (254)
    • Słowa kluczowe try i catch (254)
    • Prosty przykład wyjątku (255)
  • Konsekwencje nieprzechwycenia wyjątku (257)
    • Wyjątki umożliwiają obsługę błędów (258)
    • Użycie wielu klauzul catch (259)
  • Przechwytywanie wyjątków klas pochodnych (259)
  • Zagnieżdżanie bloków try (261)
  • Generowanie wyjątku (262)
    • Powtórne generowanie wyjątku (262)
  • Klasa Throwable (263)
  • Klauzula finally (265)
  • Użycie klauzuli throws (266)
  • Trzy ostatnio dodane możliwości wyjątków (267)
  • Wyjątki wbudowane w Javę (268)
  • Tworzenie klas pochodnych wyjątków (270)
  • Test sprawdzający (274)

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

  • Strumienie wejścia i wyjścia (276)
  • Strumienie bajtowe i strumienie znakowe (276)
  • Klasy strumieni bajtowych (276)
  • Klasy strumieni znakowych (276)
  • Strumienie predefiniowane (277)
  • Używanie strumieni bajtowych (278)
    • Odczyt wejścia konsoli (278)
    • Zapis do wyjścia konsoli (280)
  • Odczyt i zapis plików za pomocą strumieni bajtowych (281)
    • Odczyt z pliku (281)
    • Zapis w pliku (284)
  • Automatyczne zamykanie pliku (285)
  • Odczyt i zapis danych binarnych (288)
  • Pliki o dostępie swobodnym (291)
  • Strumienie znakowe (293)
    • Odczyt konsoli za pomocą strumieni znakowych (293)
    • Obsługa wyjścia konsoli za pomocą strumieni znakowych (297)
  • Obsługa plików za pomocą strumieni znakowych (298)
    • Klasa FileWriter (298)
    • Klasa FileReader (299)
  • Zastosowanie klas opakowujących do konwersji łańcuchów numerycznych (299)
  • Test sprawdzający (307)

11. Programowanie wielowątkowe (309)

  • Podstawy wielowątkowości (309)
  • Klasa Thread i interfejs Runnable (310)
  • Tworzenie wątku (310)
    • Drobne usprawnienia (313)
  • Tworzenie wielu wątków (317)
  • Jak ustalić, kiedy wątek zakończył działanie? (319)
  • Priorytety wątków (321)
  • Synchronizacja (324)
  • Synchronizacja metod (324)
  • Synchronizacja instrukcji (327)
  • Komunikacja międzywątkowa (328)
    • Przykład użycia metod wait() i notify() (329)
  • Wstrzymywanie, wznawianie i kończenie działania wątków (333)
  • Test sprawdzający (338)

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

  • Wyliczenia (340)
    • Podstawy wyliczeń (340)
  • Wyliczenia są klasami (342)
  • Metody values() i valueOf() (342)
  • Konstruktory, metody, zmienne instancji a wyliczenia (343)
    • Dwa ważne ograniczenia (345)
  • Typy wyliczeniowe dziedziczą po klasie Enum (345)
  • Automatyczne opakowywanie (351)
  • Typy opakowujące (351)
  • Podstawy automatycznego opakowywania (352)
  • Automatyczne opakowywanie i metody (353)
  • Automatyczne opakowywanie i wyrażenia (354)
    • Przestroga (356)
  • Import składowych statycznych (356)
  • Adnotacje (metadane) (358)
  • Test sprawdzający (361)

13. Typy sparametryzowane (363)

  • Podstawy typów sparametryzowanych (364)
  • Prosty przykład typów sparametryzowanych (364)
    • Parametryzacja dotyczy tylko typów obiektowych (367)
    • Typy sparametryzowane różnią się dla różnych argumentów (367)
    • Klasa sparametryzowana o dwóch parametrach (368)
    • Ogólna postać klasy sparametryzowanej (369)
  • Ograniczanie typów (369)
  • Stosowanie argumentów wieloznacznych (372)
  • Ograniczanie argumentów wieloznacznych (374)
  • Metody sparametryzowane (376)
  • Konstruktory sparametryzowane (378)
  • Interfejsy sparametryzowane (378)
  • Typy surowe i tradycyjny kod (384)
  • Wnioskowanie typów i operator diamentowy (387)
  • Wymazywanie (388)
  • Błędy niejednoznaczności (388)
  • Ograniczenia związane z typami sparametryzowanymi (389)
    • Zakaz tworzenia instancji parametru typu (389)
    • Ograniczenia dla składowych statycznych (389)
    • Ograniczenia tablic sparametryzowanych (390)
    • Ograniczenia związane z wyjątkami (391)
  • Dalsze studiowanie typów sparametryzowanych (391)
  • Test sprawdzający (391)

14. Wyrażenia lambda i referencje metod (393)

  • Przedstawienie wyrażeń lambda (394)
    • Podstawowe informacje o wyrażeniach lambda (394)
    • Interfejsy funkcyjne (395)
    • Wyrażenia lambda w działaniu (397)
    • Blokowe wyrażenia lambda (400)
  • Sparametryzowane interfejsy funkcyjne (401)
  • Wyrażenia lambda i przechwytywanie zmiennych (407)
  • Zgłaszanie wyjątków w wyrażeniach lambda (408)
  • Referencje metod (409)
    • Referencje metod statycznych (409)
    • Referencje metod instancyjnych (411)
  • Referencje konstruktorów (414)
  • Predefiniowane interfejsy funkcyjne (417)
  • Test sprawdzający (418)

15. Aplety, zdarzenia i pozostałe słowa kluczowe (421)

  • Podstawy apletów (422)
  • Organizacja apletów i podstawowe elementy (424)
  • Architektura apletu (424)
  • Kompletny szkielet apletu (425)
  • Rozpoczęcie i zakończenie działania apletu (426)
  • Żądanie odrysowania (426)
    • Metoda update() (427)
  • Wykorzystanie okna statusu (430)
  • Parametry apletów (431)
  • Klasa Applet (432)
  • Obsługa zdarzeń (433)
  • Model delegacji zdarzeń (433)
  • Zdarzenia (435)
    • Źródła zdarzeń (435)
    • Obiekty nasłuchujące (435)
    • Klasy zdarzeń (435)
    • Interfejsy obiektów nasłuchujących (436)
  • Wykorzystanie modelu delegacji zdarzeń (436)
    • Obsługa zdarzeń myszy (437)
    • Prosty aplet obsługujący zdarzenia myszy (438)
  • Inne słowa kluczowe Javy (440)
    • Modyfikatory transient i volatile (440)
    • Operator instanceof (441)
    • Słowo kluczowe strictfp (441)
    • Słowo kluczowe assert (441)
    • Metody natywne (442)
  • Test sprawdzający (443)

16. Wprowadzenie do Swing (445)

  • Pochodzenie i filozofia Swing (446)
  • Komponenty i kontenery (447)
    • Komponenty (448)
    • Kontenery (448)
    • Panele kontenerów szczytowych (448)
  • Menedżery układu (449)
  • Pierwszy program wykorzystujący Swing (450)
    • Pierwszy program Swing wiersz po wierszu (451)
  • Komponent JButton (454)
  • Komponent JTextField (457)
  • Komponent JCheckBox (459)
  • Komponent JList (462)
  • Wykorzystanie anonimowych klas wewnętrznych lub wyrażeń lambda do obsługi zdarzeń (470)
  • Aplety Swing (471)
  • Test sprawdzający (473)

17. Wprowadzenie do JavaFX (475)

  • Podstawowe pojęcia JavaFX (476)
    • Pakiety JavaFX (476)
    • Klasy Stage oraz Scene (476)
    • Węzły i graf sceny (477)
    • Układy (477)
    • Klasa Application oraz metody cyklu życia (477)
    • Uruchamianie aplikacji JavaFX (478)
  • Szkielet aplikacji JavaFX (478)
  • Kompilacja i uruchamianie programów JavaFX (481)
  • Wątek aplikacji (481)
  • Prosta kontrolka JavaFX: Label (481)
  • Stosowanie przycisków i zdarzeń (483)
    • Podstawy obsługi zdarzeń (484)
    • Przedstawienie kontrolki Button (484)
    • Przedstawienie obsługi zdarzeń i stosowania przycisków (485)
  • Trzy kolejne kontrolki JavaFX (487)
    • Pola wyboru (487)
    • Listy (491)
    • Pola tekstowe (495)
  • Przedstawienie efektów i transformacji (498)
    • Efekty (498)
    • Transformacje (500)
    • Prezentacja zastosowania efektów i transformacji (501)
  • Co dalej? (503)
  • Test sprawdzający (504)

A Rozwiązania testów sprawdzających (505)

  • Rozdział 1. Podstawy Javy (505)
  • Rozdział 2. Typy danych i operatory (507)
  • Rozdział 3. Instrukcje sterujące (508)
  • Rozdział 4. Wprowadzenie do klas, obiektów i metod (510)
  • Rozdział 5. Więcej typów danych i operatorów (511)
  • Rozdział 6. Więcej o metodach i klasach (514)
  • Rozdział 7. Dziedziczenie (518)
  • Rozdział 8. Pakiety i interfejsy (519)
  • Rozdział 9. Obsługa wyjątków (521)
  • Rozdział 10. Obsługa wejścia i wyjścia (523)
  • Rozdział 11. Programowanie wielowątkowe (526)
  • Rozdział 12. Typy wyliczeniowe, automatyczne opakowywanie, import składowych statycznych i adnotacje (528)
  • Rozdział 13. Typy sparametryzowane (531)
  • Rozdział 14. Wyrażenia lambda i referencje metod (534)
  • Rozdział 15. Aplety, zdarzenia i pozostałe słowa kluczowe (537)
  • Rozdział 16. Wprowadzenie do Swing (541)
  • Rozdział 17. Wprowadzenie do JavaFX (546)

B Komentarze dokumentacyjne (551)

  • Znaczniki javadoc (551)
    • @author (552)
    • {@code} (552)
    • @deprecated (552)
    • {@docRoot} (553)
    • @exception (553)
    • {@inheritDoc} (553)
    • {@link} (553)
    • {@linkplain} (553)
    • {@literal} (553)
    • @param (553)
    • @return (553)
    • @see (554)
    • @serial (554)
    • @serialData (554)
    • @serialField (554)
    • @since (554)
    • @throws (554)
    • {@value} (554)
    • @version (555)
  • Ogólna postać komentarza dokumentacyjnego (555)
  • Wynik działania programu javadoc (555)
  • Przykład użycia komentarzy dokumentacyjnych (555)

Skorowidz (557)

Informatyka » Java - Programowanie

https://facebook.com/wiedzanaplus
Alt + 9
Pomoc ( Alt + 0 )
Loading...