Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
01699 018826 17770715 na godz. na dobę w sumie
Java. Podstawy. Wydanie IX - książka
Java. Podstawy. Wydanie IX - książka
Autor: , Liczba stron: 864
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-7758-0 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).

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:

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

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Core Java Volume I--Fundamentals (9th Edition) Tłumaczenie: Łukasz Piwko ISBN: 978-83-246-7758-0 Authorized translation from the English language edition, entitled CORE JAVA VOLUME I – FUNDAMENTALS, 9TH EDITION; ISBN 0137081898; by Cay S. Horstmann; and Gary Cornell; published by Pearson Education, Inc, publishing as Prentice Hall. Copyright © 2013 by Oracle and/or its affiliates, 500 Oracle Parkway, Redwood Shores, CA 94065. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from Pearson Education Inc. Polish language edition published by HELION S.A. Copyright © 2013. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Wydawnictwo HELION dołożyło wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie bierze jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Wydawnictwo HELION nie ponosi również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/javpd9.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/javpd9 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis tre(cid:202)ci Wst(cid:194)p ........................................................................................................................................................13 Podzi(cid:194)kowania .........................................................................................................................................19 1.1. 1.2. Rozdzia(cid:196) 1. Wst(cid:194)p do Javy ........................................................................................................................21 Java jako platforma programistyczna ................................................................... 21 S(cid:228)owa klucze bia(cid:228)ej ksi(cid:246)gi Javy ............................................................................ 22 1.2.1. Prosty .................................................................................................. 23 1.2.2. Obiektowy ............................................................................................ 24 1.2.3. Sieciowy .............................................................................................. 24 1.2.4. Niezawodny .......................................................................................... 24 1.2.5. Bezpieczny ........................................................................................... 25 1.2.6. Niezale(cid:276)ny od architektury ..................................................................... 26 Przeno(cid:264)ny ............................................................................................ 26 1.2.7. 1.2.8. Interpretowany ..................................................................................... 27 1.2.9. Wysokowydajny ..................................................................................... 27 1.2.10. Wielow(cid:241)tkowy ....................................................................................... 28 1.2.11. Dynamiczny .......................................................................................... 28 Aplety Javy i internet .......................................................................................... 28 Krótka historia Javy ............................................................................................ 30 G(cid:228)ówne nieporozumienia dotycz(cid:241)ce Javy .............................................................. 32 Rozdzia(cid:196) 2. (cid:201)rodowisko programistyczne Javy ...................................................................................37 Instalacja oprogramowania Java Development Kit ................................................. 38 2.1.1. Pobieranie pakietu JDK ......................................................................... 38 2.1.2. Ustawianie (cid:264)cie(cid:276)ki dost(cid:246)pu ................................................................... 39 Instalacja bibliotek i dokumentacji ......................................................... 41 2.1.3. 2.1.4. Instalacja przyk(cid:228)adowych programów ...................................................... 42 2.1.5. Drzewo katalogów Javy .......................................................................... 42 2.2. Wybór (cid:264)rodowiska programistycznego .................................................................. 43 U(cid:276)ywanie narz(cid:246)dzi wiersza polece(cid:254) ...................................................................... 44 2.3. 2.3.1. Rozwi(cid:241)zywanie problemów ..................................................................... 45 Praca w zintegrowanym (cid:264)rodowisku programistycznym .......................................... 47 2.4.1. Znajdowanie b(cid:228)(cid:246)dów kompilacji .............................................................. 49 1.3. 1.4. 1.5. 2.1. 2.4. Kup książkęPoleć książkę 4 Java. Podstawy 3.4. 3.5. 3.6. 2.5. 2.6. 3.1. 3.2. 3.3. Uruchamianie aplikacji graficznej ......................................................................... 50 Tworzenie i uruchamianie apletów ....................................................................... 53 Rozdzia(cid:196) 3. Podstawowe elementy j(cid:194)zyka Java ....................................................................................57 Prosty program w Javie ....................................................................................... 58 Komentarze ....................................................................................................... 61 Typy danych ...................................................................................................... 62 Typy ca(cid:228)kowite ...................................................................................... 62 3.3.1. Typy zmiennoprzecinkowe ...................................................................... 63 3.3.2. 3.3.3. Typ char ............................................................................................... 65 3.3.4. Typ boolean ......................................................................................... 66 Zmienne ........................................................................................................... 66 Inicjacja zmiennych ............................................................................... 68 3.4.1. 3.4.2. Sta(cid:228)e ................................................................................................... 68 Operatory .......................................................................................................... 69 3.5.1. Operatory inkrementacji i dekrementacji ................................................. 71 3.5.2. Operatory relacyjne i logiczne ................................................................. 71 3.5.3. Operatory bitowe .................................................................................. 72 Funkcje i sta(cid:228)e matematyczne ................................................................ 73 3.5.4. 3.5.5. Konwersja typów numerycznych ............................................................. 74 3.5.6. Rzutowanie .......................................................................................... 75 3.5.7. Nawiasy i priorytety operatorów .............................................................. 76 3.5.8. Typ wyliczeniowy ................................................................................... 77 (cid:227)a(cid:254)cuchy .......................................................................................................... 77 Pod(cid:228)a(cid:254)cuchy ......................................................................................... 78 3.6.1. Konkatenacja ....................................................................................... 78 3.6.2. (cid:227)a(cid:254)cuchów nie mo(cid:276)na modyfikowa(cid:232) ....................................................... 79 3.6.3. 3.6.4. Porównywanie (cid:228)a(cid:254)cuchów ...................................................................... 79 3.6.5. (cid:227)a(cid:254)cuchy puste i (cid:228)a(cid:254)cuchy null .............................................................. 81 3.6.6. Wspó(cid:228)rz(cid:246)dne kodowe znaków i jednostki kodowe .................................... 81 3.6.7. API String ............................................................................................. 83 3.6.8. Dokumentacja API w internecie .............................................................. 85 3.6.9. Sk(cid:228)adanie (cid:228)a(cid:254)cuchów ............................................................................ 86 3.7. Wej(cid:264)cie i wyj(cid:264)cie ................................................................................................ 89 3.7.1. Odbieranie danych wej(cid:264)ciowych ............................................................. 89 Formatowanie danych wyj(cid:264)ciowych ......................................................... 91 3.7.2. 3.7.3. Zapis i odczyt plików ............................................................................. 96 Przep(cid:228)yw sterowania ........................................................................................... 98 Zasi(cid:246)g blokowy ..................................................................................... 98 3.8.1. Instrukcje warunkowe ............................................................................ 99 3.8.2. P(cid:246)tle ................................................................................................. 101 3.8.3. 3.8.4. P(cid:246)tle o okre(cid:264)lonej liczbie powtórze(cid:254) ..................................................... 106 3.8.5. Wybór wielokierunkowy — instrukcja switch .......................................... 109 3.8.6. Instrukcje przerywaj(cid:241)ce przep(cid:228)yw sterowania ......................................... 111 3.9. Wielkie liczby ................................................................................................... 114 3.10. Tablice ............................................................................................................ 116 3.10.1. P(cid:246)tla typu for each .............................................................................. 117 3.10.2. Inicjowanie tablic i tworzenie tablic anonimowych .................................. 118 3.10.3. Kopiowanie tablicy .............................................................................. 119 3.10.4. Parametry wiersza polece(cid:254) .................................................................. 120 3.10.5. Sortowanie tablicy .............................................................................. 121 3.8. Kup książkęPoleć książkę Spis tre(cid:202)ci 5 4.2. 4.3. 3.10.6. Tablice wielowymiarowe ...................................................................... 124 3.10.7. Tablice postrz(cid:246)pione ........................................................................... 127 Rozdzia(cid:196) 4. Obiekty i klasy ......................................................................................................................131 4.1. Wst(cid:246)p do programowania obiektowego .............................................................. 132 4.1.1. Klasy ................................................................................................. 132 4.1.2. Obiekty .............................................................................................. 133 Identyfikacja klas ................................................................................ 134 4.1.3. 4.1.4. Relacje mi(cid:246)dzy klasami ....................................................................... 135 U(cid:276)ywanie klas predefiniowanych ........................................................................ 137 4.2.1. Obiekty i zmienne obiektów ................................................................. 137 4.2.2. Klasa GregorianCalendar ..................................................................... 139 4.2.3. Metody udost(cid:246)pniaj(cid:241)ce i zmieniaj(cid:241)ce warto(cid:264)(cid:232) elementu ........................ 141 Definiowanie w(cid:228)asnych klas .............................................................................. 148 4.3.1. Klasa Employee .................................................................................. 148 4.3.2. U(cid:276)ywanie wielu plików (cid:274)ród(cid:228)owych ........................................................ 151 Analiza klasy Employee ....................................................................... 151 4.3.3. Pierwsze kroki w tworzeniu konstruktorów ............................................. 152 4.3.4. Parametry jawne i niejawne ................................................................. 153 4.3.5. 4.3.6. Korzy(cid:264)ci z hermetyzacji ........................................................................ 155 4.3.7. Przywileje klasowe .............................................................................. 157 4.3.8. Metody prywatne ................................................................................ 157 4.3.9. Sta(cid:228)e jako pola klasy ........................................................................... 158 Pola i metody statyczne .................................................................................... 158 Pola statyczne .................................................................................... 159 4.4.1. 4.4.2. Sta(cid:228)e statyczne ................................................................................... 159 4.4.3. Metody statyczne ................................................................................ 160 4.4.4. Metody fabryczne ................................................................................ 161 4.4.5. Metoda main ...................................................................................... 162 Parametry metod ............................................................................................. 164 Konstruowanie obiektów .................................................................................. 171 Przeci(cid:241)(cid:276)anie ....................................................................................... 171 4.6.1. 4.6.2. Inicjacja pól warto(cid:264)ciami domy(cid:264)lnymi ................................................... 171 Konstruktor bezargumentowy ............................................................... 172 4.6.3. 4.6.4. Jawna inicjacja pól .............................................................................. 172 4.6.5. Nazywanie parametrów ....................................................................... 174 4.6.6. Wywo(cid:228)ywanie innego konstruktora ........................................................ 174 4.6.7. Bloki inicjuj(cid:241)ce ................................................................................... 175 4.6.8. Niszczenie obiektów i metoda finalize ................................................... 179 Pakiety ............................................................................................................ 180 Importowanie klas .............................................................................. 180 4.7.1. 4.7.2. Importy statyczne ............................................................................... 182 4.7.3. Dodawanie klasy do pakietu ................................................................ 182 4.7.4. Zasi(cid:246)g pakietów ................................................................................. 185 (cid:263)cie(cid:276)ka klas .................................................................................................... 187 4.8.1. Ustawianie (cid:264)cie(cid:276)ki klas ....................................................................... 189 Komentarze dokumentacyjne ............................................................................ 190 4.9.1. Wstawianie komentarzy ....................................................................... 190 Komentarze do klas ............................................................................ 191 4.9.2. Komentarze do metod ......................................................................... 191 4.9.3. 4.9.4. Komentarze do pól ............................................................................. 192 4.5. 4.6. 4.4. 4.7. 4.8. 4.9. Kup książkęPoleć książkę 6 Java. Podstawy 5.1. Komentarze ogólne ............................................................................. 192 4.9.5. 4.9.6. Komentarze do pakietów i ogólne ........................................................ 194 4.9.7. Generowanie dokumentacji .................................................................. 194 4.10. Porady dotycz(cid:241)ce projektowania klas ................................................................. 195 Rozdzia(cid:196) 5. Dziedziczenie .......................................................................................................................199 Klasy, nadklasy i podklasy ................................................................................ 200 5.1.1. Hierarchia dziedziczenia ...................................................................... 206 5.1.2. Polimorfizm ........................................................................................ 207 5.1.3. Wi(cid:241)zanie dynamiczne .......................................................................... 209 5.1.4. Wy(cid:228)(cid:241)czanie dziedziczenia — klasy i metody finalne ................................ 211 Rzutowanie ........................................................................................ 212 5.1.5. 5.1.6. Klasy abstrakcyjne .............................................................................. 214 5.1.7. Ochrona dost(cid:246)pu ................................................................................ 219 Klasa bazowa Object ........................................................................................ 220 5.2.1. Metoda equals ................................................................................... 221 5.2.2. Porównywanie a dziedziczenie .............................................................. 222 5.2.3. Metoda hashCode .............................................................................. 225 5.2.4. Metoda toString ................................................................................. 228 Generyczne listy tablicowe ................................................................................ 233 5.3.1. Dost(cid:246)p do elementów listy tablicowej ................................................... 236 5.3.2. Zgodno(cid:264)(cid:232) pomi(cid:246)dzy typowanymi a surowymi listami tablicowymi ............. 239 5.4. Os(cid:228)ony obiektów i autoboxing ............................................................................ 241 5.5. Metody ze zmienn(cid:241) liczb(cid:241) parametrów ............................................................... 244 Klasy wyliczeniowe ........................................................................................... 245 5.6. Refleksja ......................................................................................................... 247 5.7. Klasa Class ....................................................................................... 248 5.7.1. Podstawy przechwytywania wyj(cid:241)tków .................................................... 250 5.7.2. 5.7.3. Zastosowanie refleksji w analizie funkcjonalno(cid:264)ci klasy ......................... 252 Refleksja w analizie obiektów w czasie dzia(cid:228)ania programu .................... 257 5.7.4. 5.7.5. Zastosowanie refleksji w generycznym kodzie tablicowym ...................... 261 5.7.6. Wywo(cid:228)ywanie dowolnych metod ............................................................ 264 Porady projektowe dotycz(cid:241)ce dziedziczenia ........................................................ 268 Rozdzia(cid:196) 6. Interfejsy i klasy wewn(cid:194)trzne ...........................................................................................271 Interfejsy ......................................................................................................... 272 6.1.1. W(cid:228)asno(cid:264)ci interfejsów ......................................................................... 276 6.1.2. Interfejsy a klasy abstrakcyjne ............................................................. 279 Klonowanie obiektów ....................................................................................... 280 Interfejsy a sprz(cid:246)(cid:276)enie zwrotne ......................................................................... 286 Klasy wewn(cid:246)trzne ............................................................................................ 289 6.4.1. Dost(cid:246)p do stanu obiektu w klasie wewn(cid:246)trznej ..................................... 289 Specjalne regu(cid:228)y sk(cid:228)adniowe dotycz(cid:241)ce klas wewn(cid:246)trznych ..................... 293 6.4.2. Czy klasy wewn(cid:246)trzne s(cid:241) potrzebne i bezpieczne? ................................. 294 6.4.3. 6.4.4. Lokalne klasy wewn(cid:246)trzne ................................................................... 296 6.4.5. Dost(cid:246)p do zmiennych finalnych z metod zewn(cid:246)trznych ........................... 297 6.4.6. Anonimowe klasy wewn(cid:246)trzne .............................................................. 300 6.4.7. Statyczne klasy wewn(cid:246)trzne ................................................................ 303 Klasy proxy ...................................................................................................... 306 6.5.1. W(cid:228)asno(cid:264)ci klas proxy .......................................................................... 311 6.2. 6.3. 6.4. 5.8. 6.1. 5.2. 5.3. 6.5. Kup książkęPoleć książkę Spis tre(cid:202)ci 7 8.2. 8.3. 8.4. Rozdzia(cid:196) 7. Grafika .................................................................................................................................313 7.1. Wprowadzenie do pakietu Swing ....................................................................... 314 Tworzenie ramki ............................................................................................... 318 7.2. Pozycjonowanie ramki ...................................................................................... 321 7.3. 7.3.1. W(cid:228)asno(cid:264)ci ramek ................................................................................ 322 7.3.2. Okre(cid:264)lanie rozmiaru ramki ................................................................... 323 7.4. Wy(cid:264)wietlanie informacji w komponencie ............................................................ 327 Figury 2D ........................................................................................................ 332 7.5. 7.6. Kolory ............................................................................................................. 340 7.7. Czcionki .......................................................................................................... 343 7.8. Wy(cid:264)wietlanie obrazów ...................................................................................... 351 Rozdzia(cid:196) 8. Obs(cid:196)uga zdarze(cid:198) .................................................................................................................355 Podstawy obs(cid:228)ugi zdarze(cid:254) ................................................................................. 355 8.1.1. Przyk(cid:228)ad — obs(cid:228)uga klikni(cid:246)cia przycisku ............................................... 357 8.1.2. Nabywanie bieg(cid:228)o(cid:264)ci w pos(cid:228)ugiwaniu si(cid:246) klasami wewn(cid:246)trznymi .............. 362 Tworzenie s(cid:228)uchaczy zawieraj(cid:241)cych jedno wywo(cid:228)anie metody ................... 364 8.1.3. Przyk(cid:228)ad — zmiana stylu ..................................................................... 366 8.1.4. 8.1.5. Klasy adaptacyjne ............................................................................... 369 Akcje .............................................................................................................. 373 Zdarzenia generowane przez mysz ..................................................................... 380 Hierarchia zdarze(cid:254) w bibliotece AWT .................................................................. 387 Zdarzenia semantyczne i niskiego poziomu ........................................... 388 8.4.1. Rozdzia(cid:196) 9. Komponenty Swing interfejsu u(cid:209)ytkownika ......................................................................391 Swing a wzorzec projektowy Model-View-Controller .............................................. 392 9.1.1. Wzorce projektowe .............................................................................. 392 9.1.2. Wzorzec Model-View-Controller ............................................................. 393 Analiza MVC przycisków Swing ............................................................. 397 9.1.3. 9.2. Wprowadzenie do zarz(cid:241)dzania rozk(cid:228)adem ........................................................... 398 Rozk(cid:228)ad brzegowy ............................................................................... 400 Rozk(cid:228)ad siatkowy ................................................................................ 402 9.3. Wprowadzanie tekstu ....................................................................................... 406 Pola tekstowe .................................................................................... 406 9.3.1. Etykiety komponentów ........................................................................ 408 9.3.2. 9.3.3. Pola hase(cid:228) .......................................................................................... 410 9.3.4. Obszary tekstowe ............................................................................... 410 9.3.5. Panele przewijane ............................................................................... 411 Komponenty umo(cid:276)liwiaj(cid:241)ce wybór opcji .............................................................. 413 Pola wyboru ....................................................................................... 413 9.4.1. 9.4.2. Prze(cid:228)(cid:241)czniki ........................................................................................ 415 9.4.3. Obramowanie ..................................................................................... 419 Listy rozwijalne ................................................................................... 423 9.4.4. 9.4.5. Suwaki .............................................................................................. 426 9.5. Menu .............................................................................................................. 432 Tworzenie menu ................................................................................. 432 9.5.1. Ikony w elementach menu ................................................................... 435 9.5.2. 9.5.3. Pola wyboru i prze(cid:228)(cid:241)czniki jako elementy menu ...................................... 436 9.5.4. Menu podr(cid:246)czne ................................................................................. 437 9.5.5. Mnemoniki i akceleratory .................................................................... 438 9.2.1. 9.2.2. 8.1. 9.1. 9.4. Kup książkęPoleć książkę 8 Java. Podstawy 9.7. 9.6. Aktywowanie i dezaktywowanie elementów menu .................................. 440 9.5.6. 9.5.7. Paski narz(cid:246)dzi .................................................................................... 444 9.5.8. Dymki ................................................................................................ 446 Zaawansowane techniki zarz(cid:241)dzania rozk(cid:228)adem .................................................. 448 9.6.1. Rozk(cid:228)ad GridBagLayout ....................................................................... 449 9.6.2. Rozk(cid:228)ad grupowy ................................................................................. 459 9.6.3. Nieu(cid:276)ywanie (cid:276)adnego zarz(cid:241)dcy rozk(cid:228)adu ................................................ 468 9.6.4. Niestandardowi zarz(cid:241)dcy rozk(cid:228)adu ........................................................ 469 9.6.5. Kolejka dost(cid:246)pu ................................................................................. 472 Okna dialogowe ............................................................................................... 474 9.7.1. Okna dialogowe opcji .......................................................................... 474 9.7.2. Tworzenie okien dialogowych ............................................................... 484 9.7.3. Wymiana danych ................................................................................. 489 9.7.4. Okna dialogowe wyboru plików ............................................................. 495 9.7.5. Okna dialogowe wyboru kolorów ........................................................... 505 Rozdzia(cid:196) 10. Przygotowywanie apletów i aplikacji do u(cid:209)ytku ..............................................................511 10.1. Pliki JAR .......................................................................................................... 512 10.1.1. Manifest ............................................................................................ 512 10.1.2. Wykonywalne pliki JAR ........................................................................ 514 10.1.3. Zasoby .............................................................................................. 515 10.1.4. Piecz(cid:246)towanie pakietów ...................................................................... 518 10.2. Java Web Start ................................................................................................ 519 10.2.1. Piaskownica ....................................................................................... 522 10.2.2. Podpisywanie kodu ............................................................................. 523 10.2.3. API JNLP ............................................................................................ 525 10.3. Aplety ............................................................................................................. 533 10.3.1. Prosty aplet ........................................................................................ 533 10.3.2. Znacznik applet i jego atrybuty ............................................................. 537 10.3.3. Znacznik object .................................................................................. 540 10.3.4. Parametry przekazuj(cid:241)ce informacje do apletów ...................................... 541 10.3.5. Dost(cid:246)p do obrazów i plików audio ........................................................ 546 10.3.6. (cid:263)rodowisko dzia(cid:228)ania apletu ................................................................ 547 10.4. Zapisywanie preferencji u(cid:276)ytkownika .................................................................. 549 10.4.1. Mapy w(cid:228)asno(cid:264)ci .................................................................................. 550 10.4.2. API Preferences .................................................................................. 555 Rozdzia(cid:196) 11. Wyj(cid:190)tki, dzienniki, asercje i debugowanie .......................................................................563 11.1. Obs(cid:228)uga b(cid:228)(cid:246)dów ............................................................................................... 564 11.1.1. Klasyfikacja wyj(cid:241)tków .......................................................................... 565 11.1.2. Deklarowanie wyj(cid:241)tków kontrolowanych ................................................ 567 11.1.3. Zg(cid:228)aszanie wyj(cid:241)tków ........................................................................... 569 11.1.4. Tworzenie klas wyj(cid:241)tków ...................................................................... 570 11.2. Przechwytywanie wyj(cid:241)tków ................................................................................ 571 11.2.1. Przechwytywanie wielu typów wyj(cid:241)tków ................................................. 574 11.2.2. Powtórne generowanie wyj(cid:241)tków i budowanie (cid:228)a(cid:254)cuchów wyj(cid:241)tków .......... 575 11.2.3. Klauzula finally ................................................................................... 576 11.2.4. Instrukcja try z zasobami ..................................................................... 580 11.2.5. Analiza danych ze (cid:264)ledzenia stosu ....................................................... 581 11.3. Wskazówki dotycz(cid:241)ce stosowania wyj(cid:241)tków ....................................................... 584 Kup książkęPoleć książkę Spis tre(cid:202)ci 9 11.4. Asercje ........................................................................................................... 587 11.4.1. W(cid:228)(cid:241)czanie i wy(cid:228)(cid:241)czanie asercji ............................................................. 588 11.4.2. Zastosowanie asercji do sprawdzania parametrów ................................ 589 11.4.3. Zastosowanie asercji do dokumentowania za(cid:228)o(cid:276)e(cid:254) ................................ 590 11.5. Dzienniki ......................................................................................................... 591 11.5.1. Podstawy zapisu do dziennika .............................................................. 592 11.5.2. Zaawansowane techniki zapisu do dziennika ......................................... 592 11.5.3. Zmiana konfiguracji mened(cid:276)era dzienników ........................................... 594 11.5.4. Lokalizacja ......................................................................................... 596 11.5.5. Obiekty typu Handler ........................................................................... 596 11.5.6. Filtry .................................................................................................. 600 11.5.7. Formatery .......................................................................................... 600 11.5.8. Przepis na dziennik ............................................................................. 601 11.6. Wskazówki dotycz(cid:241)ce debugowania ................................................................... 609 11.7. Wskazówki dotycz(cid:241)ce debugowania aplikacji z GUI ............................................. 614 11.7.1. Zaprz(cid:246)ganie robota AWT do pracy ........................................................ 617 11.8. Praca z debugerem .......................................................................................... 621 Rozdzia(cid:196) 12. Programowanie ogólne ....................................................................................................627 12.1. Dlaczego programowanie ogólne ....................................................................... 628 12.1.1. Dla kogo programowanie ogólne .......................................................... 629 12.2. Definicja prostej klasy ogólnej ........................................................................... 630 12.3. Metody ogólne ................................................................................................. 632 12.4. Ograniczenia zmiennych typowych ..................................................................... 633 12.5. Kod ogólny a maszyna wirtualna ....................................................................... 635 12.5.1. Translacja wyra(cid:276)e(cid:254) generycznych ......................................................... 637 12.5.2. Translacja metod ogólnych .................................................................. 637 12.5.3. U(cid:276)ywanie starego kodu ....................................................................... 639 12.6. Ograniczenia i braki ......................................................................................... 641 12.6.1. Nie mo(cid:276)na podawa(cid:232) typów prostych jako parametrów typowych .............. 641 12.6.2. Sprawdzanie typów w czasie dzia(cid:228)ania programu jest mo(cid:276)liwe tylko dla typów surowych .................................................. 641 12.6.3. Nie mo(cid:276)na tworzy(cid:232) tablic typów ogólnych .............................................. 642 12.6.4. Ostrze(cid:276)enia dotycz(cid:241)ce zmiennej liczby argumentów ............................... 642 12.6.5. Nie wolno tworzy(cid:232) egzemplarzy zmiennych typowych .............................. 643 12.6.6. Zmiennych typowych nie mo(cid:276)na u(cid:276)ywa(cid:232) w statycznych kontekstach klas ogólnych ..................................................................................... 645 12.6.7. Obiektów klasy ogólnej nie mo(cid:276)na generowa(cid:232) ani przechwytywa(cid:232) ............ 646 12.6.8. Uwa(cid:276)aj na konflikty, które mog(cid:241) powsta(cid:232) po wymazaniu typów ............... 648 12.7. Zasady dziedziczenia dla typów ogólnych ........................................................... 649 12.8. Typy wieloznaczne ............................................................................................ 650 12.8.1. Ograniczenia nadtypów typów wieloznacznych ....................................... 652 12.8.2. Typy wieloznaczne bez ogranicze(cid:254) ........................................................ 655 12.8.3. Chwytanie typu wieloznacznego ............................................................ 655 12.9. Refleksja a typy ogólne .................................................................................... 658 12.9.1. Zastosowanie parametrów Class T do dopasowywania typów .............. 659 Informacje o typach generycznych w maszynie wirtualnej ........................ 659 12.9.2. Rozdzia(cid:196) 13. Kolekcje .............................................................................................................................665 Interfejsy kolekcyjne ......................................................................................... 665 13.1.1. Oddzielenie warstwy interfejsów od warstwy klas konkretnych ................ 666 13.1.2. Interfejsy Collection i Iterator ............................................................... 668 13.1. Kup książkęPoleć książkę 10 Java. Podstawy 13.2. Konkretne klasy kolekcyjne ............................................................................... 674 13.2.1. Listy powi(cid:241)zane ................................................................................. 674 13.2.2. Listy tablicowe .................................................................................. 684 13.2.3. Zbiór HashSet ................................................................................... 684 13.2.4. Zbiór TreeSet .................................................................................... 688 13.2.5. Porównywanie obiektów ..................................................................... 689 13.2.6. Kolejki Queue i Deque ....................................................................... 694 13.2.7. Kolejki priorytetowe ........................................................................... 696 13.2.8. Mapy ................................................................................................ 697 13.2.9. Specjalne klasy Set i Map .................................................................. 702 13.3. Architektura kolekcji ......................................................................................... 706 13.3.1. Widoki i obiekty opakowuj(cid:241)ce ............................................................. 709 13.3.2. Operacje zbiorcze .............................................................................. 717 13.3.3. Konwersja pomi(cid:246)dzy kolekcjami a tablicami ......................................... 718 13.4. Algorytmy ........................................................................................................ 718 13.4.1. Sortowanie i tasowanie ...................................................................... 720 13.4.2. Wyszukiwanie binarne ........................................................................ 722 13.4.3. Proste algorytmy ................................................................................ 723 13.4.4. Pisanie w(cid:228)asnych algorytmów .............................................................. 725 13.5. Stare kolekcje ................................................................................................. 726 13.5.1. Klasa Hashtable ................................................................................ 726 13.5.2. Wyliczenia ......................................................................................... 727 13.5.3. Mapy w(cid:228)asno(cid:264)ci ................................................................................. 728 13.5.4. Stosy ................................................................................................ 729 13.5.5. Zbiory bitów ...................................................................................... 729 Rozdzia(cid:196) 14. Wielow(cid:190)tkowo(cid:202)(cid:192) ...............................................................................................................735 14.1. Czym s(cid:241) w(cid:241)tki ................................................................................................. 736 14.1.1. Wykonywanie zada(cid:254) w osobnych w(cid:241)tkach ............................................ 741 14.2. Przerywanie w(cid:241)tków ......................................................................................... 746 14.3. Stany w(cid:241)tków .................................................................................................. 749 14.3.1. W(cid:241)tki NEW ........................................................................................ 749 14.3.2. W(cid:241)tki RUNNABLE ............................................................................... 750 14.3.3. W(cid:241)tki BLOCKED i WAITING ................................................................. 750 14.3.4. Zamykanie w(cid:241)tków ............................................................................ 752 14.4. W(cid:228)asno(cid:264)ci w(cid:241)tków ........................................................................................... 752 14.4.1. Priorytety w(cid:241)tków ............................................................................... 752 14.4.2. W(cid:241)tki demony ................................................................................... 753 14.4.3. Procedury obs(cid:228)ugi nieprzechwyconych wyj(cid:241)tków .................................... 754 14.5. Synchronizacja ................................................................................................ 756 14.5.1. Przyk(cid:228)ad sytuacji powoduj(cid:241)cej wy(cid:264)cig ................................................... 756 14.5.2. Wy(cid:264)cigi ............................................................................................. 760 14.5.3. Obiekty klasy Lock ............................................................................. 762 14.5.4. Warunki ............................................................................................ 765 14.5.5. S(cid:228)owo kluczowe synchronized ............................................................. 769 14.5.6. Bloki synchronizowane ....................................................................... 774 14.5.7. Monitor ............................................................................................. 775 14.5.8. Pola ulotne ....................................................................................... 776 14.5.9. Zmienne finalne ................................................................................ 777 14.5.10. Zmienne atomowe ............................................................................. 777 14.5.11. Zakleszczenia .................................................................................... 778 Kup książkęPoleć książkę Spis tre(cid:202)ci 11 14.5.12. Zmienne lokalne w(cid:241)tków .................................................................... 781 14.5.13. Testowanie blokad i odmierzanie czasu ............................................... 782 14.5.14. Blokady odczytu-zapisu ...................................................................... 783 14.5.15. Dlaczego metody stop i suspend s(cid:241) wycofywane .................................. 784 14.6. Kolejki blokuj(cid:241)ce ............................................................................................. 786 14.7. Kolekcje bezpieczne w(cid:241)tkowo ........................................................................... 794 14.7.1. Szybkie mapy, zbiory i kolejki ............................................................. 794 14.7.2. Tablice kopiowane przy zapisie ........................................................... 796 14.7.3. Starsze kolekcje bezpieczne w(cid:241)tkowo ................................................. 796 Interfejsy Callable i Future ................................................................................ 797 14.8. 14.9. Klasa Executors ............................................................................................... 802 14.9.1. Pule w(cid:241)tków ..................................................................................... 803 14.9.2. Planowanie wykonywania ................................................................... 807 14.9.3. Kontrolowanie grup zada(cid:254) .................................................................. 808 14.9.4. Szkielet rozga(cid:228)(cid:246)zienie-z(cid:228)(cid:241)czenie .......................................................... 809 14.10. Synchronizatory ............................................................................................... 812 14.10.1. Semafory ......................................................................................... 812 14.10.2. Klasa CountDownLatch ..................................................................... 813 14.10.3. Bariery ............................................................................................. 814 14.10.4. Klasa Exchanger ............................................................................... 814 14.10.5. Kolejki synchroniczne ........................................................................ 815 14.11. W(cid:241)tki a biblioteka Swing .................................................................................. 815 14.11.1. Uruchamianie czasoch(cid:228)onnych zada(cid:254) .................................................. 816 14.11.2. Klasa SwingWorker ........................................................................... 820 14.11.3. Zasada jednego w(cid:241)tku ...................................................................... 827 Dodatek A. S(cid:196)owa kluczowe Javy .........................................................................................................829 Skorowidz ..............................................................................................................................................831 Kup książkęPoleć książkę 12 Java. Podstawy Kup książkęPoleć książkę 7 Grafika W tym rozdziale: (cid:81) Wprowadzenie do biblioteki Swing (cid:81) Tworzenie ramek (cid:81) Pozycjonowanie ramek (cid:81) Wy(cid:286)wietlanie informacji w komponencie (cid:81) Figury 2D (cid:81) Kolory (cid:81) Kroje czcionek (cid:81) Wy(cid:286)wietlanie obrazów Do tej pory tworzyli(cid:286)my tylko programy, które pobiera(cid:225)y dane z klawiatury, przetwarza(cid:225)y je i wy(cid:286)wietla(cid:225)y wyniki w konsoli. Wi(cid:266)kszo(cid:286)(cid:252) u(cid:298)ytkowników oczekuje jednak nieco wi(cid:266)cej. Ani nowoczesne programy, ani strony internetowe nie dzia(cid:225)aj(cid:261) w ten sposób. W tym roz- dziale zaczynamy nauk(cid:266) pisania programów z graficznym interfejsem u(cid:298)ytkownika (GUI). Nauczymy si(cid:266) przede wszystkim ustawia(cid:252) rozmiar i po(cid:225)o(cid:298)enie okien na ekranie, wy(cid:286)wietla(cid:252) tekst pisany ró(cid:298)nymi krojami czcionki, wy(cid:286)wietla(cid:252) obrazy itd. Ca(cid:225)y zdobyty tu warsztat przyda nam si(cid:266) w kolejnych rozdzia(cid:225)ach, w których b(cid:266)dziemy tworzy(cid:252) ciekawe projekty. Dwa nast(cid:266)pne rozdzia(cid:225)y opisuj(cid:261) przetwarzanie zdarze(cid:276), takie jak wci(cid:286)ni(cid:266)cie klawisza na kla- wiaturze lub klikni(cid:266)cie przyciskiem myszy, oraz dodawanie do aplikacji takich elementów interfejsu jak menu i przyciski. Po zapoznaniu si(cid:266) z tymi trzema rozdzia(cid:225)ami b(cid:266)dziesz dys- ponowa(cid:252) wiedz(cid:261), która jest niezb(cid:266)dna do pisania aplikacji graficznych. Bardziej zaawanso- wane techniki zwi(cid:261)zane z programowaniem grafiki zosta(cid:225)y opisane w drugim tomie. Osoby zainteresowane wy(cid:225)(cid:261)cznie programowaniem po stronie serwera, które nie maj(cid:261) w planach pisania GUI, mog(cid:261) bezpiecznie pomin(cid:261)(cid:252) te rozdzia(cid:225)y. Kup książkęPoleć książkę 314 Java. Podstawy 7.1. Wprowadzenie do pakietu Swing W Java 1.0 udost(cid:266)pniono bibliotek(cid:266) klas o nazwie Abstract Window Toolkit (AWT), która dostarcza(cid:225)a podstawowe narz(cid:266)dzia do programowania GUI. Podstawowa biblioteka AWT przerzuca zadania dotycz(cid:261)ce tworzenia elementów interfejsu oraz obs(cid:225)ugi ich zachowa(cid:276) na natywne narz(cid:266)dzia GUI danej platformy (Windows, Solaris, Mac OS X itd.). Je(cid:286)li na przy- k(cid:225)ad przy u(cid:298)yciu oryginalnej biblioteki AWT umieszczono w oknie pole tekstowe, dane wprowadzane do niego by(cid:225)y w rzeczywisto(cid:286)ci obs(cid:225)ugiwane przez odpowiednik tego pola w systemie. Dzi(cid:266)ki temu program napisany w Javie móg(cid:225) teoretycznie dzia(cid:225)a(cid:252) na dowol- nej platformie, a jego styl by(cid:225) taki sam jak innych programów w danym systemie. St(cid:261)d wzi(cid:261)(cid:225) si(cid:266) slogan firmy Sun: „Napisz raz, uruchamiaj wsz(cid:266)dzie”. Metoda programowania oparta na odpowiednikach sprawdza(cid:225)a si(cid:266) w przypadku prostych aplikacji. Natomiast szybko wysz(cid:225)o na jaw, (cid:298)e napisanie wysokiej jako(cid:286)ci przeno(cid:286)nej biblio- teki graficznej opartej na natywnych elementach interfejsu u(cid:298)ytkownika jest niezwykle trud- nym zadaniem. Elementy interfejsu, jak menu, paski przewijania i pola tekstowe, mog(cid:261) si(cid:266) nieco ró(cid:298)ni(cid:252) na ró(cid:298)nych platformach. Przez to trudno by(cid:225)o stworzy(cid:252) program dzia(cid:225)aj(cid:261)cy identycznie w ró(cid:298)nych systemach. Ponadto niektóre (cid:286)rodowiska graficzne (jak np. X11/Motif) nie dysponuj(cid:261) tak szerok(cid:261) gam(cid:261) elementów interfejsu jak systemy Windows czy Mac OS X. Ten fakt ogranicza(cid:225) zasobno(cid:286)(cid:252) przeno(cid:286)nej biblioteki do tych elementów, które mo(cid:298)na zna- le(cid:296)(cid:252) na wszystkich platformach. W wyniku tego aplikacje GUI budowane na bazie AWT ust(cid:266)powa(cid:225)y wygl(cid:261)dem i funkcjonalno(cid:286)ci(cid:261) natywnym aplikacjom takich systemów jak Win- dows czy Mac OS X. Na domiar z(cid:225)ego na ró(cid:298)nych platformach biblioteka AWT zawiera(cid:225)a ró(cid:298)ne b(cid:225)(cid:266)dy. Programi(cid:286)ci narzekali, (cid:298)e musz(cid:261) testowa(cid:252) swoje aplikacje na wszystkich platformach, co z(cid:225)o(cid:286)liwie nazywano „napisz raz, testuj wsz(cid:266)dzie”. W 1996 roku firma Netscape stworzy(cid:225)a bibliotek(cid:266) GUI o nazwie IFC (ang. Internet Foundation Classes), w której zastosowano zupe(cid:225)nie inne podej(cid:286)cie. Elementy interfejsu u(cid:298)ytkownika, jak przyciski, menu itd., by(cid:225)y rysowane w pustym oknie. Rola systemu polega(cid:225)a tylko na wy(cid:286)wietlaniu okien i rysowaniu w nich. Dzi(cid:266)ki temu widgety firmy Netscape wygl(cid:261)da(cid:225)y i dzia(cid:225)a(cid:225)y zawsze tak samo, bez wzgl(cid:266)du na platform(cid:266). Firma Sun podj(cid:266)(cid:225)a wspó(cid:225)prac(cid:266) z Netscape w celu udoskonalenia tej technologii, czego owocem by(cid:225)a biblioteka o nazwie kodo- wej Swing. Biblioteka ta zosta(cid:225)a udost(cid:266)pniona w postaci dodatku w Java 1.1, a do biblioteki standardowej wcielono j(cid:261) w Java SE 1.2. Zgodnie z my(cid:286)l(cid:261) Duke’a Ellingtona, (cid:298)e „Nic nie ma znaczenia, je(cid:286)li jest pozbawione swingu”, Swing sta(cid:225) si(cid:266) oficjaln(cid:261) nazw(cid:261) zestawu narz(cid:266)dzi do tworzenia GUI, niewykorzystuj(cid:261)cego systemowych odpowiedników elementów. Swing wchodzi w sk(cid:225)ad Java Foundation Classes (JFC). Biblioteka JFC jest bardzo du(cid:298)a i zawiera wiele innych narz(cid:266)dzi poza Swingiem. Zali- czaj(cid:261) si(cid:266) do nich interfejsy API dost(cid:266)pno(cid:286)ci, grafiki dwuwymiarowej oraz obs(cid:225)ugi operacji przeci(cid:261)gania i upuszczania. Oczywi(cid:286)cie elementy interfejsu oparte na Swingu pojawiaj(cid:261) si(cid:266) z pewnym opó(cid:296)nieniem w stosunku do komponentów u(cid:298)ywanych przez AWT. Z naszego do(cid:286)wiadczenia wynika, (cid:298)e ró(cid:298)nica ta nie powinna stanowi(cid:252) problemu na (cid:298)adnym w miar(cid:266) niezbyt starym sprz(cid:266)cie. Z dru- giej strony argumenty przemawiaj(cid:261)ce za u(cid:298)yciem Swinga s(cid:261) przyt(cid:225)aczaj(cid:261)ce: (cid:81) Swing udost(cid:266)pnia bogaty i wygodny w u(cid:298)yciu zestaw elementów interfejsu u(cid:298)ytkownika. Kup książkęPoleć książkę Rozdzia(cid:196) 7. (cid:81) Grafika 315 Biblioteka Swing nie zast(cid:241)pi(cid:228)a AWT, tylko zosta(cid:228)a zbudowana w oparciu o architek- tur(cid:246) swojej poprzedniczki. Komponenty Swing oferuj(cid:241) znacznie wi(cid:246)ksze mo(cid:276)liwo(cid:264)ci. U(cid:276)ywaj(cid:241)c biblioteki Swing, zawsze korzysta si(cid:246) z podstawowej biblioteki AWT, zw(cid:228)aszcza przy obs(cid:228)udze zdarze(cid:254). Od tej pory pisz(cid:241)c „Swing”, mamy na my(cid:264)li klasy rysuj(cid:241)ce interfejs u(cid:276)ytkownika, a pisz(cid:241)c „AWT”, my(cid:264)limy o podstawowych mechanizmach okien, takich jak obs(cid:228)uga zdarze(cid:254). (cid:81) Swing w niewielkim stopniu zale(cid:298)y od platformy, dzi(cid:266)ki czemu jest mniej podatny na b(cid:225)(cid:266)dy zwi(cid:261)zane z danym systemem. (cid:81) Sposób dzia(cid:225)ania i wygl(cid:261)d elementów Swinga jest taki sam na ró(cid:298)nych platformach. Niemniej trzecia z wymienionych zalet mo(cid:298)e by(cid:252) uwa(cid:298)ana za wad(cid:266) — je(cid:286)li elementy inter- fejsu u(cid:298)ytkownika wygl(cid:261)daj(cid:261) tak samo na wszystkich platformach, to znaczy, (cid:298)e wygl(cid:261)daj(cid:261) inaczej ni(cid:298) elementy natywne, co z kolei oznacza, (cid:298)e b(cid:266)d(cid:261) s(cid:225)abiej znane u(cid:298)ytkownikom. W pakiecie Swing problem ten zosta(cid:225) rozwi(cid:261)zany w bardzo elegancki sposób. Programista pisz(cid:261)cy program przy u(cid:298)yciu klas Swing mo(cid:298)e nada(cid:252) mu specyficzny charakter. Rysunki 7.1 i 7.2 przedstawiaj(cid:261) ten sam program w stylu systemu Windows i GTK. Rysunek 7.1. Styl systemu Windows Dodatkowo firma Sun opracowa(cid:225)a niezale(cid:298)ny od platformy styl o nazwie Metal, który pó(cid:296)- niej przez specjalistów od marketingu przechrzczono na Java look and feel. Jednak wi(cid:266)k- szo(cid:286)(cid:252) programistów nadal u(cid:298)ywa okre(cid:286)lenia „Metal” i my równie(cid:298) trzymamy si(cid:266) tej konwencji w tej ksi(cid:261)(cid:298)ce. Ze wzgl(cid:266)du na krytyczne g(cid:225)osy kierowane pod adresem stylu Metal, który wed(cid:225)ug niektó- rych wydawa(cid:225) si(cid:266) zbyt ci(cid:266)(cid:298)ki, w Java SE 5.0 nieco go od(cid:286)wie(cid:298)ono (zobacz rysunek 7.3). Obecnie styl Metal obs(cid:225)uguje wiele motywów — ró(cid:298)nych wersji kolorystycznych i zestawów czcionek. Motyw domy(cid:286)lny nazywa si(cid:266) Ocean. Kup książkęPoleć książkę 316 Java. Podstawy Rysunek 7.2. Styl GTK Rysunek 7.3. Motyw Ocean stylu Metal W Java SE 6 poprawiono obs(cid:225)ug(cid:266) natywnego stylu systemu Windows i GTK. Aktualnie apli- kacje Swing obs(cid:225)uguj(cid:261) schematy kolorów i pulsuj(cid:261)ce przyciski oraz paski przewijania, które sta(cid:225)y si(cid:266) ostatnio modne. W Java 7 dodano nowy styl o nazwie Nimbus (rysunek 7.4), ale nie jest on domy(cid:286)lnie dost(cid:266)pny. W stylu tym wykorzystywana jest grafika wektorowa zamiast bitmapowej, dzi(cid:266)ki czemu interfejsy tworzone przy jego u(cid:298)yciu s(cid:261) niezale(cid:298)ne od rozmiaru ekranu. Niektórzy u(cid:298)ytkownicy wol(cid:261), aby aplikacje w Javie wygl(cid:261)da(cid:225)y tak jak inne programy na danej platformie, inni wol(cid:261) styl Metal, a jeszcze inni preferuj(cid:261) styl ca(cid:225)kiem innego producenta. Jak przekonamy si(cid:266) w rozdziale 8., umo(cid:298)liwienie u(cid:298)ytkownikom wyboru dowolnego stylu jest bardzo (cid:225)atwe. Kup książkęPoleć książkę Rysunek 7.4. Styl Nimbus Rozdzia(cid:196) 7. (cid:81) Grafika 317 W Javie mo(cid:276)liwe jest rozszerzenie istniej(cid:241)cego stylu, a nawet utworzenie ca(cid:228)kiem nowego. W tej ksi(cid:241)(cid:276)ce nie mamy wystarczaj(cid:241)co du(cid:276)o miejsca, aby opisa(cid:232) ten (cid:276)mudny proces polegaj(cid:241)cy na okre(cid:264)leniu sposobu rysowania ka(cid:276)dego komponentu. Jed- nak niektórzy programi(cid:264)ci pokusili si(cid:246) o to, zw(cid:228)aszcza ci, którzy przenosili programy w Javie na nietypowe platformy, jak terminale sklepowe czy urz(cid:241)dzenia kieszonkowe. Zbiór cieka- wych stylów mo(cid:276)na znale(cid:274)(cid:232) pod adresem http://www.javootoo.com/. W Java SE 5.0 wprowadzono styl o nazwie Synth, który upraszcza ca(cid:228)y ten proces. W Synth styl mo(cid:276)na definiowa(cid:232) poprzez dostarczenie obrazów i deskryptorów XML. Nie trzeba nic programowa(cid:232). Styl Napkin (http://napkinlaf.sourceforge.net) nadaje elementom interfejsu u(cid:276)yt- kownika wygl(cid:241)d przypominaj(cid:241)cy odr(cid:246)czne rysowanie. Wysy(cid:228)aj(cid:241)c do klienta utworzony w nim prototyp, dajemy wyra(cid:274)ny sygna(cid:228), (cid:276)e nie jest to jeszcze uko(cid:254)czony produkt. Programowanie interfejsu u(cid:276)ytkownika w Javie opiera si(cid:246) obecnie w wi(cid:246)kszo(cid:264)ci na pakiecie Swing. Jest tylko jeden godny uwagi wyj(cid:241)tek. (cid:263)rodowisko zintegrowane Eclipse u(cid:276)ywa zestawu narz(cid:246)dzi graficznych o nazwie SWT, który podobnie jak AWT odwzo- rowuje natywne komponenty na ró(cid:276)nych platformach. Artyku(cid:228)y na temat SWT mo(cid:276)na zna- le(cid:274)(cid:232) na stronie http://www.eclipse.org/articles/. Firma Oracle pracuje nad alternatywn(cid:241) technologi(cid:241) o nazwie JavaFX, która mo(cid:276)e w przy- sz(cid:228)o(cid:264)ci zast(cid:241)pi(cid:232) Swing. Je(cid:264)li chcesz dowiedzie(cid:232) si(cid:246) o niej wi(cid:246)cej, zajrzyj na stron(cid:246) http://www.oracle.com/technetwork/java/javafx/overview. Ka(cid:298)dy, kto pisa(cid:225) programy dla systemu Microsoft Windows w j(cid:266)zykach Visual Basic lub C#, wie, jak du(cid:298)ym u(cid:225)atwieniem s(cid:261) graficzne narz(cid:266)dzia do projektowania uk(cid:225)adu i edytory zaso- bów. Narz(cid:266)dzia te umo(cid:298)liwiaj(cid:261) zaprojektowanie ca(cid:225)ej wizualnej strony aplikacji oraz automa- tycznie generuj(cid:261) wi(cid:266)kszo(cid:286)(cid:252) (cz(cid:266)sto ca(cid:225)o(cid:286)(cid:252)) kodu GUI. Dla Javy równie(cid:298) dost(cid:266)pne s(cid:261) narz(cid:266)dzia Kup książkęPoleć książkę 318 Java. Podstawy wspomagaj(cid:261)ce budowanie GUI, ale naszym zdaniem, aby si(cid:266) nimi sprawnie pos(cid:225)ugiwa(cid:252), trzeba najpierw nauczy(cid:252) si(cid:266) robi(cid:252) to samodzielnie. Pozosta(cid:225)a cz(cid:266)(cid:286)(cid:252) tego rozdzia(cid:225)u zosta(cid:225)a po(cid:286)wi(cid:266)cona opisowi technik wy(cid:286)wietlania okien i rysowania w nich ró(cid:298)nych elementów. 7.2. Tworzenie ramki Okno najwy(cid:298)szego poziomu, tzn. takie, które nie jest zawarte w (cid:298)adnym innym oknie, nazywa si(cid:266) w Javie ramk(cid:261) (ang. frame). W bibliotece AWT dla tego typu okien utworzono klas(cid:266) o nazwie Frame. Wersja Swing tej klasy nosi nazw(cid:266) JFrame i j(cid:261) rozszerza. Ramka JFrame jest jednym z niewielu komponentów Swinga, które nie s(cid:261) rysowane w obszarze roboczym. W zwi(cid:261)zku z tym elementy dodatkowe (przyciski, pasek tytu(cid:225)u, ikony itd.) s(cid:261) rysowane przez system operacyjny, a nie klasy Swing. Nazwy wi(cid:246)kszo(cid:264)ci klas komponentów Swing zaczynaj(cid:241) si(cid:246) od litery J, np. JButton, JFrame itd. Istniej(cid:241) tak(cid:276)e klasy Button i Frame, ale s(cid:241) to komponenty AWT. Je(cid:264)li litera J zostanie przypadkowo pomini(cid:246)ta, program mo(cid:276)e przej(cid:264)(cid:232) kompilacj(cid:246) bez problemu, ale mieszanina komponentów AWT i Swing mo(cid:276)e spowodowa(cid:232) nietypowe zachowania lub wygl(cid:241)d aplikacji. W tym podrozdziale przejrzymy najpopularniejsze metody pracy z komponentem Swing o nazwie JFrame. Listing 7.1 przedstawia prosty program wy(cid:286)wietlaj(cid:261)cy na ekranie pust(cid:261) ramk(cid:266) widoczn(cid:261) na rysunku 7.5. Listing 7.1. simpleFrame/SimpleFrameTest.java package simpleFrame; import java.awt.*; import javax.swing.*; /** * @version 1.32 2007-06-12 * @author Cay Horstmann */ public class SimpleFrameTest { public static void main(String[] args) { EventQueue.invokeLater(new Runnable() { public void run() { SimpleFrame frame = new SimpleFrame(); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); } }); } } Kup książkęPoleć książkę Rysunek 7.5. Najprostsza widoczna ramka Rozdzia(cid:196) 7. (cid:81) Grafika 319 class SimpleFrame extends JFrame { private static final int DEFAULT_WIDTH = 300; private static final int DEFAULT_HEIGHT = 200; public SimpleFrame() { setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT); } } Przeanalizujemy powy(cid:298)szy program wiersz po wierszu. Klasy Swing znajduj(cid:261) si(cid:266) w pakiecie javax.swing. Nazwa pakietu javax oznacza, (cid:298)e jest to pakiet rozszerzaj(cid:261)cy Javy, a nie podstawowy. Swing jest uznawany za rozszerzenie ze wzgl(cid:266)- dów historycznych. Jest jednak dost(cid:266)pny w ka(cid:298)dej wersji Java SE od 1.2. Domy(cid:286)lny rozmiar ramki 0×0 jest raczej ma(cid:225)o atrakcyjny. Zdefiniowali(cid:28
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Java. Podstawy. Wydanie IX
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: