Java 8. Leksykon kieszonkowy 978-83-246-9631-4 [PDF]

Zitiervorschau

Tytuł oryginału: Java 8 Pocket Guide Tłumaczenie: Robert Górczyński ISBN: 978-83-246-9631-4 © 2014 Helion S.A. Authorized Polish translation of the English edition Java 8 Pocket Guide ISBN 9781491900864 © 2014 Gliesian, LLC. This translation is published and sold by permission of O’Reilly Media, Inc., which owns or controls all rights to publish and sell the same. 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 Wydawnictwo HELION 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. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: [email protected] WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/jav8lk_ebook Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.  Poleć książkę na Facebook.com

 Księgarnia internetowa

 Kup w wersji papierowej

 Lubię to! » Nasza społeczność

 Oceń książkę

Tę książkę dedykujemy naszej wspaniałej córce Ashleigh.

Spis treści

Wprowadzenie ...........................................................................................11

Część I Język . ................................................................ 15 Rozdział 1. Konwencje nazw . .................................................................. 17 Nazwy klas Nazwy interfejsów Nazwy metod Nazwy egzemplarzy i zmiennych statycznych Nazwy parametrów i zmiennych lokalnych Nazwy parametrów typów ogólnych Nazwy stałych Nazwy typów wyliczeniowych Nazwy pakietów Nazwy adnotacji Nazwy akronimów

17 17 18 18 18 18 19 19 19 20 20

Rozdział 2. Elementy leksykalne . ............................................................ 21 Unicode i ASCII Komentarze Słowa kluczowe Identyfikatory

21 23 24 24

5

Separatory Operatory Literały Sekwencje sterujące Symbole walut w Unicode

25 26 26 30 31

Rozdział 3. Typy proste .............................................................................33 Typy podstawowe Literały dla typów podstawowych Encje zmiennoprzecinkowe Promocja liczbowa dla typów podstawowych Klasy opakowujące Automatyczne pakowanie i rozpakowywanie

33 33 35 37 39 39

Rozdział 4. Typy odnośnikowe . ...............................................................43 Porównanie typów odnośnikowych i podstawowych Wartości domyślne Konwersja typów odnośnikowych Konwersja między typami podstawowymi i odnośnikowymi Przekazanie typu odnośnikowego metodzie Porównywanie typów odnośnikowych Kopiowanie typów odnośnikowych Alokacja pamięci i usuwanie nieużytków w przypadku typów odnośnikowych

44 44 46 47 47 48 51 52

Rozdział 5. Programowanie zorientowane obiektowo . ........................53 Klasy i obiekty Zmiennej długości lista argumentów Klasy i metody abstrakcyjne Statyczne dane składowe, metody, stałe i inicjalizatory Interfejsy Wyliczenia Typy adnotacji Interfejsy funkcjonalne

6



Spis treści

53 59 60 61 63 63 64 66

Rozdział 6. Polecenia i bloki .....................................................................67 Polecenie w postaci wyrażenia Polecenie puste Blok Polecenia warunkowe Polecenia iteracji Transfer kontroli Polecenie synchronized Polecenie assert Polecenia obsługi wyjątków

67 68 68 68 70 72 73 73 74

Rozdział 7. Obsługa wyjątków .................................................................75 Hierarchia wyjątku Sprawdzane i niesprawdzane wyjątki oraz błędy Najczęstsze sprawdzane i niesprawdzane wyjątki oraz błędy Słowa kluczowe związane z obsługą wyjątków Proces obsługi wyjątków Zdefiniowanie własnej klasy wyjątku Wyświetlanie informacji o wyjątku

75 76 77 79 84 84 85

Rozdział 8. Modyfikatory w Javie . ..........................................................87 Modyfikatory dostępu Inne modyfikatory (niedotyczące dostępu)

88 88

Część II Platforma . ......................................................... 91 Rozdział 9. Java SE ....................................................................................93 Najczęściej używane biblioteki API Javy SE

93

Rozdział 10. Podstawy programowania . ............................................... 105 JRE JDK Struktura programu w Javie Narzędzia wiersza poleceń Classpath

105 105 106 108 114

Spis treści



7

Rozdział 11. Zarządzanie pamięcią . ........................................................115 Rodzaje mechanizmów usuwania nieużytków Narzędzia przeznaczone do zarządzania pamięcią Opcje w wierszu poleceń Zmiana wielkości stosu wirtualnej maszyny Javy Przestrzeń Metaspace Współpraca z mechanizmem GC

115 117 118 121 121 121

Rozdział 12. Podstawowe wejście i wyjście .......................................... 123 Standardowe strumienie in, out i err Hierarchia klas dla podstawowego wejścia i wyjścia Odczyt i zapis pliku Odczyt i zapis gniazda Serializacja Tworzenie archiwum ZIP i rozpakowywanie plików

123 124 124 127 128 129

Rozdział 13. Nowe API wejścia-wyjścia (NIO.2) . ...................................131 Interfejs Path Klasa Files Funkcje dodatkowe

131 132 133

Rozdział 14. Współbieżność . ................................................................. 135 Tworzenie wątków Stany wątku Priorytety wątku Najczęściej używane metody dotyczące wątków Synchronizacja Narzędzia współbieżności

135 136 136 137 138 139

Rozdział 15. Framework Collections . ..................................................... 143 Interfejs Collection Implementacje Metody frameworka Collection Algorytmy klasy Collections Efektywność algorytmu Interfejs funkcjonalny Comparator 8



Spis treści

143 144 144 145 145 146

Rozdział 16. Framework Generics . ......................................................... 149 Klasy i interfejsy frameworka Generics Konstruktory wykorzystujące framework Generics Zasada zastępowania Parametry typu, znaki wieloznaczne i granice Zasada get i put Specjalizacja typów generycznych Metody frameworka Generics w niezmodyfikowanych typach

149 150 151 151 152 153 154

Rozdział 17. API skryptowe Javy . ........................................................... 155 Języki skryptowe Implementacje silnika skryptów Konfiguracja języków skryptowych i silników

155 155 157

Rozdział 18. API daty i godziny . ..............................................................161 Wsteczna zgodność Kalendarze regionalne Kalendarz ISO

162 162 162

Rozdział 19. Wyrażenia lambda . ........................................................... 169 Podstawy wyrażeń lambda Interfejsy funkcjonalne specjalnego przeznaczenia Interfejsy funkcjonalne ogólnego przeznaczenia Zasoby dotyczące wyrażeń lambda

