Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00358 007085 14486297 na godz. na dobę w sumie
Java. Przygotowanie do programowania na platformę Android - książka
Java. Przygotowanie do programowania na platformę Android - książka
Autor: Liczba stron: 624
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-3372-2 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie mobilne >> android
Porównaj ceny (książka, ebook, audiobook).

Zdobądź wiedzę i umiejętności, które pomogą Ci tworzyć efektywne aplikacje dla systemu Android!

Język Java, obecny na rynku od dobrych piętnastu lat, ugruntował już swoją pozycję w środowisku programistów. Wykorzystywany jest niemal w każdej dziedzinie informatycznego świata, począwszy od aplikacji internetowych, poprzez tradycyjne oprogramowanie biurowe, aż po rozwiązania dla urządzeń przenośnych. Został on również wybrany jako główny język platformy Android - aplikacje dla tego systemu pisane są w języku Java i korzystają z różnorodnych standardowych API tego języka. Dzięki temu tysiące programistów niemal z marszu rozpoczęło tworzenie aplikacji przeznaczonych dla systemu Android, właściwie nie ponosząc żadnych dodatkowych kosztów.

Jedną z najlepszych książek wprowadzających do języka Java... trzymasz właśnie w rękach. Dzięki niej błyskawicznie opanujesz język Java oraz zasady programowania obiektowego, skupiając się przede wszystkim na tych aspektach Javy, które pozwolą Ci zrozumieć istotę tworzenia aplikacji. Z tak solidnymi fundamentami zaczniesz odkrywać możliwości i ograniczenia Javy. Na kolejnych stronach znajdziesz szczegółowo omówione API platformy, jej potencjał w zakresie korzystania z kolekcji oraz tworzenia aplikacji wielojęzycznych. Ponadto nauczysz się wykonywać operacje wejścia-wyjścia. Książka ta jest idealną pozycją dla wszystkich osób chcących poznać niuanse języka Java, a następnie wykorzystać je podczas tworzenia aplikacji. Dzięki zawartym w niej ćwiczeniom błyskawicznie zweryfikujesz zdobytą wiedzę.

Wykorzystaj potencjał Javy i przygotuj się do tworzenia aplikacji na urządzenia przenośne!

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

Darmowy fragment publikacji:

Tytuł oryginału: Learn Java for Android Development Tłumaczenie: Daniel Kaczmarek (wstęp, rozdz. 1 – 7, dod. A) Aleksander Lamża (rozdz. 8 – 10, dod. A) ISBN: 978-83-246-3372-2 Original edition copyright © 2010 by Jeff “JavaJeff” Friesen. All rights reserved. Polish edition copyright © 2012 by Helion S.A. All rights reserved. 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. Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/jappan.zip Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/jappan 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 ....................................................................................................11 O recenzencie technicznym .........................................................................12 Wprowadzenie ...........................................................................................13 Rozdziaï 1. Pierwsze kroki w jÚzyku Java .....................................................................17 Czym jest Java? ....................................................................................................................... 17 Java jest językiem programowania ............................................................................... 18 Java jest platformą .......................................................................................................... 19 Java SE, Java EE, Java ME i Android ............................................................................ 21 Instalacja i poznawanie możliwości JDK ........................................................................... 22 Instalacja i poznawanie możliwości dwóch najpopularniejszych środowisk IDE ....... 27 Zintegrowane środowisko programistyczne NetBeans ............................................. 28 Zintegrowane środowisko programistyczne Eclipse ................................................. 32 Gra karciana Kareta ............................................................................................................... 35 Reguły gry w Karetę ........................................................................................................ 36 Model gry Kareta w pseudokodzie ............................................................................... 36 Przekształcenie pseudokodu na kod języka Java ........................................................ 38 Kompilowanie, uruchamianie i udostępnianie aplikacji FourOfAKind ................ 51 Podsumowanie ....................................................................................................................... 55 Rozdziaï 2. Podstawy jÚzyka Java .................................................................................57 Klasy ......................................................................................................................................... 57 Deklarowanie klas ........................................................................................................... 58 Pola .................................................................................................................................... 59 Metody .............................................................................................................................. 73 Konstruktory ................................................................................................................... 91 Inne konstrukcje inicjalizujące ..................................................................................... 93 Interfejs a implementacja .............................................................................................. 98 Obiekty .................................................................................................................................. 102 Tworzenie obiektów i tablic ........................................................................................ 102 Uzyskiwanie dostępu do pól ....................................................................................... 104 Wywoływanie metod .................................................................................................... 106 Odśmiecanie .................................................................................................................. 109 Podsumowanie ..................................................................................................................... 111 JAVA. PRZYGOTOWANIE DO PROGRAMOWANIA NA PLATFORM} ANDROID Rozdziaï 3. Mechanizmy jÚzyka zorientowane obiektowo ..........................................115 Dziedziczenie ........................................................................................................................ 115 Rozszerzanie klas .......................................................................................................... 116 Najwyższa klasa przodka ............................................................................................. 121 Kompozycja ................................................................................................................... 130 Problemy z dziedziczeniem implementacji .............................................................. 130 Wielopostaciowość .............................................................................................................. 134 Rzutowanie w górę i późne wiązanie ......................................................................... 135 Klasy i metody abstrakcyjne ........................................................................................ 138 Rzutowanie w dół i identyfikacja typów w fazie wykonania .................................. 140 Kowariantne typy zwracanych wartości .................................................................... 142 Interfejsy ................................................................................................................................ 144 Deklarowanie interfejsów ............................................................................................ 144 Implementowanie interfejsów .................................................................................... 145 Rozszerzanie interfejsów .............................................................................................. 149 Po co używać interfejsów? ........................................................................................... 150 Podsumowanie ..................................................................................................................... 156 Zaawansowane mechanizmy jÚzyka — czÚĂÊ I .........................................157 Typy zagnieżdżone .............................................................................................................. 157 Statyczne klasy składowe ............................................................................................. 157 Niestatyczne klasy składowe ....................................................................................... 160 Klasy anonimowe .......................................................................................................... 164 Klasy lokalne .................................................................................................................. 166 Interfejsy wewnątrz klas ............................................................................................... 168 Pakiety ................................................................................................................................... 169 Czym są pakiety? ........................................................................................................... 169 Instrukcja pakietu ......................................................................................................... 171 Instrukcja importu ........................................................................................................ 171 Wyszukiwanie pakietów i typów ................................................................................ 172 Korzystanie z pakietów ................................................................................................ 174 Pakiety i pliki JAR ......................................................................................................... 178 Importy statyczne ................................................................................................................ 178 Wyjątki .................................................................................................................................. 180 Czym są wyjątki? ........................................................................................................... 181 Reprezentowanie wyjątków w kodzie źródłowym ................................................... 181 Rzucanie wyjątków ....................................................................................................... 185 Obsługa wyjątków ......................................................................................................... 188 Wykonywanie czynności sprzątających .................................................................... 192 Podsumowanie ..................................................................................................................... 198 Zaawansowane mechanizmy jÚzyka — czÚĂÊ II ........................................199 Asercje ................................................................................................................................... 199 Deklarowanie asercji .................................................................................................... 200 Korzystanie z asercji ..................................................................................................... 201 Unikanie korzystania z asercji .................................................................................... 207 Włączanie i wyłączanie asercji .................................................................................... 207 Rozdziaï 4. Rozdziaï 5. 6 SPIS TRE¥CI Adnotacje .............................................................................................................................. 208 Działanie adnotacji ....................................................................................................... 209 Deklarowanie typów adnotacji i wstawianie adnotacji do kodu źródłowego ...... 212 Przetwarzanie adnotacji ............................................................................................... 216 Mechanizmy ogólne ............................................................................................................ 218 Kolekcje i potrzeba bezpieczeństwa typologicznego ............................................... 219 Typy ogólne ................................................................................................................... 221 Metody ogólne ............................................................................................................... 232 Typy wyliczeniowe .............................................................................................................. 233 Problem z tradycyjnymi typami wyliczeniowymi .................................................... 234 Enum — alternatywa dla tradycyjnego typu wyliczeniowego ............................... 235 Klasa Enum .................................................................................................................... 240 Podsumowanie ..................................................................................................................... 244 Rozdziaï 6. Podstawowe interfejsy API — czÚĂÊ I .......................................................247 Interfejsy API do wykonywania obliczeń matematycznych .......................................... 247 Klasy Math i StrictMath ............................................................................................... 247 Klasa BigDecimal .......................................................................................................... 254 Klasa BigInteger ............................................................................................................ 259 Informacje na temat pakietów ........................................................................................... 263 Podstawowe klasy opakowujące ........................................................................................ 267 Klasa Boolean ................................................................................................................ 268 Klasa Character ............................................................................................................. 270 Klasy Float i Double ..................................................................................................... 271 Klasy Integer, Long, Short i Byte ................................................................................ 275 Klasa Number ................................................................................................................ 277 API References ..................................................................................................................... 277 Podstawowe pojęcia ...................................................................................................... 277 Klasy Reference i ReferenceQueue ............................................................................. 279 Klasa SoftReference ...................................................................................................... 280 Klasa WeakReference ................................................................................................... 283 Klasa PhantomReference ............................................................................................. 284 Podsumowanie ..................................................................................................................... 288 Rozdziaï 7. Podstawowe interfejsy API — czÚĂÊ II ......................................................289 API Reflection ...................................................................................................................... 289 Zarządzanie ciągami znaków ............................................................................................. 297 Klasa String .................................................................................................................... 298 Klasa StringBuffer ......................................................................................................... 301 Klasa System ......................................................................................................................... 304 API Threading ...................................................................................................................... 307 Interfejs Runnable i klasa Thread ............................................................................... 307 Synchronizacja wątków ................................................................................................ 317 Podsumowanie ..................................................................................................................... 333 Rozdziaï 8. Biblioteka kolekcji ....................................................................................335 Przegląd biblioteki ............................................................................................................... 335 Interfejs Comparable kontra Comparator ................................................................ 336 7 JAVA. PRZYGOTOWANIE DO PROGRAMOWANIA NA PLATFORM} ANDROID Interfejsy Iterable i Collection ........................................................................................... 338 Iterator i nowa pętla for ............................................................................................... 341 Automatyczne pakowanie i rozpakowywanie .......................................................... 342 Interfejs List .......................................................................................................................... 344 Klasa ArrayList .............................................................................................................. 348 Klasa LinkedList ............................................................................................................ 349 Interfejs Set ........................................................................................................................... 351 Klasa TreeSet ................................................................................................................. 351 Klasa HashSet ................................................................................................................ 353 Klasa EnumSet .............................................................................................................. 356 Interfejs SortedSet ................................................................................................................ 358 Interfejs Queue ..................................................................................................................... 365 Klasa PriorityQueue ..................................................................................................... 366 Interfejs Map ........................................................................................................................ 369 Klasa TreeMap .............................................................................................................. 373 HashMap ........................................................................................................................ 374 Klasa IdentityHashMap ............................................................................................... 380 Klasa WeakHashMap ................................................................................................... 382 Klasa EnumMap ............................................................................................................ 383 Interfejs SortedMap ............................................................................................................. 384 Narzędzia .............................................................................................................................. 387 Klasyczne klasy kolekcji ...................................................................................................... 389 Podsumowanie ..................................................................................................................... 396 Rozdziaï 9. Dodatkowe biblioteki klas narzÚdziowych ...............................................397 Narzędzia wspomagające współbieżność ......................................................................... 397 Wykonawcy ................................................................................................................... 397 Synchronizatory ............................................................................................................ 406 Współbieżne kolekcje ................................................................................................... 408 Blokady ........................................................................................................................... 410 Zmienne atomowe ........................................................................................................ 413 Internacjonalizacja ............................................................................................................... 414 Lokalizatory ................................................................................................................... 414 Paczki zasobów .............................................................................................................. 416 Iteratory operujące na tekście ..................................................................................... 425 Porównywanie tekstów — klasa Collator .................................................................. 429 Daty, strefy czasowe i kalendarze ............................................................................... 430 Formatery ....................................................................................................................... 436 Biblioteka klas preferencji .................................................................................................. 443 Generowanie liczb pseudolosowych ................................................................................. 446 Wyrażenia regularne ........................................................................................................... 449 Podsumowanie ..................................................................................................................... 460 Rozdziaï 10. Operacje wejĂcia-wyjĂcia ..........................................................................463 Klasa File ............................................................................................................................... 463 Klasa RandomAccessFile .................................................................................................... 474 Strumienie ............................................................................................................................. 485 Przegląd klas strumieni ................................................................................................ 485 Klasy OutputStream i InputStream ............................................................................ 487 8 SPIS TRE¥CI Klasy ByteArrayOutputStream i ByteArrayInputStream ....................................... 489 Klasy FileOutputStream i FileInputStream .............................................................. 491 Klasy PipedOutputStream i PipedInputStream ....................................................... 494 Klasy FilterOutputStream i FilterInputStream ......................................................... 497 Klasy BufferedOutputStream i BufferedInputStream ............................................. 504 Klasy DataOutputStream i DataInputStream ........................................................... 505 Serializacja i deserializacja obiektów .......................................................................... 508 Klasa PrintStream ......................................................................................................... 519 Klasy Writer i Reader .......................................................................................................... 523 Przegląd klas Writer i Reader ...................................................................................... 524 Klasy bazowe Writer i Reader ..................................................................................... 524 Klasy OutputStreamWriter i InputStreamReader ................................................... 525 Klasy FileWriter i FileReader ...................................................................................... 529 Podsumowanie ..................................................................................................................... 540 Na tym nie koniec ......................................................................................................... 541 Dodatek A Odpowiedzi do Êwiczeñ ............................................................................543 Rozdział 1. Pierwsze kroki w języku Java ......................................................................... 543 Rozdział 2. Podstawy języka Java ...................................................................................... 548 Rozdział 3. Mechanizmy języka zorientowane obiektowo ............................................ 551 Rozdział 4. Zaawansowane mechanizmy języka — część I ........................................... 558 Rozdział 5. Zaawansowane mechanizmy języka — część II .......................................... 564 Rozdział 6. Podstawowe interfejsy API — część I ........................................................... 569 Rozdział 7. Podstawowe interfejsy API — część II ......................................................... 572 Rozdział 8. Biblioteka kolekcji ........................................................................................... 578 Rozdział 9. Dodatkowe biblioteki klas narzędziowych .................................................. 583 Rozdział 10. Operacje wejścia-wyjścia .............................................................................. 589 Skorowidz .................................................................................................601 9 R O Z D Z I A ’ 6 Podstawowe interfejsy API — czÚĂÊ I Poważni programiści aplikacji dla systemu Android muszą gruntownie znać najważniejsze interfejsy API języka Java. Z kilkoma API mieliśmy już do czynienia, dość wspomnieć klasy Object i String oraz hierarchię klas Throwable. W tym rozdziale przedstawimy kolejne pod- stawowe interfejsy API przeznaczone do wykonywania obliczeń matematycznych, opero- wania na pakietach i typach podstawowych, a także mechanizm odśmiecania. „ Uwaga • W rozdziale 6. zostanÈ opisane podstawowe klasy i interfejsy API zlokalizowane w pakietach java.lang, java.lang.ref i java.math. Interfejsy API do wykonywania obliczeñ matematycznych W rozdziale 2. zaprezentowano operatory +, -, *, / i języka Java przeznaczone do wyko- nywania najważniejszych operacji matematycznych na wartościach typów podstawowych. Java udostępnia także klasy przeznaczone do wykonywania operacji trygonometrycznych i innych zaawansowanych działań, precyzyjnej prezentacji wartości pieniężnych oraz obsługi bardzo długich liczb całkowitych wykorzystywanych do szyfrowania algorytmem RSA (http://pl. wikipedia.org/wiki/RSA_(kryptografia)) i w innych kontekstach. Klasy Math i StrictMath Klasa java.lang.Math deklaruje stałe typu double o nazwach E i PI, które reprezentują od- powiednio podstawę logarytmu naturalnego (2,71828…) oraz stosunek obwodu okręgu do jego średnicy (3,141519…). Stała E jest inicjalizowana wartością 2,718281828459045, nato- miast stała PI ma wartość 3,141592653589793. W klasie Math zadeklarowane są także wybra- ne metody klasy, przeznaczone do wykonywania różnego rodzaju działań matematycznych. W tabeli 6.1 opisano większość dostępnych metod. JAVA. PRZYGOTOWANIE DO PROGRAMOWANIA NA PLATFORM} ANDROID Tabela 6.1. Metody klasy Math Opis Zwraca wartość bezwzględną liczby d. Istnieją cztery przypadki szczególne: abs(-0.0) = +0.0, abs(+nieskoñczonoĂÊ) = +nieskoñczonoĂÊ, abs(-nieskoñczonoĂÊ) = +nieskoñczonoĂÊ oraz abs(NaN) = NaN. Zwraca wartość bezwzględną liczby f. Istnieją cztery przypadki szczególne: abs(-0.0) = +0.0, abs(+nieskoñczonoĂÊ) = +nieskoñczonoĂÊ, abs(-nieskoñczonoĂÊ) = +nieskoñczonoĂÊ oraz abs(NaN) = NaN. Zwraca wartość bezwzględną liczby i. Istnieje jeden przypadek szczególny: wartością bezwzględną Integer.MIN_VALUE jest Integer.MIN_VALUE. Zwraca wartość bezwzględną liczby l. Istnieje jeden przypadek szczególny: wartością bezwzględną Long.MIN_VALUE jest Long.MIN_VALUE. Zwraca arcus cosinus kąta d z przedziału od 0 do PI. Istnieją trzy przypadki szczególne: acos(wartoĂÊ 1) = NaN, acos(wartoĂÊ -1) = NaN oraz acos(NaN) = NaN. Zwraca arcus sinus kąta d z przedziału od –PI/2 do PI/2. Istnieją trzy przypadki szczególne: asin(wartoĂÊ 1) = NaN, asin(wartoĂÊ -1) = NaN oraz asin(NaN) = NaN. Zwraca arcus tangens kąta d z przedziału –PI/2 do PI/2. Istnieje pięć przypadków szczególnych: atan(+0.0) = +0.0, atan(-0.0) = -0.0, atan(+nieskoñczonoĂÊ) = +PI/2, atan(-nieskoñczonoĂÊ) = -PI/2 oraz atan(NaN) = NaN. Zwraca najmniejszą wartość (najbliższą minus nieskończoności), która nie jest mniejsza od d i jest liczbą całkowitą. Istnieje sześć przypadków szczególnych: ceil(+0.0) = +0.0, ceil(-0.0) = -0.0, ceil(wartoĂÊ -1.0 oraz 0.0) = -0.0, ceil(+nieskoñczonoĂÊ) = +nieskoñczonoĂÊ, ceil(-nieskoñczonoĂÊ) = -nieskoñczonoĂÊ oraz ceil(NaN) = NaN. Zwraca cosinus kąta d (wyrażonego w radianach). Istnieją trzy przypadki szczególne: cos(+nieskoñczonoĂÊ) = NaN, cos(-nieskoñczonoĂÊ) = NaN oraz cos(NaN) = NaN. Zwraca liczbę Eulera e podniesioną do potęgi d. Istnieją trzy przypadki szczególne: exp(+nieskoñczonoĂÊ) = + nieskoñczonoĂÊ, exp(- nieskoñczonoĂÊ) = +0.0 oraz exp(NaN) = NaN. Zwraca największą wartość (najbliższą plus nieskończoności), która nie jest większa od d i jest liczbą całkowitą. Istnieje pięć przypadków szczególnych: floor(+0.0) = +0.0, floor(-0.0) = -0.0, floor(+nieskoñczonoĂÊ) = +nieskoñczonoĂÊ, floor(-nieskoñczonoĂÊ) = -nieskoñczonoĂÊ oraz floor(NaN) = NaN. Zwraca logarytm naturalny (przy podstawie e) z liczby d. Istnieje sześć przypadków szczególnych: log(+0.0) = - nieskoñczonoĂÊ, log(-0.0) = - nieskoñczonoĂÊ, log(wartoĂÊ 0) = NaN, log(+nieskoñczonoĂÊ) = +nieskoñczonoĂÊ, log(-nieskoñczonoĂÊ) = NaN oraz log(NaN) = NaN. Metoda double abs(double d) float abs(float f) int abs(int i) long abs(long l) double acos(double d) double asin(double d) double atan(double d) double ceil(double d) double cos(double d) double exp(double d) double floor(double d) double log(double d) 248 Tabela 6.1. Metody klasy Math — ciąg dalszy ROZDZIA’ 6. „ PODSTAWOWE INTERFEJSY API — CZ}¥m I float max(double f1, double f2) int max(int i1, int i2) double max(double d1, double d2) Metoda double log10(double d) Opis Zwraca logarytm przy podstawie 10 z liczby d. Istnieje sześć przypadków szczególnych: log10(+0.0) = -nieskoñczonoĂÊ, log10(-0.0) = -nieskoñczonoĂÊ, log10(wartoĂÊ 0) = NaN, log10(+nieskoñczonoĂÊ) = +nieskoñczonoĂÊ, log10(-nieskoñczonoĂÊ) = NaN oraz log10(NaN) = NaN. Zwraca największą (najbliższą plus nieskończoności) spośród liczb d1 i d2. Istnieją cztery przypadki szczególne: max(NaN, wartoĂÊ) = NaN, max(wartoĂÊ, NaN) = NaN, max(+0.0, -0.0) = +0.0 oraz max(-0.0, +0.0) = +0.0. Zwraca największą (najbliższą plus nieskończoności) spośród liczb f1 i f2. Istnieją cztery przypadki szczególne: max(NaN, wartoĂÊ) = NaN, max(wartoĂÊ, NaN) = NaN, max(+0.0, -0.0) = +0.0 oraz max(-0.0, +0.0) = +0.0. Zwraca największą (najbliższą plus nieskończoności) spośród liczb i1 i i2. long max(long l1, long l2) Zwraca największą (najbliższą plus nieskończoności) spośród liczb l1 i l2. Zwraca najmniejszą (najbliższą minus nieskończoności) spośród liczb double min(double d1, double d2) d1 i d2. Istnieją cztery przypadki szczególne: min(NaN, wartoĂÊ) = NaN, min(wartoĂÊ, NaN) = NaN, min(+0.0, -0.0) = -0.0 oraz min(-0.0, +0.0) = -0.0. Zwraca najmniejszą (najbliższą minus nieskończoności) spośród liczb f1 i f2. Istnieją cztery przypadki szczególne: min(NaN, wartoĂÊ) = NaN, min(wartoĂÊ, NaN) = NaN, min(+0.0, -0.0) = -0.0 oraz min(-0.0, +0.0) = -0.0. Zwraca najmniejszą (najbliższą minus nieskończoności) spośród liczb i1 i i2. float min(float f1, float f2) int min(int i1, int i2) long min(long l1, long l2) Zwraca najmniejszą (najbliższą minus nieskończoności) spośród double random() long round(double d) int round(float f) double signum(double d) liczb l1 i l2. Zwraca liczbę pseudolosową z przedziału prawostronnie otwartego od 0,0 (włącznie) do 1,0. Zwraca wynik zaokrąglenia liczby d do długiej liczby całkowitej. Wynik jest równoważny wynikowi wyrażenia (long) Math.floor(d+0.5). Istnieje siedem przypadków szczególnych: round(+0.0) = +0.0, round(-0.0) = +0.0, round(wartoĂÊ Long.MAX_VALUE) = Long.MAX_VALUE, round(wartoĂÊ Long.MIN_VALUE) = Long.MIN_VALUE, round(+nieskoñczonoĂÊ) = Long.MAX_ ´VALUE, round(-nieskoñczonoĂÊ) = Long.MIN_VALUE oraz round(NaN) = +0.0. Zwraca wynik zaokrąglenia liczby f do liczby całkowitej. Wynik jest równoważny wynikowi wyrażenia (long) Math.floor(f+0.5). Istnieje siedem przypadków szczególnych: round(+0.0) = +0.0, round(-0.0) = +0.0, round(wartoĂÊ Integer.MAX_VALUE) = Integer.MAX_VALUE, round(wartoĂÊ Integer.MIN_VALUE) = Integer.MIN_VALUE, round(+nieskoñczonoĂÊ) = Integer.MAX_VALUE, round(-nieskoñczonoĂÊ) = Integer.MIN_VALUE oraz round(NaN) = +0.0. Zwraca znak liczby d jako liczbę –1,0 (jeżeli d jest mniejsze od 0,0), liczbę 0,0 (jeżeli d jest równe 0,0) lub 1,0 (jeżeli d jest większe niż 0,0). Istnieje pięć przypadków szczególnych: signum(+0.0) = +0.0, signum(-0.0) = -0.0, signum(+nieskoñczonoĂÊ) = +1.0, signum(-nieskoñczonoĂÊ) = -1.0 oraz signum(NaN) = NaN. 249 JAVA. PRZYGOTOWANIE DO PROGRAMOWANIA NA PLATFORM} ANDROID Tabela 6.1. Metody klasy Math — ciąg dalszy Metoda float signum(float f) double sin(double d) double sqrt(double d) double tan(double d) double toDegrees (double angrad) double toRadians (angdeg) Opis Zwraca znak liczby f jako liczbę –1,0 (jeżeli f jest mniejsze od 0,0), liczbę 0,0 (jeżeli f jest równe 0,0) lub 1,0 (jeżeli f jest większe niż 0,0). Istnieje pięć przypadków szczególnych: signum(+0.0) = +0.0, signum(- 0.0) = -0.0, signum(+nieskoñczonoĂÊ) = +1.0, signum(-nieskoñczonoĂÊ) = -1.0 oraz signum(NaN) = NaN. Zwraca sinus kąta d (wyrażonego w radianach). Istnieje pięć przypadków szczególnych: sin(+0.0) = +0.0, sin(-0.0) = -0.0, sin(+nieskoñczonoĂÊ) = NaN, sin(-nieskoñczonoĂÊ) = NaN oraz sin(NaN) = NaN. Zwraca pierwiastek kwadratowy liczby d. Istnieje pięć przypadków szczególnych: sqrt(+0.0) = +0.0, sqrt(-0.0) = -0.0, sqrt(wartoĂÊ 0) = NaN, sqrt(+nieskoñczonoĂÊ) = +nieskoñczonoĂÊ oraz sqrt(NaN) = NaN. Zwraca tangens kąta d (wyrażonego w radianach). Istnieje pięć przypadków szczególnych: tan(+0.0) = +0.0, tan(-0.0) = -0.0, tan(+nieskoñczonoĂÊ) = NaN, tan(-nieskoñczonoĂÊ) = NaN oraz tan(NaN) = NaN. Przekształca miarę kąta angrad z radianów na stopnie za pomocą wyrażenia angrad*180/PI. Istnieje pięć przypadków szczególnych: toDegrees(+0.0) = +0.0, toDegrees(-0.0) = -0.0, toDegrees(+nieskoñczonoĂÊ) = +nieskoñczonoĂÊ, toDegrees(-nieskoñczonoĂÊ) = -nieskoñczonoĂÊ oraz toDegrees(NaN) = NaN. Przekształca miarę kąta angdeg ze stopni na radiany za pomocą wyrażenia angdeg/180*PI. Istnieje pięć przypadków szczególnych: toRadians(+0.0) = +0.0, toRadians(-0.0) = -0.0, toRadians(+nieskoñczonoĂÊ) = +nieskoñczonoĂÊ, toRadians(-nieskoñczonoĂÊ) = -nieskoñczonoĂÊ oraz toRadians(NaN) = NaN. W tabeli 6.1 przedstawiono obszerny zbiór metod przydatnych do wykonywania działań matematycznych. Na przykład każda metoda abs zwraca wartość bezwzględną (czyli liczbę bez względu na znak) przekazanego do niej argumentu. Metody abs(double) oraz abs(float) przydają się do bezpiecznego porównywania liczb zmiennopozycyjnych o podwójnej precyzji oraz liczb zmiennopozycyjnych. Na przykład wyrażenie 0.3 == 0.1+0.1+0.1 ma wartość false, ponieważ liczba 0,1 nie ma dokładnej re- prezentacji. Wyrażenia te można jednak ze sobą porównać przy użyciu metody abs() i wartości tolerancji, która wskazuje akceptowalny poziom błędu. Na przykład wyrażenie Math.abs ´(0.3-(0.1+0.1+0.1)) 0.1 będzie już mieć wartość true, ponieważ bezwzględna różnica między 0.3 i 0.1+0.1+0.1 jest mniejsza niż wartość tolerancji 0,1. We wcześniejszych rozdziałach przedstawiono inne metody klasy Math. Na przykład w rozdziale 2. zostały wykorzystane metody sin(), toRadians(), cos(), round(double) i random() tej klasy. Jak widać na przykładzie aplikacji Lotto649 z rozdziału 5., funkcja random() (która zwra- ca liczbę wyglądającą na losową, choć w rzeczywistości jest wyznaczana przez określoną funkcję matematyczną i dlatego jest tak naprawdę liczbą pseudolosową) przydaje się do symulacji, gier i w innych zastosowaniach, w których potrzeba losowości. Najpierw jednak 250 ROZDZIA’ 6. „ PODSTAWOWE INTERFEJSY API — CZ}¥m I liczbę zwracaną przez random(), która należy do przedziału od 0,0 do prawie 1,0, trzeba ja- koś przekształcić do wartości bardziej przydatnej, na przykład należącej do przedziału od 0 do 49 albo od –100 do 100. Na listingu 6.1 znajduje się metoda rnd(), przydatna do wyko- nywania tego typu przekształceń. Listing 6.1. Przekształcanie wartości zwracanej przez random() do bardziej przydatnej wartości public static int rnd(int limit) { return (int) (Math.random()*limit); } Metoda rnd() przekształca zwracaną przez random() liczbę zmiennopozycyjną o podwójnej precyzji z przedziału od 0,0 do 1,0 do liczby całkowitej z przedziału od 0 do limit – 1. Na przykład rnd(50) zwróci liczbę całkowitą z przedziału od 0 do 49. Z kolei instrukcja -100+rnd(201) przekształci przedział od 0,0 do prawie 1,0 do przedziału od –100 do 100 przez dodanie odpowiedniej wartości przesunięcia i wykorzystanie odpowiedniej wartości limit. „ Ostrzeĝenie • Nie naleĝy wykonywaÊ instrukcji (int) Math.random()*limit, poniewaĝ wyraĝenie to zawsze bÚdzie mieÊ wartoĂÊ 0. W wyraĝeniu uïamkowa liczba zmiennopozycyjna o podwójnej precy- zji z przedziaïu od 0,0 do 0,99999… najpierw jest rzutowana na liczbÚ caïkowitÈ 0 przez uciÚcie czÚĂci uïamkowej, a nastÚpnie 0 jest mnoĝone przez limit, co w efekcie daje równieĝ 0. W tabeli 6.1 opisano także przypadki szczególne, dotyczące najczęściej wartości +nieskończoność, –nieskończoność, +0.0, –0.0 i NaN (ang. Not a Number — wartość, która nie jest liczbą). Wynikiem obliczeń zmiennopozycyjnych wykonywanych w języku Java mogą być war- tości +nieskończoność, –nieskończoność, +0.0, –0.0 i NaN, ponieważ Java w dużej mierze jest zgodna ze standardem IEEE 754 (http://pl.wikipedia.org/wiki/IEEE_754), który opisuje sposób wykonywania obliczeń zmiennopozycyjnych. Poniżej przedstawiono okoliczności, w których pojawiają się wspomniane wartości specjalne: x +nieskończoność jest zwracana jako wynik dzielenia liczby dodatniej przez 0,0. Na przykład instrukcja System.out.println(1.0/0.0); zwróci wartość Infinity. x –nieskończoność jest zwracana jako wynik dzielenia liczby ujemnej przez 0,0. Na przykład instrukcja System.out.println(-1.0/0.0); zwróci wartość –Infinity. x NaN jest zwracana jako wynik dzielenia 0,0 przez 0,0, wartość pierwiastka kwadrato- wego liczby ujemnej oraz wynik innych dziwnych operacji. Na przykład instrukcje System.out.println(0.0/0.0); oraz System.out.println(Math.sqrt(-1.0)); zwra- cają wynik NaN. x +0.0 jest zwracana jako wynik dzielenia liczby całkowitej przez +nieskończoność. Na przykład instrukcja System.out.println(1.0/(1.0/0.0)); zwróci wartość +0.0. x -0.0 jest zwracana jako wynik dzielenia liczby ujemnej przez +nieskończoność. Na przykład instrukcja System.out.println(-1.0/(1.0/0.0)); zwróci wartość -0.0. 251 JAVA. PRZYGOTOWANIE DO PROGRAMOWANIA NA PLATFORM} ANDROID Jeżeli wynikiem jakiegoś działania jest wartość specjalna +nieskończoność, –nieskoń- czoność lub NaN, wówczas całe wyrażenie ma zwykle taki sam wynik równy wartości spe- cjalnej. Na przykład wynikiem instrukcji System.out.println(1.0/0.0*20.0); jest Infinity. Jednak wyrażenie, w którym pojawia się wartość +nieskończoność lub –nieskończoność, może też zwrócić wartość NaN. Na przykład w wyrażeniu 1.0/0.0*0.0 najpierw pojawia się +nieskończoność (jako wynik wyrażenia 1.0/0.0), a następnie NaN (jako wynik wyrażenia +nieskończoność*0, 0). Kolejna ciekawostka wiąże się z wartościami Integer.MAX_VALUE, Integer.MIN_VALUE, Long.MAX_VALUE oraz Long.MIN_VALUE. Każda z tych wartości jest klasą opakowującą typu podstawowego, która identyfikuje wartość maksymalną lub minimalną, jaka może być re- prezentowana przez typ podstawowy skojarzony z klasą. Można się także zastanawiać, dlaczego nie istnieją przeciążone wersje metod abs(), max() i min(), które obsługują argumenty typu byte i short, czyli byte abs(byte b) oraz short abs(short s). Wersje takie nie są jednak potrzebne, ponieważ ograniczone przedziały liczb całkowitych typu byte i short sprawiają, że są one mało przydatne do wykonywania obliczeń. Jeżeli jednak metody takie są potrzebne, można skorzystać z implementacji przedstawionej na listingu 6.2. Listing 6.2. Przeciążone metody byte abs(byte b) i short abs(short s) public static byte abs(byte b) { return (b 0) ? (byte) -b : b; } public static short abs(short s) { return (s 0) ? (short) -s : s; } public static void main(String[] args) { byte b = -2; System.out.println(abs(b)); // Wynik: 2 short s = -3; System.out.println(abs(s)); // Wynik: 3 } Rzutowania (byte) i (short) trzeba wykonać, ponieważ wyrażenie –b przekształca war- tość zmiennej b z typu byte na typ int, a wyrażenie –s przekształca wartość zmiennej s z ty- pu short na typ int. Z kolei rzutowania nie są potrzebne w wyrażeniach (b 0) i (s 0), ponieważ w tych przypadkach wartości b i s są automatycznie rzutowane do typu int przed porównaniem ich z wartością 0 typu int. „ Wskazówka • Brak wspomnianych wersji metod w klasie Math mógïby sugerowaÊ, ĝe typy byte i short nie sÈ zbyt przydatne w deklaracjach metod. Jednak typy te przydajÈ siÚ wówczas, gdy deklaruje siÚ tablice, których elementy przechowujÈ maïe wartoĂci (na przykïad wartoĂci bajtowe w pliku binarnym). Gdyby tablica do przechowywania takich wartoĂci zostaïa zadeklarowana jako typu int lub long, zmarnowaïoby siÚ w ten sposób znacznÈ iloĂÊ miejsca na stercie (a w skrajnym przypadku mogïoby to doprowadziÊ do wyczerpania siÚ pamiÚci). 252 ROZDZIA’ 6. „ PODSTAWOWE INTERFEJSY API — CZ}¥m I Gdy w dokumentacji języka Java analizuje się informacje na temat pakietu java.lang, można natknąć się na klasę o nazwie StrictMath. Oprócz dłuższej nazwy, klasa wydaje się identyczna z klasą Math. Różnice między dwiema klasami można podsumować następująco: x Metody klasy StrictMath zwracają identyczne wyniki na wszystkich platformach. Nato- miast metody klasy Math mogą zwracać nieco odmienne wartości, zależnie od platformy. x Ponieważ StrictMath nie może używać elementów charakterystycznych dla konkret- nych platform, takich jak choćby koprocesor obliczeń matematycznych o zwiększonej precyzji, implementacja klasy StrictMath może być mniej wydajna od implementacji klasy Math. W większości przypadków metody klasy Math mogą wywoływać swoje odpowiedniczki z klasy StrictMath. Dwoma wyjątkami od tej reguły są metody toDegrees() i toRadians(). Wprawdzie w obydwóch klasach obie metody mają taką samą implementację, lecz w na- główkach tych metod w klasie StrictMath występuje zastrzeżone słowo strictfp: public static strictfp double toDegrees(double angrad) public static strictfp double toRadians(double angdeg) Według Wikipedii (http://en.wikipedia.org/wiki/Strictfp) słowo zastrzeżone strictfp ogranicza obliczenia zmiennopozycyjne w taki sposób, aby zapewnić przenośność. Słowo to umożliwia przenośność dzięki zapewnieniu jednolitej pośredniej reprezentacji liczb zmien- nopozycyjnych oraz w zakresie nadmiarów i niedomiarów (czyli generowania wartości zbyt dużej lub zbyt małej w stosunku do ograniczeń reprezentacji). „ Uwaga • Zgodnie ze wspomnianym przed chwilÈ artykuïem z Wikipedii na temat sïowa zastrzeĝonego strictfp klasa Math zawiera metodÚ public static strictfp double abs(double); oraz inne metody strictfp. Jednak gdy w Javie 6 update 16 przeanalizuje siÚ kod ěródïowy tej klasy, okaĝe siÚ, ĝe nie ma w nim ĝadnego wystÈpienia sïowa strictfp. Jednak wiele metod klasy Math (na przykïad metoda sin()) wywoïuje swoje odpowiedniczki z klasy StrictMath, które sÈ juĝ zaimplementowane w bibliotece dla odpowiedniej platformy, a implementacje metod w tej bibliotece bazujÈ juĝ na strictfp. Jeżeli słowo zastrzeżone strictfp nie jest obecne, wówczas obliczenia pośrednie nie są ograniczone do 32-bitowych i 64-bitowych reprezentacji zmiennopozycyjnych obsługiwanych przez Javę. W zamian w obliczeniach można korzystać z szerszych reprezentacji (w szczególno- ści 128-bitowych) na tych platformach, które takie reprezentacje obsługują. W przypadku reprezentacji wartości na 32 lub 64 bitach w trakcie obliczeń pośrednich może dojść do nadmiaru lub niedomiaru. Natomiast jeśli reprezentacja bazuje na większej liczbie bitów, prawdopodobieństwo wystąpienia nadmiaru lub niedomiaru się zmniejsza. Ze względu na te różnice zapewnienie pełnej przenośności nie jest możliwe. Dlatego słowo zastrzeżone strictfp do pewnego stopnia wyrównuje te niespójności przez nałożenie wymagania, by na wszystkich platformach obliczenia pośrednie były wykonywane na repre- zentacji 32-bitowej lub 64-bitowej. Gdy w deklaracji metody zostanie zawarte słowo zastrzeżone strictfp, będzie ono gwa- rantować, że wszystkie wykonywane w metodzie obliczenia zmiennopozycyjne zostaną wy- konane zgodnie z regułami zapewnienia precyzji. Słowo zastrzeżone strictfp można umieścić 253 JAVA. PRZYGOTOWANIE DO PROGRAMOWANIA NA PLATFORM} ANDROID również w deklaracji klasy (na przykład public strictfp class FourierTransform), aby zapewnić, że wszystkie obliczenia zmiennopozycyjne wykonywane w ramach tej klasy będą przeprowadzane z zapewnieniem właściwej precyzji. „ Uwaga • Klasy Math i StrictMath sÈ zadeklarowane jako final i dlatego nie moĝna ich rozszerzaÊ. Ponadto w klasach tych znajdujÈ siÚ deklaracje prywatnych, pustych i bezargumentowych konstrukto- rów, co powoduje, ĝe nie moĝna tworzyÊ ich instancji. Klasy Math i StrictMath to przykïady tak zwanych klas narzÚdziowych (ang. utility classes), poniewaĝ wyznaczajÈ one obszar zarezerwowany dla staïych narzÚdziowych oraz metod narzÚdziowych (static). Klasa BigDecimal W rozdziale 2. zdefiniowano klasę CheckingAccount z polem o nazwie balance. Zgodnie z deklaracją pole balance jest typu int, a dodatkowo w kodzie źródłowym został umieszczony komentarz, według którego pole balance reprezentuje liczbę złotych, jaką można wypłacić z konta. Alternatywnie można było wskazać, że pole balance zawiera liczbę groszy dostęp- nych do wypłaty. Można zadać pytanie, dlaczego pole balance nie zostało zadeklarowane jako pole typu double lub float. Dzięki temu w polu balance można by przechowywać na przykład wartość 18,26 (18 złotych w części całkowitoliczbowej i 26 groszy w części ułamkowej). Pole balance nie zostało zadeklarowane jako typu float lub double z następujących względów: x Nie wszystkie wartości zmiennopozycyjne, które mogą reprezentować kwoty pienięż- ne (w złotych i groszach), mogą być przechowywane w pamięci z odpowiednią precy- zją. Na przykład liczba 0.1 (która może oznaczać 10 groszy) nie posiada precyzyjnej reprezentacji w pamięci. Gdyby wykonano wyrażenie double total = 0.1; for (int i = 0; i 50; i++) total += 0.1; System.out.println(total);, jego wynikiem byłaby wartość 5.099999999999998, a nie prawidłowa wartość 5.1. x Wynik każdego obliczenia zmiennopozycyjnego musi zostać zaokrąglony do jednego grosza. Jeżeli tak się nie stanie, w obliczeniach pojawią się drobne niedokładności, które w efekcie mogą spowodować, że ostateczny wynik będzie się znacznie różnił od prawidłowego. Wprawdzie klasa Math udostępnia dwie metody round(), za pomocą których można próbować zaokrąglać wyniki obliczeń do jednego grosza, lecz metody te zaokrąglają wartości do najbliższych liczb całkowitych (czyli złotych). Aplikacja InvoiceCalc z listingu 6.3 ilustruje obydwa wspomniane problemy. Jednak pierwszy z tych problemów nie jest aż tak poważny, ponieważ nie wpływa znacząco na do- kładność ostatecznego wyniku. Zdecydowanie bardziej istotny jest drugi problem, przez który wyniki obliczeń nie są zaokrąglane do jednego grosza. Listing 6.3. Obliczanie zmiennopozycyjnej wartości faktury, które prowadzi do powstania błędów import java.text.NumberFormat; class InvoiceCalc { 254 ROZDZIA’ 6. „ PODSTAWOWE INTERFEJSY API — CZ}¥m I final static double DISCOUNT_PERCENT = 0.1; // 10 final static double TAX_PERCENT = 0.05; // 5 public static void main(String[] args) { double invoiceSubtotal = 285.36; double discount = invoiceSubtotal*DISCOUNT_PERCENT; double subtotalBeforeTax = invoiceSubtotal-discount; double salesTax = subtotalBeforeTax*TAX_PERCENT; double invoiceTotal = subtotalBeforeTax+salesTax; NumberFormat currencyFormat = NumberFormat.getCurrencyInstance(); System.out.println( Suma: + currencyFormat.format(invoiceSubtotal)); System.out.println( Rabat: + currencyFormat.format(discount)); System.out.println( Suma po uwzglÚdnieniu rabatu: + currencyFormat.format(subtotalBeforeTax)); System.out.println( Podatek: + currencyFormat.format(salesTax)); System.out.println( ’Ècznie: + currencyFormat.format(invoiceTotal)); } } Na listingu 6.3 wykorzystano klasę NumberFormat (z pakietu java.text) i jej metodę format(), aby sformatować wartość zmiennopozycyjną o podwójnej precyzji na postać wartości wa- lutowej. Więcej na temat klasy NumberFormat powiemy w rozdziale 9. Gdy uruchomi się aplika- cję InvoiceCalc, zwróci ona następujący wynik: Suma: 285,36 zï Rabat: 28,54 zï Suma po uwzglÚdnieniu rabatu: 256,82 zï Podatek: 12,84 zï ’Ècznie: 269,67 zï W wynikach działania aplikacji prawidłowo obliczone zostały kwoty sumy, rabatu, sumy po uwzględnieniu rabatu i podatku. Nieprawidłowo natomiast wskazana jest kwota łączna, której wartość wynosi 269,67 zamiast 269,66. Klient nie będzie skłonny zapłacić dodatko- wego grosza, mimo że zgodnie z regułami obliczeń zmiennopozycyjnych to właśnie kwota 269,67 jest wartością prawidłową: Suma: 285,36 Rabat: 28,536 Suma po uwzglÚdnieniu rabatu: 256,824 Podatek: 12,8412 ’Ècznie: 269,6652 Źródłem problemu jest to, że po wykonaniu każdej operacji, a przed wykonaniem ope- racji następnej uzyskany wynik nie jest zaokrąglany do najbliższego grosza. W efekcie 0,024 w liczbie 256,824 oraz 0,012 w liczbie 12,84 są uwzględniane także w kwocie końcowej, przez co metoda format() klasy NumberFormat zaokrągla kwotę końcową do wartości 269,67. Java udostępnia rozwiązanie obydwóch problemów w postaci klasy java.math.BigDecimal. Jest to klasa niezmienna (to znaczy instancja klasy BigDecimal nie może być zmieniona), która reprezentuje liczbę dziesiętną o określonym znaku (na przykład 23,653) ze wskazana precyzją (liczbą cyfr) i odpowiednią skalą (czyli z uwzględnieniem liczby całkowitej wyzna- czającej liczbę cyfr po przecinku). 255 JAVA. PRZYGOTOWANIE DO PROGRAMOWANIA NA PLATFORM} ANDROID W klasie BigDecimal zadeklarowano trzy wygodne stałe: ONE, TEN i ZERO. Każda z tych stałych jest odpowiednikiem wartości 1, 10 i 0 ze skalą zerową. „ Ostrzeĝenie • W klasie BigDecimal zadeklarowano kilka staïych, których nazwy zaczynajÈ siÚ od sïo- wa ROUND_. Staïe te sÈ w wiÚkszoĂci przestarzaïe i powinno siÚ ich unikaÊ. To samo dotyczy metod public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode) oraz public BigDecimal setScale(int newScale, int roundingMode), które sÈ nadal obecne w klasie, aby zagwarantowaÊ prawidïowÈ kompilacjÚ starszego kodu. Klasa BigDecimal deklaruje ponadto kilka przydatnych konstruktorów i metod. Wybra- ne konstruktory i metody zostały opisane w tabeli 6.2. Tabela 6.2. Konstruktory i metody klasy BigDecimal Opis Inicjalizuje instancję klasy BigDecimal liczbą cyfr wskazywaną przez val i skalą 0. Inicjalizuje instancję klasy BigDecimal dziesiętnym odpowiednikiem val. Jako skalę ustawia liczbę cyfr po przecinku lub 0, jeżeli przecinek nie występuje. Jeśli val będzie null, konstruktor rzuci wyjątek java.lang.NullPointerException. Jeżeli reprezentacja val w postaci ciągu znaków będzie nieprawidłowa (na przykład będzie zawierała litery), konstruktor rzuci wyjątek java.lang.NumberFormatException. Zwraca nową instancję klasy BigDecimal, która zawiera bezwzględną wartość wartości instancji bieżącej. Skala nowej instancji jest taka sama jak skala instancji bieżącej. Zwraca nową instancję klasy BigDecimal, która zawiera sumę wartości bieżącej oraz argumentu przekazanego do konstruktora. Skala w nowej instancji jest wyznaczana przez wartość większą spośród skali instancji bieżącej i skali instancji przekazanej jako argument. Jeżeli augend będzie null, metoda rzuci wyjątek NullPointerException. Zwraca nową instancję klasy BigDecimal, która zawiera iloraz wartości bieżącej podzielonej i wartości argumentu. Skala nowej instancji to różnica między skalą instancji bieżącej i skalą instancji przekazanej jako argument. Skala ta może zostać odpowiednio dostosowana, jeżeli do przedstawienia wyniku dzielenia potrzebna będzie większa liczba cyfr. Jeżeli divisor będzie null, metoda rzuci wyjątek NullPointerException, a jeżeli divisor będzie reprezentować wartość 0 lub wyniku dzielenia nie będzie można zaprezentować precyzyjnie, metoda rzuci wyjątek java.lang.ArithmeticException. Zwraca this lub val, zależnie od tego, która z tych instancji posiada większą wartość. Jeżeli val będzie null, metoda rzuci wyjątek NullPointerException. Zwraca this lub val, zależnie od tego, która z tych instancji posiada mniejszą wartość. Jeżeli val będzie null, metoda rzuci wyjątek NullPointerException. Metoda BigDecimal(int val) BigDecimal(String val) BigDecimal abs() BigDecimal add(BigDecimal augend) BigDecimal divide(BigDecimal divisor) BigDecimal max(BigDecimal val) BigDecimal min(BigDecimal val) 256 Tabela 6.2. Konstruktory i metody klasy BigDecimal — ciąg dalszy ROZDZIA’ 6. „ PODSTAWOWE INTERFEJSY API — CZ}¥m I Metoda BigDecimal multiply(BigDecimal multiplicand) BigDecimal negate() int precision() BigDecimal remainder(BigDecimal divisor) int scale() BigDecimal setScale(int newScale, RoundingMode roundingMode) BigDecimal subtract(BigDecimal subtrahend) String toString() Opis Zwraca nową instancję klasy BigDecimal, która zawiera iloczyn wartości bieżącej i wartości instancji podanej jako argument. Skala nowej instancji jest sumą skali instancji bieżącej i instancji przekazanej jako argument. Jeżeli multiplicand jest null, metoda rzuci wyjątek NullPointerException. Zwraca nową instancję klasy BigDecimal, która zawiera wartość przeciwną do wartości bieżącej. Skala nowej instancji jest taka sama jak skala instancji bieżącej. Zwraca precyzję bieżącej instancji klasy BigDecimal. Zwraca nową instancję klasy BigDecimal, która zawiera resztę z dzielenia wartości instancji bieżącej przez wartość instancji przekazanej jako argument. Skala nowej instancji to różnica między skalą bieżącą i skalą argumentu. Skala ta może zostać odpowiednio dostosowana, jeżeli do wyświetlenia wyniku potrzeba będzie większej liczby cyfr. Jeżeli divisor będzie null, metoda rzuci wyjątek NullPointerException, a jeśli divisor będzie mieć wartość 0, metoda rzuci wyjątek ArithmeticException. Zwraca skalę bieżącej instancji klasy BigDecimal. Zwraca nową instancję klasy BigDecimal o wskazanej skali i trybie zaokrąglania. Jeżeli nowa skala jest większa niż skala dotychczasowa, wówczas do wartości, które były niewyskalowane, dodawane są zera. W takiej sytuacji nie potrzeba wykonywać zaokrąglania. Jeżeli nowa skala jest mniejsza niż skala dotychczasowa, wówczas usuwane są ostatnie cyfry. Jeżeli usuwane cyfry są inne niż zero, uzyskana w ten sposób liczba niewyskalowana musi zostać zaokrąglona. Zaokrąglenie wykonuje się w trybie zaokrąglania wskazanym jako argument. Jeżeli roundingMode jest null, metoda rzuci wyjątek NullPointerException. Jeżeli natomiast roundingMode będzie mieć wartość RoundingMode.ROUND_UNNECESSARY, a ze względu na bieżącą skalę zaokrąglenie będzie potrzebne, metoda rzuci wyjątek ArithmeticException. Zwraca nową instancję klasy BigDecimal, która zawiera wartość bieżącą pomniejszoną o wartość argumentu. Skala nowej instancji jest większą spośród skali bieżącej i skali argumentu. Jeżeli subtrahend będzie null, metoda rzuci wyjątek NullPointerException. Zwraca ciąg znaków, który stanowi reprezentację bieżącej instancji BigDecimal. Jeżeli to konieczne, zostanie użyta notacja naukowa. W tabeli 6.2 wspomniano o typie RoundingMode wyznaczającym tryb zaokrąglania. Rounding ´Mode to typ wyliczeniowy enum, który zawiera stałe odpowiadające różnorodnym trybom zaokrąglania. Stałe te opisano w tabeli 6.3. Najlepszym sposobem oswojenia się z klasą BigDecimal jest zastosowanie jej w praktyce. Na listingu 6.4 wykorzystano tę klasę do wykonania prawidłowych obliczeń wartości na faktu- rze, którą przedstawiono wcześniej na listingu 6.3. 257 JAVA. PRZYGOTOWANIE DO PROGRAMOWANIA NA PLATFORM} ANDROID Tabela 6.3. Stałe typu RoundingMode Staïa CEILING DOWN FLOOR HALF_DOWN HALF_EVEN HALF_UP UNNECESSARY UP Opis Zaokrągla w kierunku plus nieskończoności. Zaokrągla w kierunku zera. Zaokrągla w kierunku minus nieskończoności. Zaokrągla w kierunku „bliższej liczby sąsiedniej”, chyba że odległość do liczb sąsiednich jest taka sama — wówczas zaokrągla w dół. Zaokrągla w kierunku „bliższej liczby sąsiedniej”, chyba że odległość do liczb sąsiednich jest taka sama — wówczas zaokrągla w stronę tej liczby sąsiedniej, która jest parzysta. Zaokrągla w kierunku „bliższej liczby sąsiedniej”, chyba że odległość do liczb sąsiednich jest taka sama — wówczas zaokrągla w górę (o tym trybie zaokrąglania najczęściej uczy się w szkole). Zaokrąglanie nie jest potrzebne, ponieważ wynik działania jest zawsze dokładny. Liczby dodatnie są zaokrąglane w kierunku plus nieskończoności, a liczby ujemne są zaokrąglane w kierunku minus nieskończoności. Listing 6.4. Obliczenia wartości na fakturze przy użyciu klasy BigDecimal, dzięki której unika się błędów zaokrągleń class InvoiceCalc { public static void main(String[] args) { BigDecimal invoiceSubtotal = new BigDecimal( 285.36 ); BigDecimal discountPercent = new BigDecimal( 0.10 ); BigDecimal discount = invoiceSubtotal.multiply(discountPercent); discount = discount.setScale(2, RoundingMode.HALF_UP); BigDecimal subtotalBeforeTax = invoiceSubtotal.subtract(discount); subtotalBeforeTax = subtotalBeforeTax.setScale(2, RoundingMode.HALF_UP); BigDecimal salesTaxPercent = new BigDecimal( 0.05 ); BigDecimal salesTax = subtotalBeforeTax.multiply(salesTaxPercent); salesTax = salesTax.setScale(2, RoundingMode.HALF_UP); BigDecimal invoiceTotal = subtotalBeforeTax.add(salesTax); invoiceTotal = invoiceTotal.setScale(2, RoundingMode.HALF_UP); System.out.println( Suma: + invoiceSubtotal); System.out.println( Rabat: + discount); System.out.println( Suma po uwzglÚdnieniu rabatu: + subtotalBeforeTax); System.out.println( Podatek: + salesTax); System.out.println( ’Ècznie: + invoiceTotal); } } W metodzie main() z listingu 6.4 najpierw tworzone są obiekty BigDecimal o nazwach invoiceSubtotal i discountPercent, inicjalizowane wartościami odpowiednio 285.36 i 0.10. Wartość invoiceSubtotal jest mnożona przez discountPercent, a wynikowa instancja klasy BigDecimal tego mnożenia jest przypisywana zmiennej discount. Na tym etapie zmienna discount ma wartość 28.5360. Jeśli nie liczyć ostatniego zera, war- tość ta jest taka sama jak wartość wynikowa wyrażenia invoiceSubtotal*DISCOUNT_PERCENT 258 ROZDZIA’ 6. „ PODSTAWOWE INTERFEJSY API — CZ}¥m I z listingu 6.3. Wartością, która powinna zostać przypisana zmiennej discount, jest 28.54. Aby rozwiązać ten problem jeszcze przed wykonaniem kolejnego obliczenia, w metodzie main() jest wywoływana metoda setScale() z następującymi argumentami: x 2 — dwie cyfry po przecinku. x RoundingMode.HALF_UP — standardowy sposób zaokrąglania. Gdy określona jest już odpowiednia skala i tryb zaokrąglania, metoda main() odejmuje discount od invoiceSubtotal, a instancję BigDecimal stanowiącą reprezentację uzyskanej różnicy przypisuje zmiennej subtotalBeforeTax. Następnie na zmiennej subtotalBeforeTax jest wywoływana metoda setScale(), aby odpowiednio zaokrąglić jej wartość przed wyko- naniem kolejnego obliczenia. W kolejnym kroku main() tworzy obiekt klasy BigDecimal o nazwie salesTaxPercent, który zostaje zainicjalizowany wartością 0.05. Dalej subtotalBeforeTax zostaje przemnożo- na przez salesTaxPercent, a iloczyn jest przypisywany zmiennej salesTax. Na tej zmiennej, której typem jest BigDecimal, jest wywoływana metoda setScale(), aby odpowiednio za- okrąglić wartość reprezentowaną przez ten obiekt. Po wykonaniu tej czynności main() dodaje salesTax do subtotalBeforeTax. Suma zo- staje przypisana zmiennej invoiceTotal, na której metoda setScale() dokonuje odpowiedniego zaokrąglenia. Na koniec wartości wszystkich obiektów klasy BigDecimal zostają przekazane do standardowego wyjścia za pomocą metody System.out.println(), która wywołuje na każdym obiekcie ich metody toString(), aby uzyskać ciąg znaków reprezentujący wartości poszcze- gólnych instancji BigDecimal. Gdy tak zmodyfikowana wersja aplikacji InvoiceCalc zostanie uruchomiona, uzyskamy następujący wynik: Suma: 285,36 Rabat: 28,54 Suma po uwzglÚdnieniu rabatu: 256,82 Podatek: 12,84 ’Ècznie: 269,66 „ Ostrzeĝenie • Klasa BigDecimal deklaruje konstruktor BigDecimal(double val), którego w miarÚ moĝliwoĂci powinno siÚ unikaÊ. Konstruktor ten inicjalizuje instancjÚ klasy BigDecimal wartoĂciÈ przekazanÈ jako val, przez co w sytuacji gdy wartoĂÊ typu double nie moĝe zostaÊ przedstawiona jako wartoĂÊ dokïad- na, tak utworzona instancja moĝe odzwierciedlaÊ nieprawidïowÈ reprezentacjÚ wartoĂci. Na przykïad wyni- kiem wywoïania BigDecimal(0.1) instancja z wartoĂciÈ 0.10000000000000000555111512 ´31257827021181583404541015625. Z kolei wywoïanie BigDecimal( 0.1 ) daje w wyniku instancjÚ z prawidïowÈ wartoĂciÈ 0.1. jest Klasa BigInteger Klasa BigDecimal przechowuje liczbę dziesiętną ze znakiem w postaci niewyskalowanej wartości ze skalą określoną przez 32-bitową liczbę całkowitą. Wartość niewyskalowana jest przechowywana w instanc
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Java. Przygotowanie do programowania na platformę Android
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


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