Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00313 004849 18761350 na godz. na dobę w sumie
Java. Przewodnik dla początkujących. Wydanie VII - książka
Java. Przewodnik dla początkujących. Wydanie VII - książka
Autor: Liczba stron: 600
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-4611-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).

Java jest jednym z kilku języków programowania, które niemal od początku istotnie wpływały na kształt programowania jako takiego. Już w początkowej fazie swojej historii, w 1995 r., Java spowodowała prawdziwą rewolucję w programowaniu. Stała się jedną z przyczyn skokowego rozwoju technologii internetowych i określiła nowe standardy projektowania języków programowania. Do dzisiaj zaliczana jest do awangardy, skupiając wokół siebie społeczność osób ciągle poszukujących innowacji. Oznacza to, że solidne podstawy programowania w Javie są znakomitą inwestycją dla każdego programisty, który swoją przyszłość wiąże z rozwojem najnowszych technologii informatycznych.

Ta książka jest kolejnym wydaniem wyjątkowego podręcznika, zaktualizowanym o informacje dotyczące Javy SE 9. Dzięki niej zdobędziesz solidne podstawy programowania w Javie, nawet jeśli nie masz żadnego przygotowania w tym kierunku. Poszczególne zagadnienia przedstawiono tu bardzo klarownie i przejrzyście, krok po kroku, uzupełniając je o liczne przykłady, testy sprawdzające i projekty do samodzielnej pracy. Najpierw zapoznasz się z podstawowymi informacjami, takimi jak kompilacja i uruchomienie programu w Javie. Następnie nauczysz się stosować słowa kluczowe i konstrukcje, które tworzą rdzeń tego języka. Stopniowo przejdziesz do zaawansowanych tematów, włączając w to programowanie wielowątkowe, typy sparametryzowane, wyrażenia lambda oraz moduły. Na końcu zapoznasz się z biblioteką Swing.

Najważniejsze zagadnienia:

Java: zdobądź solidne podstawy i twórz kod mistrzów!

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

Darmowy fragment publikacji:

Tytuł oryginału: Java: A Beginner’s Guide, Seventh Edition Tłumaczenie: Piotr Rajca ISBN: 978-83-283-4611-6 Original edition copyright © 2018 by McGraw-Hill Education. All rights reserved. Polish edition copyright © 2018 by HELION SA All rights reserved. Oracle and Java are registered trademarks of Oracle Corporation and/or its affiliates. All other trademarks are the property of their respective owners, and McGraw-Hill Education makes no claim of ownership by the mention of products that contain these marks. 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 the Publisher. 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. Autor oraz HELION SA dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. HELION SA 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/javpp7.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/javpp7 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ści O autorze ................................................................................................................................. 13 O redaktorze technicznym ...................................................................................................... 14 Wstęp ....................................................................................................................................... 15 1. Podstawy Javy .................................................................................................................. 21 Pochodzenie Javy .................................................................................................................................. 22 Java a języki C i C++ ............................................................................................................................. 22 Wpływ Javy na Internet ....................................................................................................................... 23 Java uprościła programowanie aplikacji internetowych ........................................................ 23 Aplety Javy .................................................................................................................................... 24 Bezpieczeństwo ............................................................................................................................ 24 Przenośność .................................................................................................................................. 25 Magiczny kod bajtowy ......................................................................................................................... 25 Coś więcej niż aplety ............................................................................................................................. 26 Terminologia Javy ................................................................................................................................. 27 Programowanie obiektowe .................................................................................................................. 27 Hermetyzacja ................................................................................................................................ 28 Polimorfizm .................................................................................................................................. 29 Dziedziczenie ................................................................................................................................ 29 Java Development Kit ........................................................................................................................... 29 Pierwszy prosty program ..................................................................................................................... 30 Wprowadzenie tekstu programu ............................................................................................... 31 Kompilowanie programu ........................................................................................................... 31 Pierwszy program wiersz po wierszu ........................................................................................ 32 Obsługa błędów składni ....................................................................................................................... 34 Drugi prosty program .......................................................................................................................... 34 Inne typy danych ................................................................................................................................... 36 Dwie instrukcje sterujące ..................................................................................................................... 38 Instrukcja if ................................................................................................................................... 38 Pętla for ......................................................................................................................................... 40 Bloki kodu .............................................................................................................................................. 41 Średnik i pozycja kodu w wierszu ....................................................................................................... 42 Wcięcia ................................................................................................................................................... 42 Słowa kluczowe języka Java ................................................................................................................. 44 Identyfikatory ........................................................................................................................................ 45 Biblioteki klas ........................................................................................................................................ 45 Test sprawdzający ................................................................................................................................. 45 Poleć książkęKup książkę 4 Java. Przewodnik dla początkujących 2. Typy danych i operatory ..................................................................................................47 Dlaczego typy danych są tak ważne .....................................................................................................47 Typy proste .............................................................................................................................................48 Typy całkowite ..............................................................................................................................48 Typy zmiennoprzecinkowe .........................................................................................................49 Znaki ...............................................................................................................................................50 Typ logiczny ............................................................................................................................................51 Literały .....................................................................................................................................................53 Literały szesnastkowe, ósemkowe i binarne ..............................................................................53 Specjalne sekwencje znaków .......................................................................................................53 Literały łańcuchowe .....................................................................................................................54 Zmienne ..................................................................................................................................................55 Inicjalizacja zmiennej ...................................................................................................................55 Dynamiczna inicjalizacja .............................................................................................................55 Zasięg deklaracji i czas istnienia zmiennych ......................................................................................56 Operatory ................................................................................................................................................58 Operatory arytmetyczne .......................................................................................................................58 Inkrementacja i dekrementacja ..................................................................................................59 Operatory relacyjne i logiczne .............................................................................................................60 Warunkowe operatory logiczne ...........................................................................................................62 Operator przypisania .............................................................................................................................63 Skrótowe operatory przypisania ..........................................................................................................63 Konwersje typów w instrukcjach przypisania ...................................................................................64 Rzutowanie typów niezgodnych ..........................................................................................................65 Priorytet operatorów .............................................................................................................................67 Wyrażenia ...............................................................................................................................................68 Konwersja typów w wyrażeniach ...............................................................................................68 Odstępy i nawiasy .........................................................................................................................70 Test sprawdzający ..................................................................................................................................70 3. Instrukcje sterujące .........................................................................................................71 Wprowadzanie znaków z klawiatury ..................................................................................................71 Instrukcja if .............................................................................................................................................72 Zagnieżdżanie instrukcji if ...................................................................................................................73 Drabinka if-else-if ..................................................................................................................................74 Instrukcja switch ....................................................................................................................................75 Zagnieżdżanie instrukcji switch ...........................................................................................................78 Pętla for ...................................................................................................................................................80 Wariacje na temat pętli for ...................................................................................................................81 Brakujące elementy ................................................................................................................................82 Pętla nieskończona .......................................................................................................................83 Pętle bez ciała ..........................................................................................................................................83 Deklaracja zmiennych sterujących wewnątrz pętli ...........................................................................84 Rozszerzona pętla for ............................................................................................................................85 Pętla while ...............................................................................................................................................85 Pętla do-while .........................................................................................................................................86 Przerywanie pętli instrukcją break ......................................................................................................90 Zastosowanie break jako formy goto ..................................................................................................91 Zastosowanie instrukcji continue ........................................................................................................95 Pętle zagnieżdżone .................................................................................................................................99 Test sprawdzający ..................................................................................................................................99 Poleć książkęKup książkę Spis treści 5 4. Wprowadzenie do klas, obiektów i metod ................................................................... 101 Podstawy klas ....................................................................................................................................... 101 Ogólna postać klasy ................................................................................................................... 102 Definiowanie klasy .................................................................................................................... 102 Jak powstają obiekty ........................................................................................................................... 105 Referencje obiektów i operacje przypisania .................................................................................... 105 Metody .................................................................................................................................................. 106 Dodajemy metodę do klasy Vehicle ........................................................................................ 106 Powrót z metody ................................................................................................................................. 108 Zwracanie wartości ............................................................................................................................. 109 Stosowanie parametrów ..................................................................................................................... 110 Dodajemy sparametryzowaną metodę do klasy Vehicle ...................................................... 112 Konstruktory ....................................................................................................................................... 117 Konstruktory z parametrami ............................................................................................................. 118 Dodajemy konstruktor do klasy Vehicle ......................................................................................... 119 Operator new ....................................................................................................................................... 120 Odzyskiwanie pamięci ........................................................................................................................ 120 Słowo kluczowe this ............................................................................................................................ 121 Test sprawdzający ............................................................................................................................... 122 5. Więcej typów danych i operatorów .............................................................................. 123 Tablice .................................................................................................................................................. 123 Tablice jednowymiarowe .......................................................................................................... 124 Tablice wielowymiarowe .................................................................................................................... 128 Tablice dwuwymiarowe ............................................................................................................ 128 Tablice nieregularne ........................................................................................................................... 129 Tablice o trzech i więcej wymiarach ........................................................................................ 130 Inicjalizacja tablic wielowymiarowych ................................................................................... 130 Alternatywna składnia deklaracji tablic ........................................................................................... 131 Przypisywanie referencji tablic ......................................................................................................... 131 Wykorzystanie składowej length ...................................................................................................... 132 Styl for-each pętli for .......................................................................................................................... 137 Iteracje w tablicach wielowymiarowych ................................................................................. 139 Zastosowania rozszerzonej pętli for ........................................................................................ 140 Łańcuchy znaków ................................................................................................................................ 141 Tworzenie łańcuchów ............................................................................................................... 141 Operacje na łańcuchach ............................................................................................................ 142 Tablice łańcuchów ..................................................................................................................... 144 Łańcuchy są niezmienne ........................................................................................................... 144 Stosowanie łańcuchów do sterowania instrukcją switch ..................................................... 145 Wykorzystanie argumentów wywołania programu ....................................................................... 146 Operatory bitowe ................................................................................................................................ 147 Operatory bitowe AND, OR, XOR i NOT ............................................................................. 147 Operatory przesunięcia ............................................................................................................. 151 Skrótowe bitowe operatory przypisania ................................................................................. 153 Operator ? ............................................................................................................................................ 155 Test sprawdzający ............................................................................................................................... 157 Poleć książkęKup książkę 6 Java. Przewodnik dla początkujących 6. Więcej o metodach i klasach ......................................................................................... 159 Kontrola dostępu do składowych klasy ........................................................................................... 159 Modyfikatory dostępu w Javie ................................................................................................. 160 Przekazywanie obiektów do metod .................................................................................................. 164 Sposób przekazywania argumentów ....................................................................................... 165 Zwracanie obiektów ............................................................................................................................ 167 Przeciążanie metod ............................................................................................................................. 169 Przeciążanie konstruktorów .............................................................................................................. 173 Rekurencja ........................................................................................................................................... 177 Słowo kluczowe static ......................................................................................................................... 178 Bloki static ................................................................................................................................... 181 Klasy zagnieżdżone i klasy wewnętrzne ........................................................................................... 184 Zmienne liczby argumentów ............................................................................................................. 186 Metody o zmiennej liczbie argumentów ................................................................................ 187 Przeciążanie metod o zmiennej liczbie argumentów ........................................................... 189 Zmienna liczba argumentów i niejednoznaczność ............................................................... 190 Test sprawdzający ............................................................................................................................... 191 7. Dziedziczenie ................................................................................................................. 193 Podstawy dziedziczenia ...................................................................................................................... 193 Dostęp do składowych a dziedziczenie ............................................................................................ 196 Konstruktory i dziedziczenie ............................................................................................................. 198 Użycie słowa kluczowego super do wywołania konstruktora klasy bazowej ............................. 199 Użycie słowa kluczowego super do dostępu do składowych klasy bazowej ............................... 203 Wielopoziomowe hierarchie klas ..................................................................................................... 206 Kiedy wywoływane są konstruktory? ............................................................................................... 208 Referencje klasy bazowej i obiekty klasy pochodnej ...................................................................... 209 Przesłanianie metod ........................................................................................................................... 213 Przesłanianie metod i polimorfizm .................................................................................................. 215 Po co przesłaniać metody? ................................................................................................................. 216 Zastosowanie przesłaniania metod w klasie TwoDShape .................................................... 217 Klasy abstrakcyjne ............................................................................................................................... 220 Słowo kluczowe final .......................................................................................................................... 223 final zapobiega przesłanianiu ................................................................................................... 223 final zapobiega dziedziczeniu ................................................................................................... 223 Użycie final dla zmiennych składowych ................................................................................. 224 Klasa Object ......................................................................................................................................... 225 Test sprawdzający ............................................................................................................................... 226 8. Pakiety i interfejsy ......................................................................................................... 227 Pakiety .................................................................................................................................................. 227 Definiowanie pakietu ................................................................................................................ 228 Wyszukiwanie pakietów i zmienna CLASSPATH ................................................................ 229 Prosty przykład pakietu ............................................................................................................ 229 Pakiety i dostęp do składowych ........................................................................................................ 230 Przykład dostępu do pakietu .................................................................................................... 231 Składowe chronione ........................................................................................................................... 232 Import pakietów .................................................................................................................................. 234 Biblioteka klas Java używa pakietów ................................................................................................ 235 Interfejsy ............................................................................................................................................... 235 Implementacje interfejsów ................................................................................................................ 237 Poleć książkęKup książkę Spis treści 7 Referencje interfejsu ........................................................................................................................... 240 Zmienne w interfejsach ...................................................................................................................... 245 Interfejsy mogą dziedziczyć ............................................................................................................... 246 Domyślne metody interfejsów .......................................................................................................... 247 Podstawowe informacje o metodach domyślnych ................................................................ 248 Praktyczny przykład metody domyślnej ................................................................................ 249 Problemy wielokrotnego dziedziczenia .................................................................................. 250 Stosowanie metod statycznych w interfejsach ................................................................................ 251 Stosowanie metod prywatnych w interfejsach ................................................................................ 252 Ostatnie uwagi o pakietach i interfejsach ........................................................................................ 253 Test sprawdzający ............................................................................................................................... 253 9. Obsługa wyjątków ......................................................................................................... 255 Hierarchia wyjątków ........................................................................................................................... 256 Podstawy obsługi wyjątków ............................................................................................................... 256 Słowa kluczowe try i catch ........................................................................................................ 256 Prosty przykład wyjątku ........................................................................................................... 257 Konsekwencje nieprzechwycenia wyjątku ...................................................................................... 259 Wyjątki umożliwiają obsługę błędów ..................................................................................... 260 Użycie wielu klauzul catch ................................................................................................................. 261 Przechwytywanie wyjątków klas pochodnych ................................................................................ 261 Zagnieżdżanie bloków try .................................................................................................................. 263 Generowanie wyjątku ......................................................................................................................... 264 Powtórne generowanie wyjątku ............................................................................................... 264 Klasa Throwable .................................................................................................................................. 265 Klauzula finally .................................................................................................................................... 267 Użycie klauzuli throws ....................................................................................................................... 268 Trzy dodatkowe możliwości wyjątków ............................................................................................ 269 Wyjątki wbudowane w Javę ............................................................................................................... 270 Tworzenie klas pochodnych wyjątków ............................................................................................ 272 Test sprawdzający ............................................................................................................................... 276 10. Obsługa wejścia i wyjścia .............................................................................................. 279 Strumienie wejścia i wyjścia .............................................................................................................. 280 Strumienie bajtowe i strumienie znakowe ...................................................................................... 280 Klasy strumieni bajtowych ................................................................................................................ 280 Klasy strumieni znakowych ............................................................................................................... 280 Strumienie predefiniowane ............................................................................................................... 281 Używanie strumieni bajtowych ......................................................................................................... 282 Odczyt wejścia konsoli .............................................................................................................. 282 Zapis do wyjścia konsoli ........................................................................................................... 284 Odczyt i zapis plików za pomocą strumieni bajtowych ................................................................ 285 Odczyt z pliku ............................................................................................................................. 285 Zapis w pliku .............................................................................................................................. 288 Automatyczne zamykanie pliku ....................................................................................................... 290 Odczyt i zapis danych binarnych ...................................................................................................... 292 Pliki o dostępie swobodnym .............................................................................................................. 296 Strumienie znakowe ........................................................................................................................... 298 Odczyt konsoli za pomocą strumieni znakowych ................................................................. 298 Obsługa wyjścia konsoli za pomocą strumieni znakowych ................................................. 301 Poleć książkęKup książkę 8 Java. Przewodnik dla początkujących Obsługa plików za pomocą strumieni znakowych ......................................................................... 302 Klasa FileWriter ......................................................................................................................... 302 Klasa FileReader ......................................................................................................................... 303 Zastosowanie klas opakowujących do konwersji łańcuchów numerycznych ............................ 304 Test sprawdzający ............................................................................................................................... 311 11. Programowanie wielowątkowe ..................................................................................... 313 Podstawy wielowątkowości ............................................................................................................... 313 Klasa Thread i interfejs Runnable .................................................................................................... 314 Tworzenie wątku ................................................................................................................................. 315 Usprawnienie i dwie modyfikacje ........................................................................................... 318 Tworzenie wielu wątków ................................................................................................................... 323 Jak ustalić, kiedy wątek zakończył działanie? ................................................................................. 326 Priorytety wątków ............................................................................................................................... 328 Synchronizacja .................................................................................................................................... 331 Synchronizacja metod ........................................................................................................................ 331 Synchronizacja instrukcji ................................................................................................................... 334 Komunikacja międzywątkowa .......................................................................................................... 336 Przykład użycia metod wait() i notify() .................................................................................. 337 Wstrzymywanie, wznawianie i kończenie działania wątków ....................................................... 341 Test sprawdzający ............................................................................................................................... 346 12. Typy wyliczeniowe, automatyczne opakowywanie, import składowych statycznych i adnotacje ................................................................. 347 Wyliczenia ............................................................................................................................................ 348 Podstawy wyliczeń ..................................................................................................................... 348 Wyliczenia są klasami ......................................................................................................................... 350 Metody values() i valueOf() ............................................................................................................... 350 Konstruktory, metody, zmienne instancji a wyliczenia ................................................................ 351 Dwa ważne ograniczenia .......................................................................................................... 353 Typy wyliczeniowe dziedziczą po klasie Enum .............................................................................. 353 Automatyczne opakowywanie .......................................................................................................... 358 Typy opakowujące .............................................................................................................................. 359 Podstawy automatycznego opakowywania ..................................................................................... 360 Automatyczne opakowywanie i metody .......................................................................................... 361 Automatyczne opakowywanie i wyrażenia ..................................................................................... 362 Przestroga ................................................................................................................................... 364 Import składowych statycznych ....................................................................................................... 364 Adnotacje (metadane) ........................................................................................................................ 366 Test sprawdzający ............................................................................................................................... 369 13. Typy sparametryzowane ................................................................................................ 371 Podstawy typów sparametryzowanych ............................................................................................ 372 Prosty przykład typów sparametryzowanych ................................................................................. 372 Parametryzacja dotyczy tylko typów obiektowych ............................................................... 375 Typy sparametryzowane różnią się dla różnych argumentów ............................................ 375 Klasa sparametryzowana o dwóch parametrach ................................................................... 376 Ogólna postać klasy sparametryzowanej ................................................................................ 377 Ograniczanie typów ............................................................................................................................ 377 Stosowanie argumentów wieloznacznych ....................................................................................... 380 Ograniczanie argumentów wieloznacznych ................................................................................... 382 Poleć książkęKup książkę Spis treści 9 Metody sparametryzowane ............................................................................................................... 384 Konstruktory sparametryzowane ..................................................................................................... 386 Interfejsy sparametryzowane ............................................................................................................ 386 Typy surowe i tradycyjny kod ........................................................................................................... 392 Wnioskowanie typów i operator diamentowy ................................................................................ 395 Wymazywanie ..................................................................................................................................... 396 Błędy niejednoznaczności .................................................................................................................. 396 Ograniczenia związane z typami sparametryzowanymi ............................................................... 397 Zakaz tworzenia instancji parametru typu ............................................................................. 397 Ograniczenia dla składowych statycznych ............................................................................. 397 Ograniczenia tablic sparametryzowanych ............................................................................. 398 Ograniczenia związane z wyjątkami ....................................................................................... 399 Dalsze studiowanie typów sparametryzowanych ........................................................................... 399 Test sprawdzający ............................................................................................................................... 399 14. Wyrażenia lambda i referencje metod .......................................................................... 401 Przedstawienie wyrażeń lambda ....................................................................................................... 402 Podstawowe informacje o wyrażeniach lambda .................................................................... 402 Interfejsy funkcyjne ................................................................................................................... 403 Wyrażenia lambda w działaniu ................................................................................................ 405 Blokowe wyrażenia lambda ...................................................................................................... 408 Sparametryzowane interfejsy funkcyjne .......................................................................................... 409 Wyrażenia lambda i przechwytywanie zmiennych ........................................................................ 415 Zgłaszanie wyjątków w wyrażeniach lambda .................................................................................. 416 Referencje metod ................................................................................................................................ 417 Referencje metod statycznych .................................................................................................. 417 Referencje metod instancyjnych .............................................................................................. 419 Referencje konstruktorów ................................................................................................................. 423 Predefiniowane interfejsy funkcyjne ................................................................................................ 425 Test sprawdzający ............................................................................................................................... 426 15. Moduły ........................................................................................................................... 429 Podstawowe informacje o modułach ............................................................................................... 430 Przykład prostego modułu ....................................................................................................... 431 Kompilowanie i uruchamianie przykładowej aplikacji ........................................................ 434 Dokładniejsze informacje o instrukcjach requires i exports ............................................... 435 java.base i moduły platformy ............................................................................................................ 436 Stary kod i moduł nienazwany .......................................................................................................... 437 Eksportowanie do konkretnego modułu ......................................................................................... 438 Wymagania przechodnie ................................................................................................................... 439 Stosowanie usług ................................................................................................................................. 443 Podstawowe informacje o usługach i dostawcach usług ...................................................... 444 Słowa kluczowe związane z usługami ..................................................................................... 444 Przykład stosowania usług i modułów ................................................................................... 445 Dodatkowe cechy modułów .............................................................................................................. 451 Moduły otwarte .......................................................................................................................... 451 Instrukcja opens ......................................................................................................................... 451 requires static .............................................................................................................................. 451 Dalsze samodzielne poznawanie modułów ..................................................................................... 452 Test sprawdzający ............................................................................................................................... 453 Poleć książkęKup książkę 10 Java. Przewodnik dla początkujących 16. Wprowadzenie do Swing ............................................................................................... 455 Pochodzenie i filozofia Swing ........................................................................................................... 456 Komponenty i kontenery ................................................................................................................... 457 Komponenty ............................................................................................................................... 458 Kontenery ................................................................................................................................... 458 Panele kontenerów szczytowych ............................................................................................. 459 Menedżery układu .............................................................................................................................. 459 Pierwszy program wykorzystujący Swing ....................................................................................... 460 Pierwszy program Swing wiersz po wierszu .......................................................................... 461 Obsługa zdarzeń w Swing .................................................................................................................. 464 Zdarzenia .................................................................................................................................... 464 Obiekty nasłuchujące ................................................................................................................ 465 Klasy zdarzeń i interfejsy obiektów nasłuchujących ............................................................. 465 Komponent JButton ........................................................................................................................... 465 Komponent JTextField ....................................................................................................................... 468 Komponent JCheckBox ..................................................................................................................... 471 Komponent JList ................................................................................................................................. 474 Wykorzystanie anonimowych klas wewnętrznych lub wyrażeń lambda do obsługi zdarzeń ......481 Test sprawdzający ............................................................................................................................... 482 17. Wprowadzenie do JavaFX ............................................................................................. 485 Podstawowe pojęcia JavaFX .............................................................................................................. 486 Pakiety JavaFX ............................................................................................................................ 486 Klasy Stage oraz Scene .............................................................................................................. 486 Węzły i graf sceny ...................................................................................................................... 487 Układy ......................................................................................................................................... 487 Klasa Application oraz metody cyklu życia ........................................................................... 487 Uruchamianie aplikacji JavaFX ............................................................................................... 488 Szkielet aplikacji JavaFX .................................................................................................................... 488 Kompilacja i uruchamianie programów JavaFX ............................................................................ 491 Wątek aplikacji .................................................................................................................................... 491 Prosta kontrolka JavaFX: Label ......................................................................................................... 491 Stosowanie przycisków i zdarzeń ..................................................................................................... 493 Podstawy obsługi zdarzeń ........................................................................................................ 493 Przedstawienie kontrolki Button ............................................................................................. 494 Przedstawienie obsługi zdarzeń i stosowania przycisków ................................................... 494 Trzy kolejne kontrolki JavaFX .......................................................................................................... 497 Pola wyboru ................................................................................................................................ 497 Listy .............................................................................................................................................. 501 Pola tekstowe .............................................................................................................................. 505 Przedstawienie efektów i transformacji ........................................................................................... 508 Efekty ........................................................................................................................................... 508 Transformacje ............................................................................................................................ 509 Prezentacja zastosowania efektów i transformacji ................................................................ 511 Co dalej? ............................................................................................................................................... 513 Test sprawdzający ............................................................................................................................... 514 Poleć książkęKup książkę Spis treści 11 A Rozwiązania testów sprawdzających ............................................................................ 515 Rozdział 1. Podstawy Javy .................................................................................................................. 515 Rozdział 2. Typy danych i operatory ................................................................................................ 517 Rozdział 3. Instrukcje sterujące ........................................................................................................ 518 Rozdział 4. Wprowadzenie do klas, obiektów i metod .................................................................. 520 Rozdział 5. Więcej typów danych i operatorów ............................................................................. 521 Rozdział 6. Więcej o metodach i klasach ......................................................................................... 524 Rozdział 7. Dziedziczenie .................................................................................................................. 528 Rozdział 8. Pakiety i interfejsy .......................................................................................................... 529 Rozdział 9. Obsługa wyjątków .......................................................................................................... 531 Rozdział 10. Obsługa wejścia i wyjścia ............................................................................................. 533 Rozdział 11. Programowanie wielowątkowe ................................................................................... 536 Rozdział 12. Typy wyliczeniowe, automatyczne opakowywanie, import składowych statycznych i adnotacje ............................................................. 538 Rozdział 13. Typy sparametryzowane .............................................................................................. 541 Rozdział 14. Wyrażenia lambda i referencje metod ....................................................................... 544 Rozdział 15. Moduły ........................................................................................................................... 547 Rozdział 16. Wprowadzenie do Swing ............................................................................................. 548 Rozdział 17. Wprowadzenie do JavaFX ........................................................................................... 552 B Komentarze dokumentacyjne ....................................................................................... 557 Znaczniki javadoc ............................................................................................................................... 557 @author ....................................................................................................................................... 558 {@code} ....................................................................................................................................... 558 @deprecated ................................................................................................................................ 558 {@docRoot} ................................................................................................................................. 559 @exception .................................................................................................................................. 559 @hidden ...................................................................................................................................... 559 {@index} ...................................................................................................................................... 559 {@inheritDoc} ............................................................................................................................ 559 {@link} ......................................................................................................................................... 559 {@linkplain} ................................................................................................................................ 560 {@literal} ...................................................................................................................................... 560 @param ....................................................................................................................................... 560 @provides .................................................................................................................................... 560 @return ........................................................................................................................................ 560 @see ............................................................................................................................................. 560 @since .......................................................................................................................................... 560 @throws ....................................................................................................................................... 561 @uses ........................................................................................................................................... 561 {@value} ....................................................................................................................................... 561 @version ...................................................................................................................................... 561 Ogólna postać komentarza dokumentacyjnego ............................................................................. 561 Wynik działania programu javadoc ................................................................................................. 561 Przykład użycia komentarzy dokumentacyjnych ........................................................................... 562 Poleć książkęKup książkę 12 Java. Przewodnik dla początkujących C Przegląd technologii Java Web Start ............................................................................. 563 Czym jest Java Web Start? ................................................................................................................. 563 Cztery kluczowe aspekty Java Web Start ......................................................................................... 564 Aplikacje Java Web Start wymagają pliku JAR ...................................................................... 564 Aplikacje Java Web Start są podpisywane cyfrowo .............................................................. 564 Java Web Start bazuje na JNLP ................................................................................................ 565 Tworzenie odnośnika do pliku JNLP ...................................................................................... 566 Eksperymenty z Java Web Start z wykorzystaniem lokalnego systemu plików ......................... 567 Utworzenie pliku JAR aplikacji ButtonDemo ....................................................................... 567 Utworzenie magazynu kluczy i podpisanie pliku ButtonDemo.jar ................................... 568 Utworzenie pliku JNLP dla aplikacji ButtonDemo .............................................................. 569 Utworzenie pliku HTML o nazwie StartBD.html ................................................................. 570 Dodanie pliku ButtonDemo.jnlp do listy wyjątków w aplikacji Java Control Panel ....... 570 Wykonanie aplikacji ButtonDemo z poziomu przeglądarki ............................................... 570 Uruchamianie aplikacji Java Web Start przy użyciu programu javaws ...................................... 571 Stosowanie technologii Java Web Start z apletami ........................................................................ 571 D Wprowadzenie do JShell ............................................................................................... 573 Podstawy JShell ................................................................................................................................... 573 Wyświetlanie, edycja i ponowne wykonywanie kodu ................................................................... 575 Dodanie metody .................................................................................................................................. 576 Utworzenie klasy ................................................................................................................................. 577 Stosowanie interfejsu .......................................................................................................................... 577 Przetwarzanie wyrażeń i wbudowane zmienne .............................................................................. 578 Importowanie pakietów ..................................................................................................................... 579 Wyjątki ................................................................................................................................................. 579 Inne polecenia JShell .......................................................................................................................... 580 Dalsze poznawanie możliwości JShell .............................................................................................. 581 E Więcej słów kluczowych języka Java ............................................................................. 583 Modyfikatory transient i volatile ...................................................................................................... 583 instanceof ............................................................................................................................................. 584 strictfp ................................................................................................................................................... 584 assert ..................................................................................................................................................... 584 Metody rodzime .................................................................................................................................. 585 Inna postać this ................................................................................................................................... 585 Skorowidz ....................................................................................................................... 587 Poleć książkęKup książkę ROZDZIAŁ17 Wprowadzenie do JavaFX W tym rozdziale poznasz:  podstawowe pojęcia JavaFX, takie jak obszar roboczy, scena, węzeł oraz graf sceny,  metody cyklu życia aplikacji JavaFX,  ogó
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Java. Przewodnik dla początkujących. Wydanie VII
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ą: