Twój koszyk : Do zapłaty 0,00 zł Ilość w koszyku: 0

Strona główna » informatyka » Programowanie » Java

• Obszerny przewodnik po języku Java -- zaktualizowany dla wersji JDK 1.3
• Pełne omówienie środowiska programowania zorientowanego obiektowo oraz klas Swing
• Więcej przykładowch kodów przydatnych profesjonalnym programistom
• CD-ROM zawiera kod źródłowy wszystkich programów, J2SE w wersji 1.3, Forte™ -- Java Community Edition i wiele więcej!

Pięć wydań w USA, pierwsze wydanie w Polsce!

"Java 2. Podstawy” jest najlepszą książką dla programistów. Nie ma sobie równych pod względem ilości przekazanych informacji, a mimo to pozostaje bardzo czytelna. -- K. N. King, Computer Reviews

Programiści znajdą tu wszystko, czego potrzeba, aby wykorzystać potęgę języka Java… -- PC Week

"Java 2. Podstawy" dostarcza wszystkiego, czego potrzebujesz, aby ukończyć nawet najbardziej skomplikowane projekty. Dlatego właśnie ta książka przez pięć lat była międzynarodowym bestsellerem. "Java 2. Podstawy" omawia podstawy platformy Java 2 Standard Edition w wersji 1.3, zawiera pełny opis zorientowanego obiektowo środowiska programistycznego Javy, komponentów interfejsu użytkownika Swing i wiele, wiele więcej.

Piąta wydanie prezentuje wiele nowych, gotowych do zastosowania programów, z których zasłynęły poprzednie edycje tej książki: pojawiły się również nowe programy dotyczące mechanizmu odbicia oraz optymalizacji kodu. Szczegółowo wyjaśniono koncepcję klas wewnętrznych, funkcjonowanie proxy, obsługę wyjątków, techniki usuwania błędów, model zdarzeń Javy, interfejs wejścia/wyjścia oraz zarządzania plikami.

Kompendium dla programistów Javy, a w nim:

• Omówienie języka Java i tworzenia aplikacji w środowisku Forte(tm)
• Tworzenie aplikacji GUI przy pomocy nowych klas Swing
• Sposoby pisania klas proxy i klas wewnętrznych
• Korzystanie z modelu zdarzeń Javy
• Omówienie klas strumieni oraz mechanizmu zarządzania plikami

To idealna książka dla profesjonalnych programistów, którzy chcą nauczyć się Javy i wykorzystać ją w swojej pracy zawodowej. Zawiera CD-ROM z kodem źródłowy wszystkich przykładów, Forte ™ -- Java Community Edition (zintegrowane środowisko programistyczne Javy) oraz wersje testowe wielu innych użytecznych programów.

O autorach:
CAY S. HORSTMANN wykłada informatykę na uniwersytecie stanowym w San Jose. Napisał sześć książek o C++, Javie i programowaniu zorientowanym obiektowo. Jest redaktorem naczelnym bestselerowego cyklu Core Series, wydawnictwa Prentice Hall PTR.

GARY CORNELL zrobił doktorat na uniwersytecie Brown i współpracował z IBM Watson Labs. Jest autorem lub współautorem 20 książek oraz wielu artykułów, wydrukowanych w czasopismach komputerowych. Obecnie kieruje programem Modern Visual Programming na Uniwersytecie Connecticut.

Podziękowania (11)

Przedmowa (13)

• Do Czytelnika (13)
  
• O książce (15)

Rozdział 1. Wprowadzenie do Javy (17)

• Java jako narzędzie programistyczne (18)
  
• Zalety Javy (19)
  
• Koncepcje języka Java (20)
  
  • Prosty (20)
  • Zorientowany obiektowo (21)
  • Rozproszony (22)
  • Niezawodny (22)
  • Bezpieczny (23)
  • Neutralny pod względem architektury (24)
  • Przenośny (24)
  • Interpretowany (25)
  • Wydajny (25)
  • Wielowątkowy (25)
  • Dynamiczny (26)
• Java i Internet (26)
  
  • Aplety w działaniu (27)
  • Java po stronie serwera (28)
• Krótka historia Javy (28)
  
• Główne nieporozumienia dotyczące Javy (31)

Rozdział 2. Środowisko programistyczne Javy (35)

• Instalowanie pakietu Java Software Development Kit (36)
  
  • Konfiguracja ścieżki dostępu (36)
  • Instalowanie bibliotek i dokumentacji (37)
  • Instalowanie przykładowych programów książki Core Java (38)
  • Drzewo katalogów Javy (38)
• Różne środowiska programistyczne (39)
  
• Korzystanie z linii poleceń (40)
  
  • Rozwiązywanie problemów (42)
• Praca ze zintegrowanym środowiskiem programistycznym (43)
  
  • Wyszukiwanie błędów kompilacji (44)
• Kompilowanie i uruchamianie programów przy użyciu edytora tekstu (46)
  
• Aplikacje graficzne (48)
  
• Aplety (51)

Rozdział 3. Podstawy programowania w Javie (57)

• Prosty program napisany w Javie (58)
  
• Komentarze (60)
  
• Typy danych (61)
  
  • Liczby całkowite (62)
  • Typy zmiennoprzecinkowe (62)
  • Typ znakowy (63)
  • Typ boolean (64)
• Zmienne (65)
  
• Przypisanie i inicjalizacja (66)
  
  • Stałe (66)
• Operatory (67)
  
  • Operatory inkrementacji i dekrementacji (69)
  • Operatory relacji i typu boolean (69)
  • Operatory bitowe (70)
  • Funkcje i stałe matematyczne (71)
  • Konwersje pomiędzy typami numerycznymi (72)
  • Rzutowanie (73)
  • Hierarchia nawiasów i operatorów (73)
• Łańcuchy (74)
  
  • Konkatenacja (74)
  • Wycinanie łańcuchów (75)
  • Edycja łańcuchów (75)
  • Porównywanie łańcuchów (77)
  • Czytanie dokumentacji API online (79)
  • Czytanie danych (81)
  • Formatowanie wyjścia (83)
• Instrukcje sterujące (86)
  
  • Blok instrukcji (86)
  • Instrukcje warunkowe (87)
  • Pętle nieokreślone (89)
  • Pętle określone (93)
  • Wielokrotny wybór - polecenie switch (96)
  • Przerywanie instrukcji sterowania (98)
• Wielkie liczby (100)
  
• Tablice (102)
  
  • Inicjalizacja tablic i tablice anonimowe (103)
  • Kopiowanie tablic (104)
  • Parametry linii poleceń (105)
  • Sortowanie tablicy (106)
  • Tablice wielowymiarowe (109)
  • Tablice nierównej długości (112)

Rozdział 4. Obiekty i klasy (115)

• Wprowadzenie do programowania zorientowanego obiektowo (116)
  
  • Słownictwo OOP (117)
  • Obiekty (118)
  • Relacje pomiędzy klasami (119)
  • Porównanie OOP z konwencjonalnymi technikami programowania proceduralnego (121)
• Korzystanie z istniejących klas (123)
  
  • Obiekty i zmienne obiektów (123)
  • Klasa biblioteczna GregorianCalendar (126)
• Tworzenie własnych klas (133)
  
  • Klasa Pracownik (133)
  • Używanie wielu plików źródłowych równocześnie (136)
  • Analiza klasy Pracownik (137)
  • Pierwsze doświadczenia z konstruktorami (137)
  • Metody klasy Pracownik (139)
  • Metody dostępu do danych prywatnych (142)
  • Metody prywatne (143)
  • Finalne pola składowe (143)
• Pola i metody statyczne (144)
  
  • Pola statyczne (144)
  • Stałe (145)
  • Metody statyczne (146)
  • Metody fabryczne (147)
  • Metoda main (147)
• Parametry metod (150)
  
• Konstrukcja obiektów (155)
  
  • Przeładowanie (155)
  • Domyślna inicjalizacja pól składowych (156)
  • Konstruktory domyślne (157)
  • Bezpośrednia inicjalizacja pól składowych (157)
  • Nazwy parametrów (158)
  • Wywoływanie innego konstruktora (159)
  • Bloki inicjalizacji (160)
  • Niszczenie obiektów i metoda finalize (163)
• Pakiety (164)
  
  • Wykorzystanie pakietów (164)
• Komentarze dokumentacji (172)
  
  • Wstawianie komentarzy (172)
  • Dokumentacja klasy (173)
  • Dokumentacja metod (174)
  • Dokumentacja pól składowych (174)
  • Komentarze standardowe (174)
  • Dokumentacja pakietu i podsumowanie (176)
  • Generowanie dokumentacji (176)
• Porady dotyczące projektowania klas (177)

Rozdział 5. Dziedziczenie (181)

• Rozszerzanie klas (181)
  
  • Hierarchie dziedziczenia (188)
  • Polimorfizm (189)
  • Wiązanie dynamiczne (190)
  • Zapobieganie dziedziczeniu - klasy i metody finalne (192)
  • Rzutowanie (193)
  • Klasy abstrakcyjne (195)
  • Dostęp chroniony (200)
• Object - uniwersalna nadklasa (201)
  
  • Metody equals i toString (202)
  • Programowanie uniwersalne (209)
  • Klasa ArrayList (211)
  • Klasy opakowań (217)
• Klasa Class (221)
  
• Mechanizm odbicia (224)
  
  • Wykorzystanie mechanizmu odbicia do analizy możliwości klas (225)
  • Wykorzystanie mechanizmu odbicia do analizy obiektów w czasie działania programu (229)
  • Wykorzystanie mechanizmu odbicia w pisaniu kodu uniwersalnej tablicy (235)
  • Wskaźniki do metod (238)
• Zastosowanie dziedziczenia w projektowaniu (242)

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

• Interfejsy (246)
  
  • Właściwości interfejsów (250)
  • Interfejsy i klasy abstrakcyjne (251)
  • Interfejsy i wywołania zwrotne (252)
• Klonowanie obiektów (255)
  
• Klasy wewnętrzne (260)
  
  • Wykorzystanie klas wewnętrznych do kontaktowania się ze zmiennymi obiektu (262)
  • Specjalne zasady składni dla klas wewnętrznych (266)
  • Czy klasy wewnętrzne są użyteczne? Czy są w ogóle potrzebne? I czy są bezpieczne? (266)
  • Lokalne klasy wewnętrzne (269)
  • Statyczne klasy wewnętrzne (274)
• Proxy (277)
  
  • Właściwości klas proxy (281)

Rozdział 7. Programowanie grafiki (283)

• Wprowadzenie do zestawu Swing (284)
• Tworzenie ramek (287)
  
• Pozycjonowanie ramek (290)
  
• Wyświetlanie informacji w panelach (295)
  
• Figury 2D (299)
  
• Kolory (307)
  
  • Wypełnianie figur geometrycznych (310)
• Tekst i czcionki (312)
  
• Obrazy (321)

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

• Podstawy obsługi zdarzeń (330)
  
  • Przykład - obsługa kliknięcia przycisku (332)
  • Wybór słuchaczy zdarzeń (338)
  • Przykład - zmiana "wyglądu i wrażenia" (341)
  • Przykład - przechwytywanie zdarzeń okna (344)
• Hierarchia zdarzeń AWT (347)
  
• Zdarzenia semantyczne i zdarzenia niskiego poziomu w AWT (350)
  
  • Mechanizm obsługi zdarzeń - podsumowanie (350)
• Typy zdarzeń niskiego poziomu (353)
  
  • Aktywacja komponentów (353)
  • Zdarzenia dotyczące klawiatury (355)
  • Pochłanianie zdarzeń (361)
  • Zdarzenia dotyczące myszki (361)
• Działania (368)
  
• Multicasting (377)
  
• Kolejka zdarzeń (380)
  
  • Dołączanie własnych zdarzeń (381)

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

• Wzór projektu MVC (392)
  
  • Analiza MVC przycisków zestawu Swing (396)
• Wprowadzenie do zarządzania układem graficznym (398)
  
  • Układ krawędzi (400)
  • Panele (401)
• Wprowadzanie tekstu (403)
  
  • Pola tekstowe (403)
  • Walidacja danych (409)
  • Pola haseł (417)
  • Obszary tekstowe (418)
  • Etykiety i komponenty etykiet (421)
  • Wybór tekstu (423)
  • Edycja tekstu (424)
• Dokonywanie wyborów (426)
  
  • Pola wyboru (426)
  • Przełączniki (429)
  • Krawędzie (433)
  • Listy kombinowane (437)
  • Suwaki (440)
• Menu (446)
  
  • Tworzenie menu (446)
  • Ikony elementów menu (449)
  • Pola wyboru i przełączniki jako elementy menu (450)
  • Menu kontekstowe (452)
  • Mnemoniki i akceleratory (453)
  • Włączanie i wyłączanie elementów menu (455)
  • Paski narzędzi (459)
  • Podpowiedzi (461)
• Zaawansowane techniki zarządzania układem graficznym (464)
  
  • Układ siatkowy (467)
  • Układ pudełkowy (471)
  • Układ arkuszowy (476)
  • Parametry gridx, gridy, gridweight oraz gridheight (478)
  • Pola wagowe (478)
  • Parametry fill i anchor (478)
  • Poszycie (479)
  • Alternatywna metoda określania parametrów gridx, gridy, gridwidth i gridheight (479)
  • Praca bez menedżera układu (483)
  • Tworzenie własnych menedżerów układu (483)
  • Sekwencja dostępu (487)
• Okna dialogowe (489)
  
  • Okna wyboru (490)
  • Tworzenie okien dialogowych (501)
  • Przesyłanie danych (505)
  • Okno pliku (511)
  • Okno wyboru koloru (522)

Rozdział 10. Aplety (529)

• Podstawy apletów (529)
  
  • Prosty aplet (532)
  • Uruchamianie przeglądarki apletów (534)
  • Oglądanie apletu w przeglądarce (535)
  • Przekształcanie aplikacji w aplety (539)
  • Cykl życia apletu (540)
  • Podstawy systemu ochrony (542)
  • Okna dialogowe w apletach (543)
• Znaczniki HTML oraz atrybuty apletów (545)
  
  • Atrybuty określające położenie apletu (546)
  • Atrybuty dotyczące kodu apletu (547)
  • Atrybuty dotyczące przeglądarek nie połączonych z Javą (550)
  • Znacznik OBJECT (550)
  • Znaczniki Java Plug-In (551)
  • Przekazywanie informacji apletom (552)
• Multimedia (557)
  
  • Adresy URL (558)
  • Tworzenie plików multimedialnych (559)
• Kontekst apletu (560)
  
  • Komunikacja pomiędzy apletami (560)
  • Wyświetlanie elementów w przeglądarce (561)
  • Aplet "Spis adresów" (563)
  • To aplet. Nie, to aplikacja. To jedno i to samo! (565)
• Pliki JAR (570)
  
  • Manifest (572)
  • Przechowywanie plików JAR (573)
  • Autonomiczne pliki JAR (574)
  • Zasoby (574)
  • Pakiety opcjonalne (578)
  • Pieczętowanie (579)

Rozdział 11. Wyjątki i proces debugowania (581)

• Obsługa błędów (582)
  
  • Klasyfikacja wyjątków (583)
  • Powiadamianie o wyjątkach zwracanych przez metody (585)
  • Jak wygenerować wyjątek? (587)
  • Tworzenie klas wyjątków (588)
• Łapanie wyjątków (589)
  
  • Wielokrotne łapanie wyjątków (591)
  • Powtórne zwracanie tego samego wyjątku (592)
  • Jeszcze jedno spojrzenie na obsługę błędów i wyjątków (595)
• Wskazówki dotyczące korzystania z wyjątków (599)
  
• Techniki debugowania (602)
  
  • Metody debugowania (602)
  • Stwierdzenia (606)
  • Korzystanie z okna konsoli (609)
  • Śledzenie zdarzeń AWT (610)
  • Robot AWT (614)
  • Profilowanie (618)
  • Test wykorzystania (622)
• Korzystanie z debuggera (623)
  
  • Debugger JDB (623)
  • Debugger Forte (628)

Rozdział 12. Strumienie i pliki (631)

• Strumienie (631)
  
  • Wczytywanie i zapisywanie bajtów (632)
• Zoo pełne strumieni (634)
  
  • Budowa filtrów strumieni (637)
  • Strumienie danych (640)
  • Strumienie plików swobodnego dostępu (643)
• Strumienie plików ZIP (653)
  
• Wykorzystanie strumieni (660)
  
  • Zapisywanie separowanego tekstu (661)
  • Klasa StringTokenizer oraz tekst separowany (662)
  • Pobieranie separowanego tekstu (663)
  • Strumienie swobodnego dostępu (666)
• Strumienie obiektów (673)
  
  • Przechowywanie obiektów zmiennego typu (674)
  • Format pliku serializacji obiektów (678)
  • Problem zapisywania referencji obiektów (682)
  • Format referencji obiektów (688)
  • Ochrona (690)
  • Wersje (695)
  • Serializacja w roli klonowania (697)
• Zarządzanie plikami (700)

Dodatek A Słowa kluczowe Javy (707)

Skorowidz (709)