169 171 172 174

Dodatki . ........................................................................ 175 A API Fluent ............................................................................................177 B Narzędzia firm trzecich . ................................................................... 179 C Podstawy UML . ................................................................................. 189 Skorowidz . .............................................................................................. 199

Spis treści



9

10



Spis treści

Wprowadzenie

Leksykon kieszonkowy, który trzymasz w rękach, został opracowany w taki sposób, aby stać się Twoim prawdziwym kompanem. Zawiera krótkie omówienie standardowych funkcji języka programowania Java i jego platformy. Znajdziesz tutaj informacje niezbędne podczas tworzenia lub debugowania programów Javy, a także użyteczne przykłady programistyczne, tabele, rysunki i listy. W leksykonie poruszono różne tematy, między innymi API skryptowe Javy, narzędzia opracowane przez firmy trzecie oraz podstawy zunifikowanego języka modelowania (ang. Unified Modeling Language, UML). Materiał zaprezentowany w książce pomaga w przygotowaniach do egzaminu Oracle Certified Associate Java, SE 7 Programmer I. Jeżeli rozważasz przystąpienie do egzaminu i zdobycie wymienionego certyfikatu, warto zakupić także książkę OCA Java SE 7 Programmer I Study Guide (Exam 1Z0-803) napisaną przez Edwarda Finegana i Roberta Liguori (McGraw-Hill Osborne Media, 2012). Informacje przedstawione w niniejszej książce dotyczą wydań Javy aż do Java SE 8. Podstawowe różnice między tym i wcześniejszym wydaniem leksykonu (poświęconym Javie 7) wynikają z dodania rozdziałów dotyczących API daty i godziny (API „Date and Time”) oraz wyrażeń lambda.

Struktura książki Książka została podzielona na trzy części. Pierwsza składa się z rozdziałów od 1. do 8., w których znajdziesz szczegółowe informacje o języku programowania Java zgodnym ze specyfikacją JLS (ang. Java Language Specification). 11

Część druga to rozdziały od 9. do 19., w których dość szczegółowo omówiono komponenty platformy Javy i poruszono związane z tym tematy. Z kolei część trzecia to dodatki, w których przedstawiono narzędzia opracowane przez firmy trzecie oraz krótkie wprowadzenie do języka UML.

Konwencje zastosowane w książce W tej książce zastosowano następujące konwencje typograficzne: Kursywa Wskazuje na nowe pojęcia, adresy URL i e-mail, nazwy plików, rozszerzenia plików itd. Czcionka o stałej szerokości

Użyta w przykładowych fragmentach kodu, a także w samym tekście, aby odwołać się do pewnych poleceń bądź innych elementów programistycznych, takich jak nazwy zmiennych lub funkcji, baz danych, typów danych, zmiennych środowiskowych, poleceń i słów kluczowych.

Pogrubiona czcionka o stałej szerokości

Użyta w celu wyeksponowania poleceń bądź innego tekstu, który powinien być wprowadzony przez czytelnika. Pochylona czcionka o stałej szerokości

Wskazuje tekst, który powinien być zastąpiony wartościami podanymi przez użytkownika bądź wynikającymi z kontekstu. Taka ikona oznacza wskazówkę, sugestię lub ogólną uwagę.

Taka ikona oznacza ostrzeżenie.

