księgarnia informatyczna aton.pl

Java Podstawy Wydanie IX

Wydawnictwo HELION

Cena:    99.00zł

Java Podstawy Wydanie IX


Autor: Cay S. Horstmann, Gary Cornell

ISBN: 978-83-246-7758-0

Ilość stron: 864

Data wydania: 12/2013 (wydanie 9)

Oprawa: Twarda

Format: 164x239

Wydawnictwo: HELION


Wykorzystaj potencjał lidera na rynku języków programowania!

Pomimo zaawansowanego wieku Java wciąż jest na topie. Ten język programowania oraz narzędzia z nim powiązane są najczęściej wybierane do tworzenia rozbudowanych systemów informatycznych. Skąd ta popularność? Przejrzysta składnia, obsługa nowoczesnych technik przesyłania informacji, automatyczne czyszczenie pamięci to tylko niektóre z atutów Javy. Jeżeli dołożymy do tego ogromną rzeszę użytkowników chętnych do pomocy, wszystko staje się jasne. Java jeszcze długo będzie na świeczniku!

Kolejne wydanie tej cenionej książki zostało zaktualizowane o wszystkie nowości, które pojawiły się w wersji 7 platformy Java Standard Edition. W trakcie lektury poznasz składnię języka oraz wszystkie istotne kwestie związane z programowaniem w Javie. Zrozumiesz założenia programowania obiektowego, nauczysz się korzystać z interfejsów oraz obsługiwać wyjątki. Przekonasz się również, jakie ułatwienia w tym zakresie oferuje Java 7 - obsługa wielu wyjątków w ramach jednego bloku catch to tylko czubek góry lodowej. Książka ta jest idealną pozycją dla wszystkich osób chcących poznać język Java. Sprawdzi się ona również w rękach doświadczonych programistów - jako źródło informacji na temat nowości w Java Standard Edition 7.

Poznaj:

  • podstawy języka Java
  • zasady programowania obiektowego
  • zastosowanie interfejsów
  • nowości wprowadzone w ostatniej wersji Javy

Wykorzystaj siłę obiektów. Zacznij programować obiektowo w języku Java!

Spis treści:

Rozdział 1. Wstęp do Javy (21)

  • Java jako platforma programistyczna (21)
  • Słowa klucze białej księgi Javy (22)
    • Prosty (23)
    • Zorientowany obiektowo (23)
    • Sieciowy (24)
    • Niezawodny (24)
    • Bezpieczny (25)
    • Niezależny od architektury (26)
    • Przenośny (26)
    • Interpretowany (27)
    • Wysokowydajny (27)
    • Wielowątkowy (27)
    • Dynamiczny (28)
  • Aplety Javy i internet (28)
  • Krótka historia Javy (30)
  • Główne nieporozumienia dotyczące Javy (32)

Rozdział 2. Środowisko programistyczne Javy (37)

  • Instalacja oprogramowania Java Development Kit (38)
    • Pobieranie pakietu JDK (38)
    • Ustawianie ścieżki dostępu (40)
    • Instalacja bibliotek i dokumentacji (41)
    • Instalacja przykładowych programów (42)
    • Drzewo katalogów Javy (43)
  • Wybór środowiska programistycznego (44)
  • Używanie narzędzi wiersza poleceń (44)
    • Rozwiązywanie problemów (46)
  • Praca w zintegrowanym środowisku programistycznym (47)
    • Znajdowanie błędów kompilacji (50)
  • Uruchamianie aplikacji graficznej (51)
  • Tworzenie i uruchamianie apletów (53)

Rozdział 3. Podstawowe elementy języka Java (59)

  • Prosty program w Javie (60)
  • Komentarze (63)
  • Typy danych (64)
    • Typy całkowite (64)
    • Typy zmiennoprzecinkowe (65)
    • Typ char (66)
    • Typ boolean (68)
  • Zmienne (69)
    • Inicjacja zmiennych (70)
    • Stałe (70)
  • Operatory (71)
    • Operatory inkrementacji i dekrementacji (72)
    • Operatory relacyjne i logiczne (73)
    • Operatory bitowe (74)
    • Funkcje i stałe matematyczne (75)
    • Konwersja typów numerycznych (76)
    • Rzutowanie (77)
    • Nawiasy i priorytety operatorów (78)
    • Typ wyliczeniowy (79)
  • Łańcuchy (79)
    • Podłańcuchy (79)
    • Konkatenacja (80)
    • Łańcuchów nie można modyfikować (80)
    • Porównywanie łańcuchów (82)
    • Współrzędne kodowe znaków i jednostki kodowe (83)
    • API String (84)
    • Dokumentacja API w internecie (86)
    • Składanie łańcuchów (87)
  • Wejście i wyjście (90)
    • Odbieranie danych wejściowych (90)
    • Formatowanie danych wyjściowych (93)
    • Zapis do pliku i odczyt (97)
  • Przepływ sterowania (99)
    • Zasięg blokowy (99)
    • Instrukcje warunkowe (100)
    • Pętle (102)
    • Pętle o określonej liczbie powtórzeń (107)
    • Wybór wielokierunkowy - instrukcja switch (110)
    • Instrukcje przerywające przepływ sterowania (112)
  • Wielkie liczby (115)
  • Tablice (118)
    • Pętla typu for each (119)
    • Inicjowanie tablic i tworzenie tablic anonimowych (120)
    • Kopiowanie tablicy (120)
    • Parametry wiersza poleceń (122)
    • Sortowanie tablicy (123)
    • Tablice wielowymiarowe (127)
    • Tablice postrzępione (130)

Rozdział 4. Obiekty i klasy (133)

  • Wstęp do programowania zorientowanego obiektowo (134)
    • Klasy (134)
    • Obiekty (136)
    • Identyfikacja klas (136)
    • Relacje między klasami (137)
  • Używanie klas predefiniowanych (139)
    • Obiekty i zmienne obiektów (139)
    • Klasa GregorianCalendar (142)
    • Metody udostępniające i zmieniające wartość elementu (144)
  • Definiowanie własnych klas (150)
    • Klasa Employee (151)
    • Stosowanie kilku plików źródłowych (154)
    • Analiza klasy Employee (154)
    • Pierwsze kroki w tworzeniu konstruktorów (155)
    • Parametry jawne i niejawne (156)
    • Korzyści z hermetyzacji (157)
    • Przywileje klasowe (159)
    • Metody prywatne (160)
    • Stałe jako pola klasy (161)
  • Pola i metody statyczne (161)
    • Pola statyczne (161)
    • Stałe statyczne (162)
    • Metody statyczne (163)
    • Metody fabrykujące (164)
    • Metoda main (165)
  • Parametry metod (167)
  • Konstruowanie obiektów (173)
    • Przeciążanie (173)
    • Inicjacja pól wartościami domyślnymi (174)
    • Konstruktor domyślny (175)
    • Jawna inicjacja pól (175)
    • Nazywanie parametrów (176)
    • Wywoływanie innego konstruktora (177)
    • Bloki inicjujące (178)
    • Niszczenie obiektów i metoda finalize (182)
  • Pakiety (182)
    • Importowanie klas (183)
    • Importy statyczne (185)
    • Dodawanie klasy do pakietu (185)
    • Zasięg pakietów (188)
  • Ścieżka klas (190)
    • Ustawianie ścieżki klas (192)
  • Komentarze dokumentacyjne (193)
    • Wstawianie komentarzy (193)
    • Komentarze do klas (194)
    • Komentarze do metod (194)
    • Komentarze do pól (195)
    • Komentarze ogólne (195)
    • Komentarze do pakietów i ogólne (197)
    • Generowanie dokumentacji (197)
  • Porady dotyczące projektowania klas (198)

