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:
Historia Javy, jej cechy szczególne i przygotowanie środowiska pracy
Podstawowe elementy kodu i zasady programowania obiektowego
Dziedziczenie, pakiety i interfejsy
Praca na plikach i operacje wejścia-wyjścia
Moduły i usługi
Technologia JavaFX
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ę:
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ą :