Autorzy Robert James Liguori jest dyrektorem Gliesian LLC (http://gliesians.com/), certyfikowanym ekspertem Oracle i zajmuje się obsługą wielu opartych na Javie aplikacji przeznaczonych do zarządzania ruchem lotniczym oraz związanych z bezpieczeństwem. Z kolei Patricia Liguori jest wszechstronnym inżynierem 12



Wprowadzenie

wielu systemów informatycznych w The MITRE Corporation (http://www. mitre.org/). Od roku 1994 zajmuje się opracowywaniem działających w czasie rzeczywistym systemów zarządzania ruchem lotniczym oraz systemów informatycznych powiązanych z lotnictwem.

Podziękowania Specjalne podziękowania składamy naszej redaktor Meghan Blanchette, której nadzór i współpraca okazały się nieocenione podczas prac nad leksykonem. Podziękowania składamy Michaelowi Loukidesowi (korektor techniczny początkowej wersji leksykonu kieszonkowego), recenzentowi technicznemu Ryanowi Cuprakowi, a także wielu różnym pracownikom wydawnictwa O’Reilly, naszej rodzinie i przyjaciołom. Ponownie chcemy podziękować wszystkim osobom zaangażowanym w przygotowanie pierwszego wydania leksykonu oraz pracującym nad wydaniem dotyczącym Javy 7. Co najważniejsze, dziękujemy czytelnikom za korzystanie z niniejszego leksykonu i wybór języka Java. Zachęcamy do umieszczania w serwisie Tumblr (http://javapocketguide.tumblr.com/) własnych zdjęć z książką. Będzie nam bardzo miło przekonać się, kto oraz w jakich okolicznościach (na przykład na wakacjach) czyta tę książkę.

Podziękowania



13

14



Wprowadzenie

CZĘŚĆ I

Język

15

16



Rozdział 1. Konwencje nazw

ROZDZIAŁ 1.

Konwencje nazw

Konwencje nazw są używane w celu zapewnienia programom Javy większej czytelności. Bardzo ważne jest stosowanie zrozumiałych i jednoznacznych nazw składających się z tak zwanych liter Javy.

Nazwy klas Nazwa klasy powinna być rzeczownikiem, ponieważ przedstawia „rzecz” lub „obiekt”. Należy stosować tak zwaną notację camelCase, w której tylko pierwsza litera każdego słowa jest duża, na przykład: public class Fish {...}

Nazwy interfejsów Jeżeli interfejs oferuje pewne możliwości, wtedy jego nazwa powinna być przymiotnikiem kończącym się na „able” lub „ible”. W przeciwnym razie nazwa powinna być rzeczownikiem. W nazwach interfejsu należy stosować tę samą konwencję wielkości liter, jak w nazwach klas: public interface Serializable {...} public interface SystemPanel {...}

17

Nazwy metod Nazwy metod powinny zawierać czasownik, ponieważ wskazują na podjęcie akcji przez obiekt. Należy zastosować małe i duże litery — na początku nazwy mała litera, a pierwsza litera każdego kolejnego słowa musi być duża. W nazwach można stosować rzeczowniki i przymiotniki. public void locate() {...} // Rzeczownik. public String getWayPoint() {...} // Przymiotnik i rzeczownik.

Nazwy egzemplarzy i zmiennych statycznych Nazwy egzemplarzy i zmiennych statycznych powinny być rzeczownikami. W tych nazwach należy stosować taką samą konwencję nazw, jak w przypadku metod: private String wayPoint;

Nazwy parametrów i zmiennych lokalnych Nazwa parametru i zmiennej lokalnej powinna być opisowym, zapisanym małymi literami słowem, akronimem lub skrótem. Jeżeli konieczne jest użycie w nazwie kilku słów, wtedy należy zastosować taką samą konwencję nazw, jak w przypadku metod: public void printHotSpots(ArrayList spotList) { int counter = 0; for (String hotSpot : spotList) { System.out.println("Hot Spot #" + ++counter + ": " + hotSpot); } }

Nazwy zmiennych tymczasowych mogą być pojedynczymi literami, na przykład i, j, k, m i n dla liczb całkowitych oraz c, d i e dla znaków.

Nazwy parametrów typów ogólnych Nazwy parametrów typów ogólnych powinny być zapisane dużymi, pojedynczymi literami. Na przykład, dla typu zaleca się użycie litery T.

18



Rozdział 1. Konwencje nazw

Framework Collections intensywnie korzysta z typów ogólnych. Na przykład, litera E jest używana dla elementów kolekcji, S dla komponentów wczytujących usługi, a K i V do mapowania kluczy i wartości: public interface Map { V put(K key, V value); }

Nazwy stałych Nazwy stałych powinny być zapisane dużymi literami. Jeżeli zachodzi potrzeba użycia w nazwie wielu słów, wtedy należy je rozdzielić znakami podkreślenia: public static final int MAX_DEPTH = 200;

Nazwy typów wyliczeniowych Nazwy typów wyliczeniowych powinny stosować taką samą konwencję nazw, jak w przypadku klas. Nazwy poszczególnych obiektów typu wyliczeniowego należy zapisywać dużymi literami: enum Battery {CRITICAL, LOW, CHARGED, FULL}

Nazwy pakietów Nazwa pakietu powinna być unikalna i składać się z jedynie małych liter. Jeśli zachodzi potrzeba, wtedy można użyć znaków podkreślenia: package com.oreilly.fish_finder;

Publicznie dostępne pakiety powinny mieć nazwę w postaci odwróconego adresu domeny internetowej organizacji. W takim przypadku nazwa rozpoczyna się od pojedynczego słowa w postaci nazwy domeny najwyższego poziomu (na przykład com, net, org lub edu), a następnie mamy nazwę organizacji i projektu bądź też oddziału. (Pakiety wewnętrzne z reguły mają nazwę zgodną z konwencją stosowaną w projekcie). Nazwy pakietów rozpoczynające się od słowa java lub javax są zastrzeżone i mogą być używane jedynie w celu dostarczenia implementacji bibliotek klas Javy.

Nazwy pakietów



19

Nazwy adnotacji Nazwy adnotacji mogą być przedstawiane na wiele różnych sposobów w API Javy SE dla predefiniowanych typów adnotacji [przymiotnik | czasownik] [rzeczownik]: @Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface FunctionalInterface {}

Nazwy akronimów Podczas stosowania w nazwie akronimu tylko pierwsza litera akronimu powinna być duża i tylko wtedy, gdy użycie dużej litery jest odpowiednie: public String getGpsVersion() {...}

20



Rozdział 1. Konwencje nazw

ROZDZIAŁ 2.

Elementy leksykalne

Kod źródłowy w języku Java składa się ze słów i symboli, nazywanych elementami leksykalnymi lub po prostu tokenami. Elementy leksykalne w Javie obejmują znaki końca wiersza, znaki odstępu, komentarze, słowa kluczowe, identyfikatory, separatory, operatory i literały. Słowa i symbole w języku programowania Java składają się ze znaków zakodowanych jako Unicode.

Unicode i ASCII Opracowany i obsługiwany przez Unicode Consortium standard Unicode to uniwersalny zestaw znaków, w którym pierwsze 128 znaków jest dokładnie takich samych, jak w standardzie ASCII (ang. American Standard Code for Information Interchange). Unicode zapewnia unikalną liczbę kodową dla znaku stosowaną na wszystkich platformach, w programach i językach programowania. Java SE 8 używa Unicode w wersji 6.2.0; więcej informacji na temat podanej wersji standardu znajdziesz na stronie http://www.unicode.org/versions/ Unicode6.2.0/. W Javie SE 7 zastosowano Unicode 6.0.0, w Javie SE 6 i J2SE 5.0 użyto Unicode 4.0. W języku Java komentarze, identyfikatory i literały w postaci ciągów tekstowych nie są ograniczone jedynie do znaków ASCII. Wszystkie pozostałe elementy danych wejściowych w Javie są dostarczane jako znaki standardu ASCII.

21

Konkretna wersja standardu Unicode używana przez określoną wersję platformy Java jest podana w klasie Character API Javy. Informacje dotyczące kodów znaków Unicode dla skryptów, symboli i znaków przestankowych znajdziesz na stronie http://unicode.org/charts/.

Drukowane znaki ASCII W standardzie ASCII liczba kodowa 32 (spacja) i od 33 do 126 (litery, cyfry, znaki przestankowe i kilka innych) są przeznaczone dla tak zwanych znaków drukowanych. W tabeli 2.1 wymieniono wartości dziesiętne i odpowiadające im znaki standardu ASCII. Tabela 2.1. Drukowane znaki ASCII 32 SP

48 0

64 @

80 P

96 '

112 p

33 !

49 1

65 A

81 Q

97 a

113 q

34 "

50 2

66 B

82 R

98 b

114 r

35 #

51 3

67 C

83 S

99 c

115 s

36 $

52 4

68 D

84 T

100 d

116 t

37 %

53 5

69 E

85 U

101 e

117 u

38 &

54 6

70 F

86 V

102 f

118 v

39 '

55 7

71 G

87 W

103 g

119 w

40 (

56 8

72 H

88 X

104 h

120 x

41 )

57 9

73 I

89 Y

105 i

121 y

42 *

58 :

74 J

90 Z

106 j

122 z

43 +

59 ;

75 K

91 [

107 k

123 {

44 ,

60


78 N

94 ^

110 n

126 ~

47 /

63 ?

79 O

95 _

111 o

Niedrukowane znaki ASCII Liczby kodowe od 0 do 31 oraz 127 są w standardzie ASCII zarezerwowane dla tak zwanych znaków sterujących. W tabeli 2.2 wymieniono wartości dziesiętne i odpowiadające im znaki sterujące standardu ASCII.

22



Rozdział 2. Elementy leksykalne

Tabela 2.2. Niedrukowane znaki ASCII 00 NUL

07 BEL

14 SO

21 NAK

28 FS

01 SOH

08 BS

15 SI

22 SYN

29 GS

02 STX

09 HT

16 DLE

23 ETB

30 RS

03 ETX

10 NL

17 DC1

24 CAN

31 US

04 EOT

11 VT

18 DC2

25 EM

127 DEL

05 ENQ

12 NP

19 DC3

26 SUB

06 ACK

13 CR

20 DC4

27 ESC

Liczba kodowa 10 w standardzie ASCII oznacza znak nowego wiersza (wysuw wiersza). Z kolei liczba kodowa 13 w ASCII oznacza znak powrotu do początku wiersza.

Komentarze Komentarz mieszczący się w jednym wierszu rozpoczyna się od dwóch ukośników i kończy natychmiast po znaku końca wiersza: // Komentarz w pojedynczym wierszu.

Z kolei komentarz obejmujący wiele wierszy rozpoczyna się od ukośnika i gwiazdki, a kończy znakami gwiazdki i ukośnika. Pojedyncze gwiazdki między znacznikami początku i końca komentarza są używane w celu zapewnienia eleganckiego formatowania — zwykle są stosowane, ale nie zaliczają się do wymaganych: /* * Komentarz może obejmować wiele wierszy, * jak w pokazanym przykładzie. */

Komentarz Javadoc jest przetwarzany przez narzędzie javadoc w celu wygenerowania dokumentacji API w formacie HTML. Komentarz Javadoc musi zaczynać się od ukośnika i dwóch gwiazdek i kończyć gwiazdką wraz z ukośnikiem. Na stronie dokumentacji przygotowanej i udostępnionej przez Oracle (http://www.oracle.com/technetwork/java/javase/documentation/index-jsp135444.html) znajdziesz więcej informacji dotyczących narzędzia i komentarzy Javadoc. /** To jest komentarz Javadoc. */

W Javie komentarze nie mogą być zagnieżdżone: /* Taki komentarz /* jest niedozwolony */ w Javie. */

Komentarze



23

Słowa kluczowe W tabeli 2.3 wymieniono słowa kluczowe Javy. Dwa z nich (const i goto) są zarezerwowane, ale nie są używane w języku programowania Java. W Javie 5.0 wprowadzono słowo kluczowe enum. Tabela 2.3. Słowa kluczowe w Javie abstract

double

int

super

assert

else

interface

switch

boolean

enum

long

synchronized

break

extends

native

this

byte

final

new

throw

case

finally

package

throws

catch

float

private

transient

char

for

protected

try

class

if

public

void

const

goto

return

volatile

continue

implements

short

while

default

import

static

do

instanceof

strictfp

W programach Javy słowa kluczowe nie mogą być używane jako identyfikatory.

Czasami literały true, false i null są błędnie uznawane za słowa kluczowe. To nie są słowa kluczowe, ale zarezerwowane literały.

Identyfikatory Identyfikator w Javie to nazwa, którą programista nadaje klasie, metodzie, zmiennej itd. Identyfikatory nie mogą mieć takiej samej sekwencji znaków Unicode, jak w przypadku jakiegokolwiek słowa kluczowego, boolean lub literału null.

24



Rozdział 2. Elementy leksykalne

W Javie identyfikatory są tworzone za pomocą tak zwanych liter Javy. Wspomniana litera Javy to znak, dla którego wartością zwrotną wywołania Character.isJavaIdentifierStart(int) jest true. W przypadku standardu ASCII litery Javy są ograniczone do znaku dolara ($), znaku podkreślenia (_) oraz małych i dużych liter. Cyfry również mogą być używane w identyfikatorach, ale dopiero po pierwszym znaku: // Przykłady prawidłowych identyfikatorów. class TestDriver {...} String testVariable; int _testVariable; Long $testVariable; startTest(testVariable1);

Informacje dotyczące konwencji nazw przedstawiono w rozdziale 1.

Separatory Kilka znaków ASCII jest przeznaczonych do ograniczania części programu, czyli są stosowane w charakterze separatorów. Znaki (), {} i [] są używane parami: () {} [] :: : ; , . ->

W tabeli 2.4 przedstawiono nazewnictwo, jakie może być stosowane w odniesieniu do separatorów w postaci różnego rodzaju nawiasów. Pierwsza z nazw wymienionych dla poszczególnych nawiasów to zwykle ta, która jest używana w specyfikacji języka Java. Tabela 2.4. Stosowane w Javie separatory w postaci nawiasów Nawias

Nazewnictwo

Użycie

()

Nawiasy, nawiasy zaokrąglone, nawiasy owalne, nawiasy okrągłe.

Określają pierwszeństwo w wyrażeniach arytmetycznych, wskazują rzutowane typy oraz zawierają argumenty metody.

{}

Nawiasy klamrowe, nawiasy kręcone, nawiasy fantazyjne, nawiasy falowane i nawiasy zwariowane.

Zawierają blok kodu i obsługują tablice.

[]

Nawiasy kwadratowe, nawiasy zamknięte i nawiasy pudełkowe.

Obsługują i inicjalizują tablice.

Nawiasy ostre, nawiasy diamentowe i nawiasy jodełkowe.

Zawierają typy ogólne.

Separatory



25

Znaki guillemet1 (« i ») są używane do określania stereotypów w języku UML.

Operatory Operatory przeprowadzają operację na maksymalnie trzech operandach i zwracają wynik. Dostępne w Javie operatory to między innymi operator przypisania, arytmetyczny, porównania, bitowy, inkrementacji i dekrementacji oraz klasy i obiektu. W tabeli 2.5 wymieniono operatory Javy z uwzględnieniem ich pierwszeństwa (operatory o największym pierwszeństwie znajdują się na początku tabeli). Każdy operator został pokrótce opisany i wskazano jego kierunek działania: od lewej do prawej (L → P) lub od prawej do lewej (P → L).

Literały Literały w kodzie źródłowym przedstawiają wartości. Począwszy od wydania Java SE 7, w literałach liczbowych dozwolone jest stosowanie znaków podkreślenia, co zwiększa czytelność kodu. Znaki podkreślenia mogą być umieszczane między poszczególnymi fragmentami liczby i są ignorowane w trakcie uruchamiania programu. Więcej informacji dotyczących podstawowych typów literałów znajdziesz w rozdziale 3.

Literały boolowskie Literały boolowskie są wyrażone w postaci true lub false: boolean isReady = true; boolean isSet = new Boolean(false); // Rozpakowana. boolean isGoing = false;

Literały znakowe Literał znakowy jest pojedynczym znakiem lub sekwencją sterującą ujętą w apostrofy. Niedozwolone jest używanie znaków końca wiersza:

1

To jest para znaków przestankowych używanych w charakterze znaków cytowania w języku francuskim oraz innych językach europejskich — przyp. tłum.

26



Rozdział 2. Elementy leksykalne

Tabela 2.5. Operatory w Javie Operator

Opis

Kierunek działania

1

++, --

postinkrementacja, postdekrementacja

P→L

2

++, --

preinkrementacja, predekrementacja

P→L

+, -

jednoargumentowy plus i minus

P→L

~

bitowe uzupełnienie

P→L

!

bitowe NOT

P→L

new

utworzenie obiektu

P→L

Pierwszeństwo

3

(typ)

rzutowanie typu

P→L

4

*, /, %

mnożenie, dzielenie i reszta z dzielenia

L→P

5

+, -

dodawanie, odejmowanie

L→P

+

łączenie ciągów tekstowych

L→P

6

, >>>

przesunięcie w lewo, przesunięcie w prawo, przesunięcie w prawo bez znaku

L→P

7

=

mniejszy niż, mniejszy niż lub równy, większy niż, większy niż lub równy

L→P

instanceof

typ porównania

==, !=

równość i nierówność wartości

L→P

==, !=

odniesienie do równości i nierówności

L→P

&

boolowskie AND

L→P

&

bitowe AND

L→P

^

boolowskie XOR

L→P

^

bitowe XOR

L→P

|

boolowskie OR

L→P

8 9 10 11

L→P

|

bitowe OR

L→P

12

&&

logiczne AND

L→P

13

||

logiczne OR

L→P

14

?:

trójargumentowy operator warunkowy

L→P

15

=, +=, -=, *=, /=, %=, &=, ^=

operatory przypisania

L→P

char charValue1 = 'a'; // Apostrof. Character charValue2 = new Character ('\'');

Literały



27

Literały w postaci liczb całkowitych Typy liczb całkowitych (byte, short, int i long) można wyrażać w postaci liczb dziesiętnych, szesnastkowych, ósemkowych i dwójkowych. Domyślnie literały w postaci liczb całkowitych są typu int: int intValue1 = 34567, intValue2 = 1_000_000;

Dziesiętne liczby całkowite zawierają dowolną liczbę cyfr ASCII od 0 do 9 i przedstawiają liczby dodatnie: Integer integerValue1 = new Integer(100);

Umieszczenie na początku liczby operatora negacji powoduje utworzenie ujemnej dziesiętnej liczby całkowitej: public static final int INT_VALUE = -200;

Liczby szesnastkowe rozpoczynają się od znaków 0x lub 0X, po których mamy cyfry ASCII od 0 do 9 oraz litery od a do f (lub od A do F). W przypadku literałów w postaci szesnastkowych liczb całkowitych wielkość liter w Javie nie ma znaczenia. Liczby szesnastkowe mogą przedstawiać dodatnie i ujemne liczby całkowite oraz zero: int intValue3 = 0X64; // Dziesiętna liczba 100 utworzona na podstawie liczby szesnastkowej.

Literały ósemkowe rozpoczynają się od 0, po którym mamy jedną lub więcej cyfr ASCII z zakresu od 1 do 7: int intValue4 = 0144; // Dziesiętna liczba 100 utworzona na podstawie liczby ósemkowej.

Literały dwójkowe są wyrażane za pomocą prefiksu 0b lub 0B, po którym znajdują się zera i jedynki: char msgValue1 = 0b01001111; // O char msgValue2 = 0B01001011; // K char msgValue3 = 0B0010_0001; // !

Aby zdefiniować liczbę całkowitą typu long, konieczne jest umieszczenie na jej końcu dużej litery L ze standardu ASCII (to rozwiązanie preferowane, zapewniające najlepszą czytelność) lub małej litery l: long longValue = 100L;

Literały w postaci liczb zmiennoprzecinkowych Prawidłowy literał w postaci liczby zmiennoprzecinkowej wymaga całej liczby i/lub części ułamkowej, przecinka dziesiętnego i przyrostka wskazującego typ. Wykładnik jest wskazywany przez literę e lub E i jest opcjonalny. Część 28



Rozdział 2. Elementy leksykalne

ułamkowa i przecinek dziesiętny nie są wymagane w przypadku zastosowania wykładnika lub przyrostka typu. Literał w postaci liczby zmiennoprzecinkowej o podwójnej precyzji (double) to liczba zmiennoprzecinkowa zabierająca osiem bajtów. Zwykła liczba zmiennoprzecinkowa typu float zabiera cztery bajty. Przyrostek typu dla liczby o podwójnej precyzji to d lub D, dla standardowej to f lub F: [cała0liczba].[część_ułamkowa][e|E wykładnik][f|F|d|D] float floatValue1 = 9.15f, floatValue2 = 1_168f; Float floatValue3 = new Float(20F); double doubleValue1 = 3.12; Double doubleValue2 = new Double(1e058); float expValue1 = 10.0e2f, expValue2=10.0E3f;

Literały w postaci ciągów tekstowych Literały w postaci ciągów tekstowych zawierają zero lub więcej znaków, między innymi znaki sterujące ujęte w cudzysłów. Literały w postaci ciągów tekstowych nie mogą zawierać znaków Unicode o kodach \u000a i \u000d wskazujących na koniec wiersza, zamiast nich należy używać \r i \n. Ciągi tekstowe są niemodyfikowalne: String String String String

stringValue1 stringValue2 stringValue3 stringValue4

= = = =

new String("Prawidłowy literał."); "Prawidłowy.\nW nowym wierszu."; "Łączenie cią" + "gów tekstowych"; "\"Sekwencje sterujące\"\r";

Istnieje pula ciągów tekstowych powiązanych z klasą String. Początkowo wspomniana pula jest pusta. Literały w postaci ciągów tekstowych i wyrażenia stałych o wartościach składających się z ciągów tekstowych są przechowywane w puli i dodawane do niej tylko jednokrotnie. Przedstawiony poniżej przykład pokazuje, jak literały są dodawane do puli i używane: // Dodanie ciągu tekstowego "tenCiągTekstowy" do puli. String stringValue5 = "tenCiągTekstowy"; // Użycie ciągu tekstowego "tenCiągTekstowy" z puli. String stringValue6 = "tenCiągTekstowy";

Ciąg tekstowy może zostać dodany do puli (jeżeli jeszcze się w niej nie znajduje) przez wywołanie metody intern() względem ciągu tekstowego. Wartością zwrotną metody intern() jest ciąg tekstowy będący odniesieniem do nowego ciągu tekstowego dodanego do puli lub odniesieniem do istniejącego ciągu tekstowego:

Literały



29

String stringValue7 = new String("tenCiągTekstowy"); String stringValue8 = stringValue7.intern();

Literały null Literał null jest typu null i może być zastosowany do typów odnośnikowych. Nie jest stosowany do typów podstawowych: String n = null;

Sekwencje sterujące W tabeli 2.6 wymieniono sekwencje sterujące używane w Javie. Tabela 2.6. Literały znakowe oraz w postaci ciągów tekstowych dla sekwencji sterujących Nazwa

Sekwencja

Dziesiętnie

Unicode

Backspace

\b

8

\u0008

Tabulator poziomy

\t

9

\u0009

Wysuw wiersza

\n

10

\u000A

Znak końca strony

\f

12

\u000C

Znak nowego wiersza

\r

13

\u000D

Cudzysłów

\"

34

\u0022

Apostrof

\'

39

\u0027

Poszczególne znaki końca wiersza są używane na różnych platformach w celu przejścia do nowego wiersza (patrz tabela 2.7). Użycie metody println() obejmującej koniec wiersza to lepsze rozwiązanie niż umieszczanie w kodzie na stałe sekwencji sterujących \n i \r. Tabela 2.7. Znaki nowego wiersza na różnych platformach System operacyjny

Znak nowego wiersza

System operacyjny zgodny z POSIX (na przykład Solaris, Linux) i OS X

LF(\n)

Mac OS do wersji 9

CR(\r)

Microsoft Windows

CR+LF (\r\n)

30



Rozdział 2. Elementy leksykalne

Symbole walut w Unicode Symbole walut w Unicode są przedstawiane za pomocą znaków o liczbie kodowej z zakresu od \u20A0 do \u20CF (8352–+8399+). Przykłady znajdziesz w tabeli 2.8. Tabela 2.8. Symbole walut w zakresie od \u20A0 do \u20CF Nazwa

Symbol

Frank francuski

Dziesiętnie

Unicode

8355

\u20A3

Lir

₤

8356

\u20A4

Mill

₥

8357

\u20A5

8360

\u20A8

Rupia Dong

₫

8363

\u20AB

Euro

€

8364

\u20AC

Drachma

₯

8367

\u20AF

Fenig

₰

8368

\u20B0

Wiele innych symboli walut istnieje poza wymienionym zakresem. Przykłady przedstawiono w tabeli 2.9. Tabela 2.9. Symbole walut spoza zakresu od \u20A0 do \u20CF Nazwa

Dziesiętnie

Unicode

36

\u0024

Cent

162

\u00A2

Funt

163

\u00A3

164

\u00A4

Jen

164

\u00A5

Małe łacińskie f z kreską

402

\u0192

Symbol rupii bengalskiej

2546

\u09F2

Znak rupii bengalskiej

2547

\u09F3

Znak rupii gudżarackiej

2801

\u0AF1

Znak rupii tamilskiej

3065

\u0BF9

Symbol bahta tajskiego

3647

\u0E3F

Wielka litera M

8499

\u2133

Dolar

Znak waluty

Symbol $

¤

Symbole walut w Unicode



31

Tabela 2.9. Symbole walut spoza zakresu od \u20A0 do \u20CF — ciąg dalszy Nazwa

Symbol

Dziesiętnie

Unicode

Ujednolicony ideogram CJK 1

20803

\u5143

Ujednolicony ideogram CJK 3

20870

\u5186

Ujednolicony ideogram CJK 2

22278

\u5706

Ujednolicony ideogram CJK 4

22291

\u5713

2

2

CJK (ang. Chinese, Japanese and Korean) oznacza ujednolicone znaki pisma chińskiego, japońskiego i koreańskiego — przyp. tłum.

32



Rozdział 2. Elementy leksykalne

ROZDZIAŁ 3.

Typy proste

Typy proste obejmują typy podstawowe (ang. primitive types) i odpowiadające im klasy opakowujące oraz typy odnośnikowe (ang. reference types). Java 5.0 i nowsze zapewniają automatyczną konwersję między typami podstawowymi i odnośnikowymi za pomocą automatycznego pakowania i rozpakowywania. Promocja liczbowa jest stosowana względem typów podstawowych, gdy tylko takie rozwiązanie jest odpowiednie.

Typy podstawowe W Javie istnieje osiem typów podstawowych, każdy z nich jest słowem zarezerwowanym. Opisują zmienne zawierające pojedyncze wartości o odpowiednim formacie i wielkości (patrz tabela 3.1). Typy podstawowe zawsze charakteryzują się podaną precyzją, niezależnie od precyzji używanego sprzętu (na przykład 32- lub 64-bitowy). W przypadku typów podstawowych byte, short, int, long, float i double można wskazać znak. Z kolei typ char jest bez znaku.

Literały dla typów podstawowych Wszystkie typy podstawowe poza boolean mogą akceptować znaki, liczby dziesiętne, szesnastkowe, ósemkowe i literały Unicode, a także sekwencje znaków sterujących. Kiedy zachodzi potrzeba, wartość literału jest automatycznie

33

Tabela 3.1. Typy podstawowe Typ

Opis

Wymagana ilość pamięci masowej

Zakres wartości

boolean

true lub false

1 bit

nie dotyczy

char

znak Unicode

2 bajty

od \u0000 do \uFFFF

byte

liczba całkowita

1 bajt

od –128 do 127

short

liczba całkowita

2 bajty

od –32 768 do 32 767

int

liczba całkowita

4 bajty

od –2 147 483 648 do 2 147 483 647

long

liczba całkowita

8 bajtów

od –263 do 263–1

float

liczba zmiennoprzecinkowa

4 bajty

od 1,4e–45 do 3,4e+38

double

liczba zmiennoprzecinkowa

8 bajtów

od 5e–324 do 1,8e+308

rzutowana lub konwertowana. Pamiętaj, że trakcie skracania dochodzi do utraty bitów. Poniżej przedstawiono przykłady przypisań typów podstawowych: boolean isTitleFight = true;

W przypadku typu podstawowego boolean jedyne prawidłowe wartości literałów to true i false.

char [] cArray = {'\u004B', 'O', '\'', 0x0064, 041, (char) 131105, 0b00100001}; // KO'd!!! Typ podstawowy char przedstawia pojedynczy znak Unicode. Wartości literałów typu podstawowego char większe niż dwa bajty wymagają

wyraźnego rzutowania.

byte rounds = 12, fighters = (byte) 2; Literałem dla trybu podstawowego byte jest czterobajtowa liczba całkowita

ze znakiem. Jeżeli nie zostanie przeprowadzone wyraźne rzutowanie, wspomniana liczba całkowita będzie niejawnie rzutowana na jeden bajt. short seatingCapacity = 17157, vipSeats = (short) 500; Literałem dla trybu podstawowego short jest czterobajtowa liczba całko-

wita ze znakiem. Jeżeli nie zostanie przeprowadzone wyraźne rzutowanie, wspomniana liczba całkowita będzie niejawnie rzutowana na dwa bajty. int ppvRecord = 19800000, vs = vipSeats, venues = (int) 20000.50D; Literałem dla trybu podstawowego int jest czterobajtowa liczba całkowita ze znakiem. Kiedy typy podstawowe char, byte i short są uży-

wane jako literały, automatycznie zostają rzutowane na czterobajtowe

34



Rozdział 3. Typy proste

liczby całkowite, jak w przypadku wartości short vipSeats. Literały w postaci liczb zmiennoprzecinkowych i typu long muszą być wyraźnie rzutowane. long wins = 38L, losses = 4l, draws = 0, knockouts = (long) 30; Literałem dla trybu podstawowego long jest ośmiobajtowa liczba całkowita ze znakiem. Na użycie typu long wskazuje przyrostek L lub l.

W przypadku braku przyrostka lub wskazanego rzutowania wartość jest automatycznie rzutowana z czterech bajtów na osiem. float payPerView = 54.95F, balcony = 200.00f, ringside = (float) 2000, cheapSeats = 50; Literałem dla trybu podstawowego float jest czterobajtowa liczba zmiennoprzecinkowa ze znakiem. Na użycie typu float wskazuje przyrostek F lub f. Chociaż nie jest wymagane wyraźne rzutowanie dla literału int, to int nie zawsze zmieści się w float, gdy wartość będzie większa niż

około 223.

double champsPay = 20000000.00D, challengersPay = 12000000.00d, chlTrainerPay = (double) 1300000, refereesPay = 3000, soda = 4.50; Literałem dla trybu podstawowego double jest ośmiobajtowa liczba całkowita ze znakiem. Na użycie typu double wskazuje przyrostek D, d lub

wyraźne rzutowanie i brak przyrostka. Jeżeli literał jest liczbą całkowitą, będzie niejawnie rzutowany. Więcej informacji o literałach przedstawiono w rozdziale 2.

Encje zmiennoprzecinkowe Dodatnie i ujemne nieskończone liczby zmiennoprzecinkowe, ujemne zero i NaN (ang. not-a-number) to encje specjalne zdefiniowane w celu sprostania wymaganiom standardu IEEE 754-1985 (patrz tabela 3.2). Tabela 3.2. Encje zmiennoprzecinkowe Encja

Opis

Przykłady

Infinity

Przedstawia koncepcję dodatniej nieskończoności.

1.0/0.0, 1e300/1e-300, Math.abs (-1.0/0.0)

-Infinity

Przedstawia koncepcję ujemnej nieskończoności.

-1.0/0.0, 1.0/(-0.0), 1e300/-1e- 300

-0.0

Przedstawia liczbę ujemną bliską zeru.

-1.0/(1.0/0.0), -1e-300/1e300

NaN

Przedstawia nieokreślony wynik.

0.0/0.0, 1e300*Float.NaN, Math.sqrt (-9.0)

Encje zmiennoprzecinkowe



35

Encje Infinity, -Infinity i -0.0 są zwracane, gdy operacja wygeneruje wartość zmiennoprzecinkową zbyt dużą, aby mogła zostać przedstawiona w tradycyjny sposób. Encje dodatniej i ujemnej nieskończoności oraz NaN są dostępne jako stałe typów dobule i float: Double.POSITIVE_INFINITY; // Nieskończoność. Float.POSITIVE_INFINITY; // Nieskończoność. Double.NEGATIVE_INFINITY; // Ujemna nieskończoność. Float.NEGATIVE_INFINITY; // Ujemna nieskończoność. Double.NaN; // NaN. Float.NaN; // NaN.

Klasy opakowujące Double i Float mają metody pozwalające na ustalenie, czy liczba jest skończona, nieskończona lub NaN: Double.isFinite(Double.POSITIVE_INFINITY); // Wartość false. Double.isFinite(Double.NEGATIVE_INFINITY); // Wartość false. Double.isFinite(Double.NaN); // Wartość false. Double.isFinite(1); // Wartość true. Double.isInfinite(Double.POSITIVE_INFINITY); // Wartość true. Double.isInfinite(Double.NEGATIVE_INFINITY); // Wartość true. Double.isInfinite(Double.NaN); // Wartość false. Double.isInfinite(1); // Wartość false. Double.isNaN(Double.NaN); // Wartość true. Double.isNaN(1); // Wartość false.

Operacje obejmujące encje specjalne W tabeli 3.3 przedstawiono wyniki operacji obejmujących encje specjalne. We wspomnianych operacjach znaczenie operandów jest następujące: INF to Double.POSITIVE_INFINITY, -INF to Double.NEGATIVE_INFINITY, natomiast NAN to Double.NaN. Na przykład w kolumnie czwartej (-0.0) w ostatnim wierszu (* NAN) otrzymujemy wynik NaN. Alternatywny sposób zapisu tego wiersza przedstawia się następująco: // Dane wyjściowe to 'NaN'. System.out.print((-0.0) * Double.NaN);

Wynikiem dowolnej operacji przeprowadzanej na NaN jest NaN. Nie ma czegoś takiego, jak -NaN.

36



Rozdział 3. Typy proste

Tabela 3.3. Operacje obejmujące encje specjalne INF

(-INF)

(-0.0)

* INF

Infinity

-Infinity

NaN

+ INF

Infinity

NaN

Infinity

- INF

NaN

-Infinity

-Infinity

/ INF

NaN

NaN

-0.0

* 0.0

NaN

NaN

-0.0

+ 0.0

Infinity

-Infinity

0.0

+ 0.5

Infinity

-Infinity

0.5

* 0.5

Infinity

-Infinity

-0.0

+ (-0.5)

Infinity

-Infinity

-0.5

* (-0.5)

-Infinity

Infinity

0.0

+ NAN

NaN

NaN

NaN

* NAN

NaN

NaN

NaN

Promocja liczbowa dla typów podstawowych Promocja liczbowa to zbiór reguł stosowanych w określonych warunkach względem operandów operatora arytmetycznego. Reguły promocji liczbowej składają się z zarówno jednoargumentowych, jak i dwuargumentowych reguł promocji.

Jednoargumentowa promocja liczbowa Kiedy typ podstawowy jest częścią wyrażenia (jak wymieniono w tabeli 3.4), wtedy zastosowane zostają następujące reguły promocji:  Gdy operator jest typu byte, short lub char, zostaje promowany do typu int.  W przeciwnym razie typ operandu pozostaje niezmieniony.

Dwuargumentowa promocja liczbowa Kiedy dwa różne typy podstawowe są porównywane za pomocą operatorów wymienionych w tabeli 3.5, wówczas jeden typ jest promowany na podstawie przedstawionych poniżej reguł dwuargumentowej promocji liczbowej:

Promocja liczbowa dla typów podstawowych



37

Tabela 3.4. Wyrażenie dla reguł jednoargumentowej promocji liczbowej Wyrażenie Operand jednoargumentowego operatora plus (+) Operand jednoargumentowego operatora minus (-) Operand bitowego operatora uzupełniania (~) Wszystkie operatory przesunięcia (>>, >>> i 5) { System.out.println("Weź udział w wydarzeniu."); } else { System.out.println("Wróć do domu bez płacenia."); }

Konstrukcja if-else-if Konstrukcja if else if jest najczęściej używana, gdy zachodzi konieczność dokonania wyboru wśród wielu bloków kodu. Kiedy nie zostaną spełnione kryteria wykonania któregokolwiek bloku, wówczas nastąpi wykonanie kodu w ostatnim bloku else: ArrayList playList = new ArrayList(); Song song1 = new Song("Mister Sandman"); Song song2 = new Song("Amazing Grace"); playList.add(song1); playList.add(song2); ... int numOfSongs = playList.size(); if (numOfSongs 24) & (numOfSongs < 50)){ System.out.println("Rezerwacja na jedną noc."); } else if ((numOfSongs >= 50)) { System.out.println("Rezerwacja na dwie noce."); } else { System.out.println("Rezerwacja na tydzień"); }

Polecenie switch Polecenie switch jest poleceniem sterowania przebiegiem programu. Rozpoczyna się od wyrażenia i na podstawie jego wartości przeprowadza transfer kontroli działania programu do jednego z bloków case. Polecenie switch działa z typami char, byte, short, int, a także z typami opakowującymi Cha racter, Byte, Short i Integer oraz z typami wyliczenia i String. Obsługa dla obiektów String została wprowadzona w Javie SE 7. Polecenie break służy

Polecenia warunkowe



69

do opuszczenia konstrukcji switch. Jeżeli blok case nie będzie zawierał polecenia break, nastąpi wykonanie wiersza kodu znajdującego się po bloku case. Wykonywanie kodu będzie kontynuowane aż do napotkania polecenia break lub końca konstrukcji switch. Dozwolone jest użycie jednego bloku default; w celu zachowania czytelności jest on najczęściej umieszczany na końcu konstrukcji: String style; String guitarist = "Eric Clapton"; ... switch (guitarist) { case "Chet Atkins": style = "Nashville"; break; case "Thomas Emmanuel": style = "Skomplikowany"; break; default: style = "Nieznany"; break; }

Polecenia iteracji Do poleceń iteracji zaliczamy pętlę for, usprawnioną pętlę for, pętlę while i pętlę do-while. Wymienione polecenia są używane w celu przeprowadzania iteracji przez fragmenty kodu.

Pętla for Polecenie for składa się z trzech części: inicjalizatora, wyrażenia i uaktualnienia. Jak pokazano nieco dalej, w poleceniu for zmienna (na przykład i) musi być zainicjalizowana przed użyciem. Wyrażenie (na przykład i < bArray. length) jest obliczane przed przeprowadzeniem iteracji pętli (na przykład i++). Iteracja zachodzi tylko wtedy, gdy wartością wyrażenia jest true. Zmienna jest uaktualniana po każdej iteracji. Banjo [] bArray = new Banjo[2]; bArray[0] = new Banjo(); bArray[0].setManufacturer("Windsor"); bArray[1] = new Banjo(); bArray[1].setManufacturer("Gibson"); for (int i=0; i 3) { CoffeeShop c = new CoffeeShop(); c.performGig(bandMembers); Random generator = new Random(); bandMembers = generator.nextInt(7) + 1; // 1-7. }

Pętla do-while W poleceniu do-while pętla jest zawsze wykonywana przynajmniej jednokrotnie, a jej wykonywanie trwa, dopóki wartością wyrażenia jest true. Wspomniane wyrażenie może być typu boolean lub Boolean: int bandMembers = 1; do { CoffeeShop c = new CoffeeShop(); c.performGig(bandMembers); Random generator = new Random(); bandMembers = generator.nextInt(7) + 1; // 1-7. } while (bandMembers > 3);

Polecenia iteracji



71

Transfer kontroli Polecenia transferu kontroli są używane w celu zmiany przebiegu działania programu. Składają się na nie polecenia break, continue i return.

Polecenie break Pozbawione etykiety polecenie break jest używane do opuszczenia konstrukcji switch lub natychmiastowego wyjścia z pętli, w której zostało wywołane. Polecenie break znajduje się w iteracjach pętli for, usprawnionej pętli for, pętli while i pętli do-while: Song song = new Song("Pink Panther"); Guitar guitar = new Guitar(); int measure = 1; int lastMeasure = 10; while (measure

Nieograniczony znak wieloznaczny, obiekt dowolnego typu, tak samo jak