Rozdział 5. Dziedziczenie (201)

  • Klasy, nadklasy i podklasy (202)
    • Hierarchia dziedziczenia (208)
    • Polimorfizm (208)
    • Wiązanie dynamiczne (210)
    • Wyłączanie dziedziczenia - klasy i metody finalne (213)
    • Rzutowanie (214)
    • Klasy abstrakcyjne (216)
    • Dostęp chroniony (221)
  • Klasa bazowa Object (222)
    • Metoda equals (223)
    • Porównywanie a dziedziczenie (224)
    • Metoda hashCode (227)
    • Metoda toString (229)
  • Generyczne listy tablicowe (234)
    • Dostęp do elementów listy tablicowej (237)
    • Zgodność pomiędzy typowanymi a surowymi listami tablicowymi (241)
  • Osłony obiektów i autoboxing (242)
  • Metody ze zmienną liczbą parametrów (245)
  • Klasy wyliczeniowe (246)
  • Refleksja (248)
    • Klasa Class (249)
    • Podstawy przechwytywania wyjątków (251)
    • Zastosowanie refleksji w analizie funkcjonalności klasy (253)
    • Refleksja w analizie obiektów w czasie działania programu (258)
    • Zastosowanie refleksji w generycznym kodzie tablicowym (263)
    • Wskaźniki do metod (267)
  • Porady projektowe dotyczące dziedziczenia (270)

Rozdział 6. Interfejsy i klasy wewnętrzne (273)

  • Interfejsy (274)
    • Własności interfejsów (279)
    • Interfejsy a klasy abstrakcyjne (280)
  • Klonowanie obiektów (281)
  • Interfejsy a sprzężenie zwrotne (287)
  • Klasy wewnętrzne (290)
    • Dostęp do stanu obiektu w klasie wewnętrznej (292)
    • Specjalne reguły składniowe dotyczące klas wewnętrznych (295)
    • Czy klasy wewnętrzne są potrzebne i bezpieczne? (296)
    • Lokalne klasy wewnętrzne (298)
    • Dostęp do zmiennych finalnych z metod zewnętrznych (299)
    • Anonimowe klasy wewnętrzne (301)
    • Statyczne klasy wewnętrzne (304)
  • Klasy proxy (307)
    • Własności klas proxy (311)

Rozdział 7. Grafika (313)

  • Wprowadzenie do pakietu Swing (314)
  • Tworzenie ramki (317)
  • Pozycjonowanie ramki (320)
    • Własności ramek (322)
    • Określanie rozmiaru ramki (323)
  • Wyświetlanie informacji w komponencie (327)
  • Figury 2W (331)
  • Kolory (339)
  • Czcionki (343)
  • Wyświetlanie obrazów (351)

Rozdział 8. Obsługa zdarzeń (355)

  • Podstawy obsługi zdarzeń (355)
    • Przykład - obsługa kliknięcia przycisku (357)
    • Nabywanie biegłości w posługiwaniu się klasami wewnętrznymi (362)
    • Tworzenie słuchaczy zawierających jedno wywołanie metody (365)
    • Przykład - zmiana stylu (366)
    • Klasy adaptacyjne (370)
  • Akcje (374)
  • Zdarzenia generowane przez mysz (381)
  • Hierarchia zdarzeń w bibliotece AWT (388)
    • Zdarzenia semantyczne i niskiego poziomu (390)

Rozdział 9. Komponenty Swing interfejsu użytkownika (393)

  • Swing a wzorzec projektowy Model-View-Controller (394)
    • Wzorce projektowe (394)
    • Wzorzec Model-View-Controller (395)
    • Analiza MVC przycisków Swing (399)
  • Wprowadzenie do zarządzania rozkładem (400)
    • Rozkład brzegowy (403)
    • Rozkład siatkowy (405)
  • Wprowadzanie tekstu (409)
    • Pola tekstowe (409)
    • Etykiety komponentów (411)
    • Pola haseł (413)
    • Obszary tekstowe (413)
    • Panele przewijane (414)
  • Komponenty umożliwiające wybór opcji (417)
    • Pola wyboru (417)
    • Przełączniki (420)
    • Obramowanie (424)
    • Listy rozwijalne (428)
    • Suwaki (432)
  • Menu (438)
    • Tworzenie menu (439)
    • Ikony w elementach menu (441)
    • Pola wyboru i przełączniki jako elementy menu (442)
    • Menu podręczne (444)
    • Mnemoniki i akceleratory (445)
    • Aktywowanie i dezaktywowanie elementów menu (448)
    • Paski narzędzi (451)
    • Dymki (453)
  • Zaawansowane techniki zarządzania rozkładem (456)
    • Rozkład GridBagLayout (458)
    • Rozkład grupowy (468)
    • Nieużywanie żadnego zarządcy rozkładu (478)
    • Niestandardowi zarządcy rozkładu (479)
    • Kolejka dostępu (483)
  • Okna dialogowe (485)
    • Okna dialogowe opcji (485)
    • Tworzenie okien dialogowych (495)
    • Wymiana danych (500)
    • Okna dialogowe wyboru plików (506)
    • Okna dialogowe wyboru kolorów (517)

Rozdział 10. Przygotowywanie apletów i aplikacji do użytku (525)

  • Pliki JAR (526)
    • Manifest (526)
    • Wykonywalne pliki JAR (528)
    • Zasoby (529)
    • Pieczętowanie pakietów (532)
  • Java Web Start (533)
    • Sandbox (537)
    • Podpisywanie kodu (538)
    • API JNLP (539)
  • Aplety (548)
    • Prosty aplet (549)
    • Znacznik applet i jego atrybuty (553)
    • Znacznik object (557)
    • Parametry przekazujące informacje do apletów (557)
    • Dostęp do obrazów i plików audio (562)
    • Środowisko działania apletu (563)
  • Zapisywanie preferencji użytkownika (572)
    • Mapy własności (572)
    • API Preferences (577)

Rozdział 11. Wyjątki, dzienniki, asercje i debugowanie (585)

  • Obsługa błędów (586)
    • Klasyfikacja wyjątków (587)
    • Deklarowanie wyjątków kontrolowanych (589)
    • Zgłaszanie wyjątków (591)
    • Tworzenie klas wyjątków (593)
  • Przechwytywanie wyjątków (594)
    • Przechwytywanie wielu typów wyjątków (596)
    • Powtórne generowanie wyjątków i budowanie łańcuchów wyjątków (596)
    • Klauzula finally (597)
    • Analiza danych ze śledzenia stosu (601)
  • Wskazówki dotyczące stosowania wyjątków (604)
  • Asercje (607)
    • Włączanie i wyłączanie asercji (608)
    • Zastosowanie asercji w sprawdzaniu parametrów (608)
    • Zastosowanie asercji w dokumentacji założeń (610)
  • Dzienniki (611)
    • Podstawy zapisu do dziennika (611)
    • Zaawansowane techniki zapisu do dziennika (612)
    • Zmiana konfiguracji menedżera dzienników (614)
    • Lokalizacja (615)
    • Obiekty typu Handler (616)
    • Filtry (620)
    • Formatery (620)
    • Przepis na dziennik (620)
  • Wskazówki dotyczące debugowania (629)
    • Używanie okna konsoli (635)
    • Śledzenie zdarzeń AWT (636)
    • Zaprzęganie robota AWT do pracy (640)
  • Praca z debugerem (645)

Rozdział 12. Programowanie uogólnione (649)

  • Dlaczego programowanie uogólnione (650)
    • Dla kogo programowanie uogólnione (651)
  • Definicja prostej klasy uogólnionej (652)
  • Metody uogólnione (654)
  • Ograniczenia zmiennych typowych (655)
  • Kod uogólniony a maszyna wirtualna (657)
    • Translacja wyrażeń generycznych (659)
    • Translacja metod uogólnionych (660)
    • Używanie starego kodu (662)
  • Ograniczenia i braki (663)
    • Nie można podawać typów prostych jako parametrów typowych (663)
    • Sprawdzanie typów w czasie działania programu jest możliwe tylko dla typów surowych (663)
    • Obiektów klasy uogólnionej nie można generować ani przechwytywać (664)
    • Nie można tworzyć tablic typów uogólnionych (665)
    • Nie wolno tworzyć egzemplarzy zmiennych typowych (665)
    • Zmiennych typowych nie można używać w statycznych kontekstach klas uogólnionych (667)
    • Uważaj na konflikty, które mogą powstać po wymazaniu typów (667)
  • Zasady dziedziczenia dla typów uogólnionych (668)
  • Typy wieloznaczne (671)
    • Ograniczenia nadtypów typów wieloznacznych (672)
    • Typy wieloznaczne bez ograniczeń (674)
    • Chwytanie typu wieloznacznego (675)
  • Refleksja a typy uogólnione (679)
    • Zastosowanie parametrów Class do dopasowywania typów (680)
    • Informacje o typach generycznych w maszynie wirtualnej (680)

Rozdział 13. Kolekcje (687)

  • Interfejsy kolekcyjne (687)
    • Oddzielenie warstwy interfejsów od warstwy klas konkretnych (688)
    • Interfejsy Collection i Iterator (690)
  • Konkretne klasy kolekcyjne (696)
    • Listy powiązane (696)
    • Listy tablicowe (706)
    • Zbiór HashSet (706)
    • Zbiór TreeSet (710)
    • Porównywanie obiektów (711)
    • Kolejki Queue i Deque (717)
    • Kolejki priorytetowe (718)
    • Mapy (719)
    • Specjalne klasy Set i Map (724)
  • Architektura kolekcji (729)
    • Widoki i obiekty opakowujące (733)
    • Operacje zbiorcze (739)
    • Konwersja pomiędzy kolekcjami a tablicami (740)
  • Algorytmy (741)
    • Sortowanie i tasowanie (742)
    • Wyszukiwanie binarne (745)
    • Proste algorytmy (746)
    • Pisanie własnych algorytmów (748)
  • Stare kolekcje (749)
    • Klasa Hashtable (749)
    • Wyliczenia (750)
    • Mapy własności (751)
    • Stosy (751)
    • Zbiory bitów (752)

Rozdział 14. Wielowątkowość (757)

  • Czym są wątki (758)
    • Wykonywanie zadań w osobnych wątkach (763)
  • Przerywanie wątków (769)
  • Stany wątków (771)
    • Wątki NEW (772)
    • Wątki RUNNABLE (772)
    • Wątki BLOCKED i WAITING (773)
    • Zamykanie wątków (773)
  • Własności wątków (775)
    • Priorytety wątków (775)
    • Wątki demony (776)
    • Procedury obsługi nieprzechwyconych wyjątków (777)
  • Synchronizacja (778)
    • Przykład sytuacji powodującej wyścig (778)
    • Wyścigi (783)
    • Obiekty klasy Lock (784)
    • Warunki (787)
    • Słowo kluczowe synchronized (792)
    • Bloki synchronizowane (796)
    • Monitor (797)
    • Pola ulotne (798)
    • Zakleszczenia (800)
    • Testowanie blokad i odmierzanie czasu (803)
    • Blokady odczytu-zapisu (804)
    • Dlaczego metody stop i suspend są odradzane (805)
  • Kolejki blokujące (808)
  • Kolekcje bezpieczne wątkowo (815)
    • Szybkie mapy, zbiory i kolejki (815)
    • Tablice kopiowane przy zapisie (817)
    • Starsze kolekcje bezpieczne wątkowo (817)
  • Interfejsy Callable i Future (819)
  • Klasa Executors (823)
    • Pule wątków (824)
    • Planowanie wykonywania (828)
    • Kontrolowanie grup zadań (829)
  • Synchronizatory (830)
    • Semafory (830)
    • Klasa CountDownLatch (831)
    • Bariery (832)
    • Klasa Exchanger (833)
    • Kolejki synchroniczne (833)
    • Przykład - wstrzymywanie i ponowne uruchamianie animacji (833)
  • Wątki a biblioteka Swing (839)
    • Uruchamianie czasochłonnych zadań (840)
    • Klasa SwingWorker (845)
    • Zasada jednego wątku (851)

Dodatek A: Słowa kluczowe Javy (853)

Cena:    99.00zł


Java Podstawy Wydanie IXKsiążka informatyczna: Java Podstawy Wydanie IX
Księgarnia informatyczna aton.pl

Tutaj możesz kupić tę książkę w dobrej cenie. Zapraszamy na zakupy do naszej księgarni internetowej.