Programowanie W Jezyku Java. Zbior Zadan Z Podpowiedziami - Wiesaw Rychlicki

Ebookpoint.pl kopia dla: pawher@o2.
pl
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.
Redaktor prowadzący: Ewelina Burska
Projekt okładki: Studio Gravite/Olsztyn

Obarek, Pokoński, Pazdrijowski, Zaprucki
Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock.
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?projaz_ebook
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Materiały do książki można znaleźć pod adresem:

ftp://ftp.helion.pl/przyklady/projaz.zip
ISBN: 978-83-246-6366-8
Copyright © Helion 2012
Printed in Poland.
• Poleć książkę na Facebook.com • Księgarnia internetowa
• Kup w wersji papierowej • Lubię to! » Nasza społeczność
• Oceń książkę
Ebookpoint.pl kopia dla: pawher@o2.pl

Spis treci
Od autora ......................................................................................... 5
Rozdzia 1. Pierwszy krok — rozpoczynamy
nauk programowania w jzyku Java ................................................. 7
1. Historia Javy i pierwsze zadania ................................................................................... 7
2. JDK, Notatnik i klasyczny przykad „Hello World” ..................................................... 9
3. Znaki, tablice znaków i klasa String ........................................................................... 11
4. Klasa String — operacje na tekstach .......................................................................... 15
5. Tablica argumentów aplikacji ..................................................................................... 18
6. Prawda czy fasz — logiczny typ danych ................................................................... 19
7. Liczby cakowite typu int i klasa Integer .................................................................... 22
8. Inne typy liczb cakowitych w Javie ........................................................................... 25
9. Typy liczb zmiennoprzecinkowych ............................................................................ 27
Rozdzia 2. Drugi krok — operacje wejcia-wyjcia
i instrukcje sterujce w Javie ......................................................... 31
10. Wywietlanie sformatowanych wyników w konsoli.
Stae i metody z klasy Math ..................................................................................... 31
11. Wczytywanie danych — klasa Scanner .................................................................... 34
12. Operacje na tekstach — klasy StringBuffer i StringBuilder ..................................... 36
13. Instrukcje warunkowe i instrukcja selekcji ............................................................... 38
14. Instrukcja ptli typu do-while ................................................................................... 41
15. Instrukcja ptli typu while ........................................................................................ 42
16. Instrukcja ptli typu for ............................................................................................ 44
Rozdzia 3. Trzeci krok — budujemy wasne metody i klasy ............................... 47
17. Obsuga wyjtków .................................................................................................... 47
18. Liczby pseudolosowe i tablice jednowymiarowe
— budujemy metody statyczne ................................................................................ 48
19. Dokumentacja klasy ................................................................................................. 53
20. Dziaania na uamkach — budujemy klas Fraction ................................................. 55
21. Klasa opakowujca Angle — miara kta i funkcje trygonometryczne ..................... 61
22. Liczby rzymskie i klasa Roman ................................................................................ 64
23. Trójmian kwadratowy i klasa QuadratPoly .............................................................. 66
24. Liczby zespolone — budujemy klas Complex ........................................................ 69

4 Programowanie w jzyku Java
Rozdzia 4. Czwarty krok — pliki, tablice i macierze ......................................... 77

25. Operacje na plikach tekstowych ............................................................................... 77
26. Tablice jednowymiarowe i wielomiany .................................................................... 80
27. Obliczenia statystyczne ............................................................................................ 82
28. Tablice wielowymiarowe i macierze ........................................................................ 87
29. Obliczanie wartoci funkcji, rekurencja i inne zadania ............................................. 92
Rozdzia 5. Rozwizania zada z rozdziau 1 ...................................................... 97
1. Historia Javy i pierwsze zadania ................................................................................. 97
2. JDK, Notatnik i klasyczny przykad „Hello World” ................................................. 101
3. Znaki, tablice znaków i klasa String ......................................................................... 104
4. Klasa String — operacje na tekstach ........................................................................ 111
5. Tablica argumentów aplikacji ................................................................................... 117
6. Prawda czy fasz — logiczny typ danych ................................................................. 120
7. Liczby cakowite typu int i klasa Integer .................................................................. 129
8. Inne typy liczb cakowitych w Javie ......................................................................... 135
9. Typy liczb zmiennoprzecinkowych .......................................................................... 140
Rozdzia 6. Rozwizania zada z rozdziau 2 .................................................... 147
10. Wywietlanie sformatowanych wyników w konsoli.
Stae i metody z klasy Math ................................................................................... 147
11. Wczytywanie danych — klasa Scanner .................................................................. 152
12. Operacje na tekstach — klasy StringBuffer i StringBuilder ................................... 157
13. Instrukcje warunkowe i instrukcja selekcji ............................................................. 162
14. Instrukcja ptli typu do-while ................................................................................. 179
15. Instrukcja ptli typu while ...................................................................................... 187
16. Instrukcja ptli typu for .......................................................................................... 193
17. Obsuga wyjtków .................................................................................................. 201
18. Liczby pseudolosowe i tablice jednowymiarowe
— budujemy metody statyczne .............................................................................. 206
19. Dokumentacja klasy ............................................................................................... 221
20. Dziaania na uamkach — budujemy klas Fraction ............................................... 237
21. Klasa opakowujca Angle — miara kta i funkcje trygonometryczne ................... 269
22. Liczby rzymskie i klasa Roman .............................................................................. 290
23. Trójmian kwadratowy i klasa QuadratPoly ............................................................ 301
24. Rozwizania zada — liczby zespolone ................................................................. 318
25. Operacje na plikach tekstowych ............................................................................. 347
26. Tablice jednowymiarowe i wielomiany .................................................................. 358
27. Obliczenia statystyczne .......................................................................................... 370
28. Tablice wielowymiarowe i macierze ...................................................................... 385
29. Obliczanie wartoci funkcji, rekurencja i inne zadania ........................................... 420

Od autora
Niniejszy zbiór zada jest propozycj dla rozpoczynajcych nauk programowania
w jzyku Java. Jak sugeruje tytu (moe nieco dziwnie zbudowany), Czytelnik znaj-
dzie tutaj zadania z zakresu programowania i podpowiedzi (wskazówki) dotyczce tego,
jak zabra si do ich rozwizywania. Jeli informacja zawarta w treci zadania i ewen-
tualna podpowied (wskazówka, uwaga) oka si niewystarczajce, to mona sign
do odpowiedzi, gdzie zawarto dodatkowe wskazówki, istotne fragmenty rozwizania
lub kompletne listingi kodów ródowych. Kady dzia jest poprzedzony krótkim wpro-
wadzeniem teoretycznym, przykadem lub linkiem do odpowiedniego fragmentu do-
kumentacji jzyka zamieszczonej w internecie.
W pocztkowych rozdziaach umieszczono w tekcie zada sugerowane nazwy plików

ródowych (np. w zadaniu 2.3 zaproponowano nazw pliku Adres.java). Rozwizu-
jc zadanie, Czytelnik powinien pamita, e nazwa klasy musi by identyczna z na-
zw pliku (bez rozszerzenia). Sugerowanie nazw plików (a przy tym nazw klas) ma
na celu przyzwyczajenie Czytelnika do dobierania nazw klas odpowiednich do treci
zadania. Ponadto róne nazwy plików (klas) umoliwiaj gromadzenie rozwiza kilku
zada w tym samym folderze. W dalszej czci zbioru zaproponowano nazwy plików
zgodne z numerami zada, np. rozwizanie zadania 13.8 zapisano w pliku Z13_8.java,
a inny wariant rozwizania tego zadania zapisano w pliku Z13_8a.java. Aby uatwi
Czytelnikowi poszukiwanie plików z rozwizaniami, rozwizanie na przykad zadania
2.3 (i innych pocztkowych zada) zawarto dodatkowo w pliku Z02_3.java. Wszyst-
kie pliki ródowe umieszczono na serwerze ftp://ftp.helion.pl/przyklady/projaz.zip).


Rozdzia 1.
Pierwszy krok
— rozpoczynamy
nauk programowania
w jzyku Java
1. Historia Javy i pierwsze zadania
Zespó inynierów z firmy Sun, pracujc pod kierownictwem Jamesa Goslinga, roz-
pocz w 1991 roku projekt pod nazw Green. Celem projektu byo utworzenie jzyka
programowania dla niewielkich urzdze elektronicznych. Jzyk mia by niezaleny
od platformy sprztowej. Doprowadzio to do utworzenia kodu poredniego dla maszy-
ny wirtualnej, który mona uruchamia w kadym urzdzeniu wyposaonym w odpo-
wiedni interpreter. Przez kilka lat projekt rozwija si, ale produkt nie uzyskiwa po-
danej popularnoci. Jzyk pocztkowo nazwano Oak (db), ale gdy okazao si, e
ta nazwa jest ju zajta, zmieniono j na Java.
Przeomem w rozwoju tego jzyka stao si napisanie w nim przegldarki internetowej
HotJava. Umoliwiaa ona uruchamianie kodu wbudowanego w strony internetowe,
czyli tzw. apletów. Efekty pracy opublikowano w maju 1995 roku w magazynie „Sun
Word” i odtd Java zacza zyskiwa popularno.
Na pocztku 1996 roku ukazaa si pierwsza oficjalna wersja jzyka — Java 1.0. Ha-
sem promujcym Jav byo zdanie Write Once, Run Anywhere („Napisz raz, urucha-
miaj wszdzie”). W kolejnych wersjach uzupeniano zauwaone braki i dodawano nowe
funkcjonalnoci. Systematycznie rosa liczba klas i interfejsów:

JDK1 1.0 (23 stycznia 1996 r. — 211 klas i interfejsów) — pierwsza oficjalna
wersja Javy.
JDK 1.1 (19 lutego 1997 r. — 477 klas i interfejsów).
J2SE2 1.2 (8 grudnia 1998 r. — 1524 klasy i interfejsy) — nazwa kodowa
Playground.
J2SE 1.3 (8 maja 2000 r. — 1840 klas i interfejsów) — nazwa kodowa
Kestrel.
J2SE 1.4 (6 lutego 2002 r. — 2723 klasy i interfejsy) — nazwa kodowa
Merlin.
J2SE 5.03 (30 wrzenia 2004 r. — 3270 klas i interfejsów) — nazwa kodowa
Tiger.
Java SE 64 (11 grudnia 2006 r. — 3777 klas i interfejsów) — nazwa kodowa
Mustang.
Java SE 7 (28 lipca 2011 r.) — nazwa kodowa Dolphin.
W 2007 roku firma Sun ogosia, e kolejne wersje jzyka bd dostpne na licencji
GPL i taka jest wanie licencja dla wersji Java SE 7. Autor podczas pracy nad zbio-
rem zada uywa wersji Java SE 6. Wszystkie przedstawione rozwizania nie bd
sprawia problemów w Java SE 7. Od 27 stycznia 2010 roku nowym wacicielem
Javy jest firma Oracle, która kupia firm Sun Microsystems.
Zadanie 1.1.
Przygotuj komputer do programowania w jzyku Java.
Poszukaj niezbdnych plików w internecie, wykorzystujc np. fraz Java download,

i zainstaluj je.
Zadanie 1.2.
Sprawd , czy rodowisko JDK do programowania w jzyku Java jest poprawnie zain-
stalowane na Twoim komputerze. Jak wersj rodowiska masz zainstalowan?
1
Java Development Kit — pakiet udostpniajcy kod bajtowy wszystkich klas standardowych, maszyn
wirtualn do ich uruchamiania oraz róda klas i narzdzia niezbdne do programowania w jzyku Java
(m.in. kompilator, paker, debuger).
2
Java 2 Platform, Standard Edition — podstawowa wersja platformy Java, pozwalajca tworzy i uru-
chamia aplikacje napisane w jzyku Java na komputerach stacjonarnych i serwerach. Od tego wyda-
nia Java rozwija si w trzech wersjach: J2SE, J2EE (Java 2 Platform, Enterprise Edition — serwerowa
platforma programistyczna jzyka Java) i J2ME (Java 2 Platform Micro Edition — uproszczona wer-
sja platformy Java, zaprojektowana z myl o tworzeniu aplikacji mobilnych dla urzdze o bardzo
ograniczonych zasobach).
3
Dotychczasow numeracj 1.5 zmieniono na 5.0.
4
J2SE zastpiono Java SE, a z numeracji usunito 0. Nadal jednak uywa si równie oznaczenia 1.6.

Rozdzia 1. i Pierwszy krok — rozpoczynamy nauk programowania w jzyku Java 9
Sprawd w oknie konsoli (praca w trybie MS-DOS) dziaanie polece java i javac.
Zadanie 1.3.
Przygotuj „cigawk” z instrukcj uruchamiania wirtualnej maszyny Javy (JVM).
Skorzystaj z opcji pomocy, jak oferuje program java.exe.
Zadanie 1.4.
Przygotuj „cigawk” z instrukcj uruchamiania kompilatora Javy (javac.exe).
Metoda zastosowana w rozwizaniu zadania 1.3 nie sprawdzi si w tym przypadku.
Informacje s zawsze wywietlane na ekranie. Naley poszuka innego rozwizania.
Zadanie 1.5.
Przygotuj folder, w którym bdziesz zapisywa swoje kody ródowe, i kilka plików
wsadowych uatwiajcych dalsz prac.
Na pocztek tak przygotowane narzdzia w zupenoci nam wystarcz. Autor nie jest
zwolennikiem strzelania z armaty do wróbli (generalnie uwaa, e strzelanie do wró-
bli nie jest wskazane), wobec tego nie proponuje Czytelnikowi uycia skomplikowa-
nych zintegrowanych rodowisk programistycznych (IDE) i wieloplikowych projektów
do kompilowania i uruchamiania kilku linijek kodu. Po wykonaniu tych zada moesz
kontynuowa nauk programowania w jzyku Java.
2. JDK, Notatnik i klasyczny

przykad „Hello World”
Ten przykad jest powielany w wielu podrcznikach i ma swoje odpowiedniki praw-
dopodobnie we wszystkich jzykach programowania.
Listing 1. Hello.java
public class Hello {
public static void main(String args[]) {
System.out.println("Hello World");
}
}
Zadanie 2.1.
Przepisz dokadnie kod ródowy podany na listingu 1. Skompiluj go i uruchom.

Skorzystaj z przygotowanych wczeniej plików wsadowych i dysku X:.
Zadanie 2.2.
Napisz polskojzyczn wersj klasycznego przykadu z zadania 2.1. Klas nazwij Witam;
uruchomiona aplikacja powinna wywietli w konsoli napis (w dwóch wierszach):
Witaj, wiecie.
Ucz si programowa w jzyku Java.
W systemie Windows kod ródowy pisany jest w Notatniku (strona kodowa

1250), a efekty pracy programu wywietlane s w konsoli (strona kodowa 852).
Powoduje to nieprawidowe wywietlanie liter z polskimi znakami diakrytycznymi.
Moliwe s dwa rozwizania:
1. Zmiana strony kodowej w konsoli poleceniem: chcp 1250.
2. Uruchamianie aplikacji poleceniem: java -Dfile.ecoding=CP852 NazwaKlasy.
W obu przypadkach w konsoli powinna by ustawiona czcionka TT Lucida Console.
Zadanie 2.3.
Napisz program, który wywietli na ekranie Twój adres w kilku wierszach, tak jak na-
pisaby go na kopercie (plik ródowy: Adres.java).
Uyj kilka razy instrukcji System.out.println("...");. Moesz równie zapisa

cay adres w jednym acuchu, wstawiajc we waciwych miejscach znak specjal-
ny \n, oznaczajcy przejcie do nowego wiersza (ang. new line).
Zadanie 2.4.
Napisz program, który wywietli na ekranie etykietk zawierajc Twoje imi i na-
zwisko (plik ródowy: Etykieta.java). Jako wzór (niekoniecznie do wiernego odtwo-
rzenia) przyjmij podany przykad:
******* Programowanie *******
* obiektowe w jzyku Java *
* Jan Nowak *
*****************************
W tym zadaniu i zadaniach podobnych wywietlenie wiersza tekstu (z przejciem

do nastpnego wiersza) moesz zrealizowa na kilka sposobów, dajcych dokad-
nie taki sam rezultat:
System.out.println("Wiersz tekstu...");
System.out.print("Wiersz tekstu...\n");
System.out.print("Wiersz tekstu..."); System.out.println();
Element odpowiedzialny za przejcie do nowego wiersza w kodzie wyróniono po-
grubieniem czcionki.

3. Znaki, tablice znaków i klasa String

Do reprezentacji znaków (liter, cyfr, znaków interpunkcyjnych i wielu innych symbo-
li) suy typ char. Do zapisania jednego znaku potrzeba 16 bitów (dwa bajty) i stoso-
wany jest standard Unicode.
Klasa Character opakowuje prosty typ char w obiekt; posiada jedno pole typu char
i szereg metod dziaajcych na znakach.
Najczciej posugujemy si staymi znakowymi, np. 'A' jest znakiem o kodzie 65.
W ten sposób moemy zapisywa wszystkie znaki widoczne na klawiaturze. Znaki
specjalne posiadaj symbole zastpcze: \b — backspace, \t — tabulator, \n — przej-
cie do nowego wiersza, \r — powrót karetki (przejcie na pocztek wiersza), \" —
znak cudzysowu, \' — znak apostrofu, \\ — znak lewego ukonika (ang. slash). Znaki
Unicode moemy zapisywa w notacji szesnastkowej — wartoci od \u0000 do \uFFFF
(65 536 znaków)5. W konsoli bd wywietlone poprawnie znaki zdefiniowane w wy-
branej czcionce, pozostae znaki zostan zastpione znakiem zapytania (?). Oto kilka
operacji na zmiennych typu char:
char a; // deklaracja zmiennej
a = 'A'; // przypisanie do zmiennej a znaku 'A' (staej znakowej 'A')
char b = 'B'; // zadeklarowanie zmiennej b i zainicjowanie jej wartoci 'B'
b = a; // przypisanie zmiennej b wartoci zmiennej a
char alfa = '\u03B1'; // grecka litera alfa ()
Przy okazji poznae komentarz liniowy (wierszowy) stosowany w kodach ródowych.

Tekst od znaków // do koca wiersza jest komentarzem (objanieniem dla programi-
sty) i kompilator go ignoruje.
Zwykle pojedyncze znaki nam nie wystarczaj, wic tworzymy tablice znaków. Zmien-
n tablicow (w tym przypadku tablic znaków) moemy zadeklarowa na dwa sposoby:
char[] znaki lub char znaki[]. Sowo znaki jest identyfikatorem (nazw) zmiennej,
natomiast char nazw typu danych przechowywanych w tablicy. Tablicami zawiera-
jcymi dane rónych typów bdziemy posugiwali si wielokrotnie. Na razie zadekla-
rowalimy zmienn znaki. Teraz moemy utworzy tablic za pomoc operatora new:
znaki = new char[15];
Tablica znaki moe przechowywa maksymalnie 15 elementów (tak warto podali-

my w chwili tworzenia tablicy) i s one indeksowane liczbami cakowitymi od 0 do
14 (o 1 mniej od rozmiaru tablicy). Mamy zatem dostp do elementów tablicy za po-
rednictwem zmiennych: znaki[0], znaki[1], …, znaki[14].
Pozostaje wypeni tablic wartociami, np.: znaki[0] = 'W', znaki[1] = 'i' itd. (pa-
mitajmy o zakresie indeksów; przekroczenie zakresu zakoczy si zgoszeniem wy-
jtku ArrayIndexOutOfBounds).
5
Na tym etapie ta informacja w zupenoci wystarczy. Obecnie standard Unicode umoliwia zakodowa-
nie wikszej liczby znaków. Zastosowano siedemnacie tzw. przestrzeni numeracyjnych. My ograniczy-
my si do podstawowej przestrzeni numeracyjnej.

Tablic znaków moemy równie wypeni wartociami (zainicjowa) w trakcie defi-

niowania:
char napis[] = {'W', 'i', 't', 'a', 'j'};
Rozmiar tej tablicy jest równy 5, a indeksy elementów zawieraj si w przedziale
od 0 do 4.
Tablica jest struktur danych stanowicych zestaw elementów tego samego typu.
Mamy dwie równowane deklaracje zmiennej tablicowej:

typ_danych[] nazwaTablicy;
typ_danych nazwaTablicy[];
Tablic moemy zainicjowa list wartoci umieszczon w nawiasach { }. Rozmiar

tablicy bdzie równy liczbie podanych elementów:
typ_danych nazwaTablicy[] = {element_1, element_2, ..., element_n};
Tablic moemy utworzy za pomoc operatora new. Tworzc tablic, naley okreli
liczb elementów:
// zmienna nazwaTablicy bya wczeniej zadeklarowana
nazwaTablicy = new typ_danych[liczba_elementów];
// deklaracja i tworzenie tablicy elementów
typ_danych[] nazwaTablicy = new typ_danych[liczba_elementów];
Rozmiar tablicy mona odczyta za pomoc odwoania nazwaTablicy.length6.
Indeksy elementów tablicy s liczbami cakowitymi i nale do przedziau od 0 do n–1,

gdzie n jest liczb elementów (rozmiarem) tablicy.
Zadanie 3.1.
Utwórz tablic znaków zawierajc napis Dzie dobry. Napisz aplikacj (plik ródo-
wy: Witaj.java), która wywietli napis w konsoli.
Parametrem wywoania metody print() lub println() (obiektu out z klasy System)
moe by warto typu char lub char[].
Zadanie 3.2.
Utwórz tablic zawierajc znaki sowa Informatyka. Napisz program wywietlajcy
znaki zawarte w tablicy w nastpujcy sposób (plik ródowy: Informatyka.java):
a) pionowo — kady znak w odrbnym wierszu,
b) poziomo — znaki rozdzielone dodatkowymi odstpami (tzw. spacjowanie
lub rozstrzelenie tekstu).
6
Tablica jest obiektem, który posiada pole (wasno) length. Pojcie to wkrótce bdzie wyjanione
dokadniej.

c) poziomo — wielkimi literami,

d) poziomo — maymi literami.
Parametrem metody print() (println()) moe by zmienna typu char. Przydatna

okae si równie klasa java.lang.Character opakowujca typ prosty char. Obiekt
typu Character posiada jedno pole typu char oraz szereg metod przetwarzaj-
cych znaki (zob. http://download.oracle.com/javase/1.4.2/docs/api/java/lang/
Character.html). Zamiany wartoci zmiennej znak typu char na wielk liter mona
dokona z wykorzystaniem metody Character.toUpperCase(znak). Zwrócony wy-
nik (obiekt typu Character) moe by parametrem metody print(). Zamiany na
mae litery dokonamy przy uyciu metody Character.toLowerCase(znak). Do po-
bierania znaków z tablicy mona zastosowa ptl typu for each.
Zadanie 3.3.
Utwórz tablic zawierajc znaki sowa programowanie. Napisz program zmieniaj-
cy zawarto tablicy i wywietlajcy efekty tych zmian (plik ródowy: Programowa-
nie.java):
a) zamie pierwsz liter na wielk,
b) zamie wszystkie litery na wielkie.
Tym razem ptla typu for each nie wystarczy. Przegldajc tablic, musimy mie
moliwo modyfikowania znaków. Aby zmodyfikowa znak, naley zna jego indeks.
Dostp do wszystkich znaków w tablicy dane uzyskamy, stosujc ptl typu for:
for(int i=0; i < dane.length; ++i) {
// tu wykonaj przeksztacenie zwizane z elementem dane[i]
}
Zadanie 3.4.
Utwórz tablic zawierajc znaki sowa programowanie. Napisz program wywietla-
jcy znaki zawarte w tablicy w kolejnoci odwrotnej — od koca do pocztku (plik
ródowy: Wspak1.java).
Mona zastosowa ptl for, w której nastpuje odliczanie w dó (od wartoci wik-
szych do mniejszych for(int i=dane.length–1; i >= 0; ––i) ....
Do przegldania (odczytu) zawartoci tablicy moemy wykorzysta ptl typ for each:
for(typ_danych z : tablica) instrukcja;
Zmienna z przyjmuje kolejno wartoci wszystkich elementów tablicy (od pocztku
do koca).
Do przegldania (odczytu) lub modyfikowania (zapisu) zawartoci tablicy moemy
wykorzysta ptl typu for:
for(int i = 0; i < tablica.length; ++i) instrukcja; /* Odliczanie w gór */

lub:
for(int i = tablica.length-1; i >= 0; --i) instrukcja; /* Odliczanie w dó */
Zadanie 3.5.
Utwórz tablic zawierajc znaki sowa programowanie. Napisz program odwracaj-
cy kolejno znaków w tablicy (plik ródowy: Wspak2.java).
Przestawiaj kolejno pary elementów tablicy: pierwszy z ostatnim, drugi z przedostat-

nim — a dojdziesz do rodka tablicy.
Zadanie 3.6.
Przeanalizuj kod podany na listingu 2. Przepisz kod i uruchom t aplikacj. Sprawd ,
czy wyniki na ekranie s zgodne z Twoimi oczekiwaniami. Na podstawie tego kodu
i dokumentacji klasy Character napisz wasn aplikacj pokazujc dziaanie wybra-
nej metody lub wartoci zdefiniowanych staych.
Listing 2. DemoCharacter.java
import static java.lang.System.*;
public class DemoCharacter {
/* Informacje o metodzie */
out.println("Klasa: java.lang.Character");
out.println("Metoda statyczna: digit\n");
out.println("static int digit(int ch, int radix)");
out.println("Returns the numeric value of the character ch
in the specified radix.");
out.println();
/* Przykadowa tablica znaków */
char znak[] = {'E', 'u', 'r', 'o', ' ', '2', '0', '1', '2'};
/* Demonstracja dziaania metody */
out.println("Warto znaku jako cyfry w ukadzie dziesitkowym
(radix = 10)");
for(char z : znak)
out.println("Znak: "+z+" Cyfra: "+Character.digit(z, 10));
out.println("Uwaga: -1 oznacza, e znak nie jest cyfr w tym
ukadzie liczbowym.");
out.println();
out.println("Warto znaku jako cyfry w ukadzie szesnastkowym
(radix = 16)");
for(char z : znak)
out.println("Uwaga: -1 oznacza, e znak nie jest cyfr w tym
ukadzie liczbowym.");
}
}

Zadanie 3.7.
Napisz program, który utworzy dziesicioelementow tablic znaków i wypeni j cy-
frami od 0 do 9 (plik ródowy: Cyfry.java).
Zadeklaruj tablic znaków o odpowiednim wymiarze. Wykorzystaj tabel kodów ASCII

i moliwo zamiany kodu znaku na odpowiadajcy mu znak np. przez rzutowanie:
(char)65 zamienia liczb 65 na znak o kodzie 65, czyli wielk liter 'A'.
Zadanie 3.8.
Napisz program, który utworzy szesnastoelementow tablic znaków i wypeni j cy-
frami ukadu szesnastkowego (plik ródowy: Cyfry16.java).
Moesz postpi podobnie jak w zadaniu 3.7 lub wykorzysta statyczn metod
forDigit() z klasy Character.
4. Klasa String — operacje na tekstach

W Javie nie ma wbudowanego typu prostego do przechowywania cigów (acuchów)
znaków. Kady acuch znaków jest obiektem klasy String nalecej do standardowej
biblioteki. Klasa String oferuje kilka konstruktorów i szereg metod (ponad 50) do prze-
twarzania acuchów. Literay acuchowe zapisujemy w cudzysowie, np. "Zadania
z programowania". Ten litera jest obiektem i na jego przykadzie zostanie pokazanych
kilka metod klasy String.
Zadanie 4.1.
Uruchom aplikacj, której kod ródowy przedstawiono na listingu 3. Na podstawie
obserwacji wyników dziaania programu opisz dziaanie uytych metod klasy String.
W przypadku wtpliwoci zajrzyj do dokumentacji jzyka Java (np. http://download.
oracle.com/javase/6/docs/api/java/lang/String.html).
Listing 3. TestString.java
public class TestString {
System.out.println("Zadania z programowania.");
System.out.println("Zadania z programowania.".charAt(0));
System.out.println("Zadania z programowania.".length());
System.out.println("Zadania z programowania.".charAt(23));
System.out.println("Zadania z programowania.".toUpperCase());
System.out.println("Zadania z programowania.".toLowerCase());
System.out.println("Zadania z programowania.".indexOf('z'));
System.out.println("Zadania z programowania.".indexOf("prog"));
System.out.println("Zadania z programowania.".replace('.', '?'));

System.out.println("Zadania z programowania.".
replace("adania", "dania"));
replaceAll("ania", "anka"));
replaceFirst("ania", "anka"));
System.out.println("Zadania z programowania.".substring(10));
System.out.println("Zadania z programowania.".substring(10, 17));
concat("\b z podpowiedziami."));
System.out.println("Zadania z programowania."+"\b"+
" z odpowiedziami.");
}
}
Oczywicie moemy tworzy zmienne typu obiektowego String. Poniewa raz utwo-
rzony acuch znaków (ang. string) nie moe by zmieniany, to kada operacja powo-
duje tworzenie nowego acucha. Zmienna jest referencj do acucha znaków, wic
moemy przypisa jej inny acuch (w szczególnoci zmieniony obraz acucha, który
wskazywaa wczeniej). Nie powoduje to problemów z pamici, gdy zbdne obiekty
w Javie s automatycznie usuwane. Utworzon zmienn naley zainicjowa:
String napis = "Zadania z programowania.";
lub:
String napis = new String("Zadania z programowania.");

acuch moemy równie utworzy z tablicy znaków, np.:
char[] znaki = {'z', 'a', 'd', 'a', 'n', 'i', 'e'};
String napis = new String(znaki);
Zadanie 4.2.
Napisz program z listingu 3., wykorzystujc zamiast literaów zmienne reprezentujce
obiekty typu String lub zmienne typu char. Klas nazwij DemoString.
Aby kod by czytelny, wprowad odpowiednie nazwy zmiennych, np. char kropka
= '.'; itp.
Rozwiemy teraz kilka zada podobnych do zada z rozdziau 3. Zastpimy tablic

znaków odpowiednim acuchem. Naley jednak pamita, e pomimo jednakowej
zawartoci te obiekty si róni. Moemy dokonywa konwersji w obie strony pomi-
dzy tablic i acuchem znaków.
Zadanie 4.3.
Utwórz acuch zawierajcy napis Dzie dobry. Napisz aplikacj (plik ródowy: WitajStr.
java), która wywietli napis w konsoli:
a) pionowo — kady znak w odrbnym wierszu,

b) poziomo — znaki rozdzielone dodatkowymi odstpami (tzw. spacjowanie

lub rozstrzelenie tekstu),
c) poziomo — wielkimi literami,
d) poziomo — maymi literami.
W podpunktach a) i b) moesz skorzysta z ptli typu for i metody charAt(). Mona

te dokona konwersji acucha na tablic znaków (metoda toCharArray() z klasy
String) i dalej postpowa wedug rozwizania zadania 3.2.
Zadanie 4.4.
Utwórz acuch znaków zawierajcy sowo programowanie. Napisz program zmie-
niajcy zawarto acucha i wywietlajcy efekty tych zmian (plik ródowy: Pro-
gramowanieStr.java):
a) zamie pierwsz liter na wielk,
b) zamie wszystkie litery na wielkie.
Moemy utworzy nowy acuch, speniajcy warunki zadania, i przypisa jego war-
to tej samej zmiennej. Dotychczasowa warto zostanie usunita z pamici w chwili,
gdy nie bdzie ju dalej potrzebna.
Zadanie 4.5.
Utwórz acuch znaków zawierajcy sowo programowanie. Napisz program, który
znaki zawarte w acuchu bdzie wywietla w kolejnoci odwrotnej, od koca do po-
cztku (plik ródowy: WspakStr1.java).
Zadanie 4.6.
Utwórz acuch znaków zawierajcy sowo programowanie. Napisz program odwra-
cajcy kolejno znaków w acuchu (plik ródowy: WspakStr2.java).
Zob. wskazówk do zadania 4.4.
Zadanie 4.7.
Napisz program, który utworzy acuch znaków wypeniony cyframi od 0 do 9 (plik
ródowy: CyfryStr.java).
Rozwizanie tego zadania jest zupenie banalne — poprawna odpowied to: String
cyfry = "0123456789";. Spróbuj jednak zbudowa ten acuch z poszczególnych
znaków (zob. zadanie 3.7). Takie podejcie do zagadnienia moe w przyszoci si
przyda .

Zadanie 4.8.
Napisz program, który utworzy acuch znaków wypeniony cyframi ukadu szesnast-
kowego (plik ródowy: CyfryStr16.java).
5. Tablica argumentów aplikacji

W nagówku metody main()jest zadeklarowana tablica argumentów String args[]
lub String[] args.
W tablicy zawarte s referencje do obiektów typu String przekazanych przez system

operacyjny podczas uruchomienia aplikacji poleceniem:
java NazwaKlasy parametr1 parametr2 ... parametrN
Pole args.length zawiera liczb przekazanych argumentów. Argumenty w progra-

mie s dostpne przy uyciu indeksów od 0 do args.length–1: args[0], args[1], …,
args[N–1], gdzie N oznacza liczb argumentów.
Jeli aplikacj wywoamy bez dodatkowych parametrów (java NazwaKlasy), czyli liczba
argumentów bdzie równa 0, to wtedy tablica args bdzie pusta (nie bdzie zawiera
adnego elementu).
W kolejnych zadaniach wykorzystamy tablic argumentów do przekazywania danych

do aplikacji.
Zadanie 5.1.
Napisz program, który wywietli na ekranie liczb argumentów wywoania aplikacji
oraz podane argumenty. Kady argument powinien by wywietlony w odrbnym wier-
szu (plik ródowy: Argumenty.java).
Do przegldania zawartoci tablicy wykorzystaj ptle typu for lub for each (zob.
zadanie 3.2).
Zadanie 5.2.
Napisz program (plik ródowy: Osoba.java), który uruchamiany z dwoma parame-
trami, imi i nazwisko, wywietli na ekranie w kolejnych wierszach te dane wedug
schematu:
Nazwisko: Kowalska
Imi: Maria
Nazwisko i imi: KOWALSKA Maria

Inicjay: MK
Login: KOmar
Wielkoci liter na wydruku powinny by zgodne z przykadem, niezalenie od tego,

jakie wielkoci liter wykorzysta uytkownik, podajc imi i nazwisko.
Wypisz bdy, które powstan podczas uruchomienia aplikacji z niewaciw liczb

parametrów.
Zadanie 5.3.
Napisz program (plik ródowy: ArgsWspak.java), który uruchomiony z kilkoma argu-
mentami wypisze list argumentów, oddzielonych odstpami, w odwrotnej kolejnoci.
Zadanie 5.4.
Napisz program (plik ródowy: ArgWspak.java), który uruchomiony z kilkoma argu-
mentami wypisze kady argument w odrbnym wierszu, odwracajc przy tym kolejno
znaków w argumencie.
Naley uy dwóch ptli, stosujc tzw. zagniedanie ptli. Zewntrzna ptla powin-
na odczyta kolejno wszystkie argumenty, a wpisana w jej ciele wewntrzna ptla
ma za zadanie odwróci kolejno znaków w biecym argumencie.
Zadanie 5.5.
Napisz program, który wywietli na ekranie etykietk zawierajc imi i nazwisko po-
dane jako parametry wywoania aplikacji (plik ródowy: EtykietaArg.java). Zmody-
fikuj odpowiednio rozwizanie zadania 2.4.
Oblicz dugo tekstu (imienia i nazwiska razem z odstpem midzy nimi), liczb
odstpów pomidzy midzy znakiem * a tekstem oraz po tekcie przed znakiem *.
Stosown liczb odstpów moesz wywietli w ptli lub wyci jako podacuch
z acucha zoonego z okrelonej liczby odstpów. Ze wzgldu na konieczno ob-
licze zadanie wyprzedza nieco omawian teori.
6. Prawda czy fasz

— logiczny typ danych
Prosty typ danych boolean moe przyjmowa jedn z dwóch wartoci: false (fasz)
i true (prawda). Te dwie wartoci su do oceny logicznej rónych zda (warunków)
i s podstaw do dziaania instrukcji sterujcych przebiegiem programu (instrukcji wa-
runkowych, instrukcji wyboru i ptli).
Klasa Boolean opakowuje prosty typ boolean.

Zadanie 6.1.
Napisz program, który w formie tabeli przedstawi dziaanie operatorów logicznych
(plik ródowy: OperatoryLogiczne.java).
Moesz zbudowa dwuelementow tablic wartoci logicznych i uy ptli typu for
each do pobierania wartoci z tej tablicy. Dziki zagniedeniu ptli moesz w atwy
sposób przetestowa wszystkie wartoci dla dwóch i wikszej liczby zda logicznych.
Do dyspozycji masz trzy operatory:
! — negacj (NOT),
& lub && — koniunkcj (iloczyn logiczny, AND),
| lub || — alternatyw (sum logiczn, OR).
Zadanie 6.2.
Napisz program (plik ródowy: PrawaLogiczne.java), który w formie tabeli przedsta-
wi dowód nastpujcych praw logicznych:
a) prawo wyczonego rodka p p ,
b) prawo niesprzecznoci p p ,
c) prawo podwójnego przeczenia p p .
W zapisie matematycznym wyrae logicznych zastosowano nastpujce symbole:

— negacja, — koniunkcja, — alternatywa, — równowano . Rów-
nowano moemy w programie zastpi operatorem jest równe (== — dwa znaki
równoci obok siebie). Wynikiem porównania dwóch wartoci nalecych do typu
prostego jest warto logiczna.
Zadanie 6.3.
Napisz program (plik ródowy: PrawaDeMorgana.java), który w formie tabeli przed-
stawi dowód praw De Morgana:
a) I prawo De Morgana — prawo zaprzeczenia koniunkcji
p q p q ,
b) II prawo De Morgana — prawo zaprzeczenia alternatywy
p q p q .
Zadanie 6.4.
Napisz program, który przedstawi tabel wartoci logicznych implikacji (plik ródo-
wy: Implikacja.java).

Przyjmijmy, e wartoci logiczne s uporzdkowane i false poprzedza true. Impli-

kacja jest faszywa tylko w jednym przypadku true false (z prawdziwych zao-
e nie mona udowodni tezy faszywej), w pozostaych przypadkach jest prawdziwa
(z prawdy wynika prawda, na podstawie faszywych zaoe mona udowodni za-
równo prawd, jak i fasz). Zauwamy, e stosujc operator mniejsze lub równe
(<=) dla dwóch wartoci logicznych, uzyskamy taki sam wynik jak w przypadku im-
plikacji tych zda. W Javie operator <= nie zosta zdefiniowany dla typu boolean.
Moemy skorzysta z metod klasy opakowujcej i porównania rezultatu z liczb 1:
Boolean.valueOf(p).compareTo(q) < 1. Analiz tego wyraenia pozostawiamy
Czytelnikowi.
Zadanie 6.5.
Napisz program, który przedstawi tabel wartoci logicznych alternatywy wyklucza-
jcej (plik ródowy: Xor.java).
Alternatywa wykluczajca (p albo q) jest prawdziwa, gdy jedno ze zda jest prawdzi-
we, a drugie jest faszywe, czyli ich wartoci logiczne nie s równe.
Zadanie 6.6.
Napisz programy (pliki ródowe: PrawoLogiczneX.java, gdzie X oznacza jedn z li-
ter A, B, C, D lub E, zgodn z podpunktem rozwizywanego zadania) przedstawiajce
w formie tabeli dowody nastpujcych praw logicznych:
a) prawo przechodnioci implikacji > p q q r @ p r ,
b) prawo rozdzielnoci alternatywy wzgldem koniunkcji
> p q r @ > p q p r @ ,
c) prawo rozdzielnoci koniunkcji wzgldem alternatywy
> p q r @ > p q p r @ ,
d) prawo odrywania > p q q @ q ,
e) prawo eliminacji implikacji p q p q .
W prawach zawierajcych implikacj (podpunkty a), d) i e)) skorzystaj z metody

statycznej impl(), zdefiniowanej w rozwizaniu zadania 6.4. Uproci to w istotny
sposób zapis zadania. Mona te wprowadzi dodatkowe zmienne typu boolean,
przechowujce wartoci wyrae stojcych po lewej i prawej stronie badanych rów-
nowanoci.

Zadanie 6.7.
W klasie String (od wersji Javy 1.6) dostpna jest metoda isEmpty(), zwracajca war-
to true, gdy dugo acucha znaków jest równa 0, oraz warto false w pozosta-
ych przypadkach. Napisz prost aplikacj (plik ródowy: StringIsEmpty.java) poka-
zujc dziaanie tej metody.
Ustal warto acucha, a nastpnie wywietl na ekranie ten acuch, jego dugo
i warto zwrócon przez metod isEmpty().
Zadanie 6.8.
Napisz program (plik ródowy: TestChar.java) demonstrujcy dziaanie metod isDi-
git(), isLetter(), isLetterOrDigit(), isLowerCase(), isSpaceChar(), isUpperCase()
i isWhiteSpace(). Wyniki przedstaw w postaci tabeli. Zadanie wykonaj dla zestawu
znaków zapisanego w acuchu:
a) "A\240b3&4\040",
b) "o_0+\t",
c) "#\"\304\\\344\b\n".
7. Liczby cakowite typu int

i klasa Integer
Prosty typ danych int pozwala na przechowywanie czterobajtowych (32-bitowych)
liczb cakowitych ze znakiem.
Klasa Integer opakowuje prosty typ int i oferuje dwa konstruktory budujce obiekt
na podstawie liczby cakowitej lub acucha znaków. Zawiera m.in. szereg metod
przeznaczonych do konwersji obiektów klasy Integer na inne typy liczbowe lub a-
cuchy znaków.
Zadanie 7.1.
Uruchom aplikacj, której kod ródowy przedstawiono na listingu 4. Na podstawie
obserwacji wyników dziaania programu opisz przeznaczenie uytych staych i metod
statycznych klasy Integer. W kodzie ródowym programu, w miejscu trzech kropek,
wpisz odpowiednie teksty objaniajce wywietlane wyniki. W przypadku wtpliwo-
ci zajrzyj do dokumentacji jzyka Java (np. http://download.oracle.com/javase/1.5.0/
docs/api/java/lang/Integer.html).
Listing 4. StaticInteger.java
public class StaticInteger {
System.out.println("Wybrane stae i metody statyczne klasy Integer\n");

System.out.println("...: "+Integer.MIN_VALUE);
System.out.println("...: "+Integer.MAX_VALUE);
System.out.println("...: "+Integer.SIZE);
int a = 179;
System.out.println("a = "+a);
System.out.println("...: "+Integer.toBinaryString(a));
System.out.println("...: "+Integer.toOctalString(a));
System.out.println("...: "+Integer.toHexString(a));
System.out.println("...: "+Integer.toString(a));
System.out.println("...: "+Integer.toString(a, 4));
int b = Integer.parseInt("-177");
System.out.println("b = "+b);
int c = Integer.parseInt("1000", 8);
System.out.println("c = "+c);
System.out.println("...: "+Integer.signum(a));
System.out.println("...: "+Integer.signum(b));
System.out.println("...: "+Integer.signum(0));
}
}
Zadanie 7.2.
Uruchom aplikacj przedstawion na listingu 5. Na podstawie uzyskanych wyników
i dokumentacji objanij (w postaci komentarza) uyte metody klasy Integer.
Listing 5. ObjectInteger.java
public class ObjectInteger {
System.out.println("Wybrane metody obiektów klasy Integer\n");
/* tworzenie obiektów */
Integer a = new Integer(1024);
Integer b = new Integer("02000");
Integer c = Integer.decode("02000");
Integer d = Integer.decode("0x2000");
System.out.println("d = "+d);
/* porównania obiektów */
System.out.println("...? "+a.equals(b));
System.out.println("...? "+a.equals(c));
System.out.println("...? "+a.compareTo(c));
System.out.println("...? "+c.compareTo(d));
System.out.println("...? "+d.compareTo(c));
/* zmiana wartoci obiektu */
a = Integer.valueOf(1000);
b = Integer.valueOf("1000");
c = Integer.valueOf("1000", 2);
d = Integer.valueOf("1000", 16);
}
}

Zmienne i stae (literay) typu int mog by wykorzystane do wykonywania oblicze
w zbiorze liczb cakowitych, w zakresie ograniczonym 32-bitowym rozmiarem typu
(od –231 do 231–1). Do dyspozycji mamy cztery podstawowe operatory: dodawanie +,
odejmowanie –, mnoenie * i dzielenie (cakowite) / oraz operator %, sucy do obli-
czania reszty z dzielenia dwóch liczb cakowitych.
Warto cakowit (potrzebn do oblicze) zawart w obiekcie moemy uzyska przy

uyciu metody intValue().
Zadanie 7.3.
Dla dwóch dowolnie wybranych liczb cakowitych typu int napisz aplikacj pokazujc
dziaanie operatora + (plik ródowy: Dodawanie.java). Wynik wywietlaj w postaci:
a = 3, b = 15
a + b = 18
Zadeklaruj i zainicjuj dwie zmienne typu int, np. int a = 2451, b = 375;. Wyrae-
nia wykonujce obliczenia moesz umieci jako parametry w metodzie println().
Zwró uwag na kolejno wykonywania dziaa, gdy operatora + uywasz do oblicze

i czenia tekstów!
Zadanie 7.4.
Dla dwóch dowolnie wybranych liczb cakowitych typu int napisz aplikacje pokazu-
jce dziaanie pozostaych operatorów arytmetycznych:
a) odejmowanie – (plik ródowy: Odejmowanie.java),
b) mnoenie * (plik ródowy: Mnoenie.java),
c) dzielenie / (plik ródowy: Dzielenie.java),
d) reszta z dzielenia % (plik ródowy: Reszta.java).
Wyniki wywietlaj podobnie jak w zadaniu 7.3.
Zadanie 7.5.
Napisz aplikacj (plik ródowy: Dzielenie2.java) demonstrujc dzielenie z reszt
dla liczb cakowitych o rónych znakach. Wyniki wywietlaj w postaci znanej z lekcji
matematyki, np. 13 : 2 = 6 r. 1.
Zadanie 7.6.
Napisz aplikacj (plik ródowy: Suma.java), która obliczy sum dwóch liczb natural-
nych podanych jako parametry wywoania. Wynik wywietl na ekranie.
Parametry s przekazywane do programu jako acuchy znaków. Potrzebna bdzie

zamiana acucha na liczb cakowit. Mona uy odpowiedniej metody statycz-
nej lub posuy si obiektami klasy Integer.

Zadanie 7.7.
Napisz aplikacj (plik ródowy: Sumuj.java), która obliczy sum serii liczb natural-
nych podanych jako parametry wywoania aplikacji. Wynik wywietl na ekranie.
Wprowad zmienn suma typu int i zainicjuj j wartoci 0. Korzystajc z ptli typu
for each, przegldaj tablic argumentów, zamieniaj argument (acuch znaków) na
liczb cakowit i dodawaj j do sumy. Po przejrzeniu caej tablicy wywietl wynik.
Zadanie 7.8.
Napisz aplikacj (plik ródowy: Zamiana.java), która na podstawie dwóch parame-
trów cakowitych — podstawy systemu liczbowego od 2 do 36 i liczby dziesitnej —
wywietli na ekranie liczb zapisan we wskazanym systemie wedug podanego wzo-
ru: 102[10] = 123[9].
Zadanie 7.9.
Napisz aplikacj (plik ródowy: Zamiana2.java), która na podstawie dwóch para-
metrów — podstawy systemu liczbowego od 2 do 36 i liczby zapisanej w systemie
o podstawie podanej jako pierwszy parametr — wywietli na ekranie t liczb zapisa-
n w systemie dziesitnym wedug podanego wzoru: 123[9] = 102[10].
8. Inne typy liczb cakowitych w Javie

Do zapisywania liczb cakowitych w pamici komputera najczciej uywamy 1, 2, 4
lub 8 bajtów (odpowiednio 8, 16, 32 lub 64 bitów). Odpowiada to nastpujcym typom
liczb cakowitych ze znakiem w jzyku Java: byte, short, int lub long.
Z kadym z wymienionych typów prostych zwizana jest klasa opakowujca — Byte,

Short, Integer lub Long. Klasy te dziedzicz z klasy abstrakcyjnej java.lang.Number.
Zmianie ulegaj jedynie zakresy dostpnych wartoci, natomiast metody maj iden-
tyczne nazwy i analogiczny sposób dziaania.
Kada z wymienionych klas posiada metody zwracajce warto reprezentowan przez

obiekt jako warto jednego z pozostaych typów cakowitych.
Zadanie 8.1.
Przepisz i uruchom kod ródowy przedstawiony na listingu 6. Opisz krótko zastoso-
wane metody. Uzasadnij otrzymane rezultaty. Powtórz wiczenie, zmieniajc warto
liczby n na minimaln dostpn warto typu long.
Listing 6. LongNumber.java
public class LongNumber {
long n = Long.MAX_VALUE;

System.out.println("n = "+n);
System.out.println("BIN: "+Long.toBinaryString(n));
System.out.println("HEX: "+Long.toHexString(n));
long m = n+1;
System.out.println("m = "+m);
System.out.println("BIN: "+Long.toBinaryString(m));
System.out.println("HEX: "+Long.toHexString(m));
Long max = new Long(n);

System.out.println("Zamiana na typ int, m = "+max.intValue());
System.out.println("BIN: "+
Integer.toBinaryString(max.intValue()));
System.out.println("HEX: "+Integer.toHexString(max.intValue()));
System.out.println("Zamiana na typ int, m = "+(int)m);

System.out.println("BIN: "+Integer.toBinaryString((int)m));
System.out.println("HEX: "+Integer.toHexString((int)m));
}
}
Zadanie 8.2.
Napisz program (plik ródowy: MinMax.java) wywietlajcy minimalne i maksymalne
wartoci liczb cakowitych typu byte, short, int i long. Wyniki wywietl w postaci:
nazwa typu <warto minimalna, warto maksymalna>.
Wykorzystaj stae MIN_VALUE i MAX_VALUE z klas opakowujcych typy proste.
Zadanie 8.3.
Napisz program (plik ródowy: MaxPositive.java) wywietlajcy maksymalne warto-
ci liczb cakowitych typu byte, short, int i long. Wyniki wywietl w postaci binar-
nej i szesnastkowej.
Klasy opakowujce Integer i Long zawieraj metody toBinaryString() i toHexString()

— tych metod nie ma w klasach Byte i Short.
Zadanie 8.4.
Napisz program (plik ródowy: Kodowanie.java) zamieniajcy acuch znaków (np.
sowo kodowanie) na cig bajtów odpowiadajcych tym znakom.
Poszukaj odpowiedniej metody w klasie String.
Zadanie 8.5.
Napisz program (plik ródowy: Dekodowanie.java) zamieniajcy cig bajtów (np.
{115, 122, 121, 102, 114}) na acuch znaków odpowiadajcych tym liczbom.

Jeden z konstruktorów klasy String tworzy acuch znaków na podstawie tablicy

bajtów.
Zadanie 8.6.
Napisz program (plik ródowy: DodajCyfry.java) obliczajcy sum cyfr liczby cako-
witej dodatniej podanej:
a) w postaci tekstu — acucha znaków (cyfr) reprezentujcych t liczb,
b) jako warto typu long.
Skorzystaj z rozwizania zadania 8.4 i pamitaj, e kody cyfr s równe: 0 — 48,

1 — 49, 2 — 51 itd. Liczb moesz zamieni na acuch znaków.
Zadanie 8.7.
Napisz program (plik ródowy: Txt2Hex.java) zamieniajcy acuch znaków ASCII
na acuch cyfr szesnastkowych odpowiadajcych tym znakom.
Zamie tekst na cig bajtów, a nastpnie przedstaw bajty w postaci szesnastkowej.

Na jeden bajt (znak ASCII) przypadn dwie cyfry szesnastkowe.
Zadanie 8.8.
Napisz program (plik ródowy: Hex2Txt.java) zamieniajcy acuch cyfr szesnast-
kowych na odpowiadajcy mu acuch znaków ASCII (dwie cyfry przypadaj na je-
den znak).
9. Typy liczb zmiennoprzecinkowych

Typy zmiennoprzecinkowe su do przechowywania liczb z czci uamkow. Java
oferuje dwa typy zmiennoprzecinkowe zgodne ze standardem IEEE 754:
float — dane zmiennoprzecinkowe 32-bitowe pojedynczej precyzji
o dokadnoci 7 – 8 cyfr znaczcych,
double — dane zmiennoprzecinkowe 64-bitowe podwójnej precyzji
o dokadnoci 15 cyfr znaczcych.
Zadanie 9.1.
Przepisz i uruchom kod ródowy przedstawiony na listingu 7. Zobacz efekty dziaa-
nia programu. Czy na podstawie zapisu kodu ródowego (bez czytania dokumentacji)
moesz okreli dziaanie uytych metod? Sporzd krótki opis kodu i efektów jego
dziaania.

Listing 7. DemoDouble.java
public class DemoDouble {
public static void main(String[] args) {
double a = Double.MIN_VALUE;
System.out.println("Minimalna warto dodatnia: "+a);
System.out.println("BIN: "+Long.toBinaryString(Double.
doubleToLongBits(a)));
System.out.println("HEX: "+Double.toHexString(a));
a = -a;
System.out.println("Liczba przeciwna: "+a);
System.out.println("BIN: "+Long.toBinaryString(Double.
doubleToLongBits(a)));
System.out.println("HEX: "+Double.toHexString(a));
}
}
Zadanie 9.2.
Przedstaw w postaci sowa 64-bitowego reprezentacj binarn kilku wybranych liczb
typu double (plik ródowy: DoubleBin.java). Z cigu 64 bitów wyodrbnij bit znaku,
cech i mantys.
a) 0,25; 0,5; 1,0; 2,0; 512,0;
b) 0,01; 0,1; 1,0; 10,0; 100,0;
c) 1,367; 1367; 13,67; –13,67; 1,367e–12; 1,367e12;
d) symbole specjalne: Double.NaN (ang. Not-a-Number), np. wynik
pierwiastkowania liczby ujemnej, Double.NEGATIVE_INFINITY ( f — ujemna
nieskoczono, np. wynik dzielenia –1/0,0), Double.POSITIVE_INFINITY ( f
— dodatnia nieskoczono, np. wynik dzielenia 1/0,0).
e) dwie reprezentacje zmiennoprzecinkowe zera 0.0 i –0.0 oraz wartoci
ekstremalne Double.MIN_VALUE, Double.MAX_VALUE i 2.2250738585072014e-308.
Moemy zastosowa metod statyczn doubleToLongBits() z klasy Double i zamie-

ni liczb zmiennoprzecinkow typu double na liczb cakowit typu long o iden-
tycznej reprezentacji binarnej. W dalszej kolejnoci zamienimy liczb typu long na
odpowiadajcy jej cig cyfr binarnych. Niestety, metoda statyczna toBinaryString()
z klasy Long, tworzc cig cyfr binarnych odpowiadajcych liczbie typu long, pomija
zera nieznaczce. Uzupenimy te zera do 64 znaków w acuchu, wycinajc je jako
podcig o odpowiedniej dugoci z cigu (acucha) zoonego z 64 cyfr 0 i dodajc
do cigu zer uzyskan posta binarn liczby.
Musimy pamita , e indeksy znaków w acuchu s liczone od strony lewej do pra-
wej, natomiast bity w liczbie binarnej s numerowane od strony prawej (najmodszy
bit to 0) do lewej (najstarszy bit to 63).
Znaczenie poszczególnych bitów w reprezentacji binarnej liczby typu double jest
nastpujce: bit nr 63 — bit znaku, bity o numerach od 52 do 62 — cecha liczby
(11 bitów), bity o numerach od 0 do 51 (52 bity) — cz uamkowa mantysy.

Zadanie 9.3.
Cig bitów 111110000011110000111000110010 reprezentuje pewn liczb zmienno-
przecinkow pojedynczej precyzji (zera nieznaczce pominito). Jak warto dzie-
sitn ma ta liczba? Napisz program (plik ródowy: Bin2Float.java) wyznaczajcy t
warto.
Liczby typu int i float zajmuj w pamici 32 bity. Znajd liczb cakowit posia-
dajc podan reprezentacj binarn i skorzystaj z metody intBitsToFloat() z kla-
sy Float.
Zadanie 9.4.
Cig bitów 111110000011110000111000110010 reprezentuje pewn liczb zmienno-
przecinkow podwójnej precyzji (zera nieznaczce pominito). Jak warto dziesit-
n ma ta liczba? Napisz program (plik ródowy: Bin2Double.java) wyznaczajcy t
warto.
Liczby typu long i double zajmuj w pamici 64 bity.
Zadanie 9.5.
Napisz binarne reprezentacje symboli specjalnych ( rf , NaN) dla liczb zmiennoprze-
cinkowych pojedynczej precyzji. Utwórz aplikacj (plik ródowy: TestBinFloat.java),
która odkoduje liczb binarn podan jako parametr wywoania i wywietli odpowia-
dajc jej warto typu float. Wykorzystaj t aplikacj do sprawdzenia poprawnoci
swoich odpowiedzi.
Reprezentacja binarna liczby zmiennoprzecinkowej pojedynczej precyzji skada si

z bitu znaku, 8 bitów cechy i 23 bitów mantysy (razem 32 bity). Cecha symbolu
specjalnego ma wszystkie bity równe 1.


Rozdzia 2.
Drugi krok — operacje
wejcia-wyjcia
i instrukcje sterujce
w Javie
10. Wywietlanie sformatowanych
wyników w konsoli.
Stae i metody z klasy Math
Do formatowania wywietlanych wyników w konsoli moemy uy metody printf()
na obiekcie out klasy System:
System.out.printf(acuch_formatujcy, lista_argumentów);
Pierwszy parametr (acuch_formatujcy) jest acuchem znaków (obiektem klasy

String) zawierajcym znaczniki formatujce w postaci:
%[indeks_argumentu$][flaga][szeroko][.precyzja]znak_konwersji
Drugi parametr (lista_argumentów) jest list zmiennych lub staych oddzielonych prze-
cinkami — wartoci tych argumentów bd podstawiane w miejsce znaczników for-
matujcych w acuchu formatujcym zgodnie z kolejnoci wystpowania lub w miej-
scu okrelonym przez opcjonalny indeks_argumentu$. Pozostae opcjonalne parametry
okrelaj:
flaga — znak okrelajcy dodatkowe cechy sformatowanego wyniku,
np. + oznacza, e przed liczb zawsze wywietlany jest znak + lub –.

szeroko — okrela szeroko pola, czyli liczb znaków przeznaczonych

do wywietlenia wartoci argumentu (jeli warto nie mieci si w tym polu,
to jego rozmiar zostanie automatycznie poszerzony).
precyzja — okrela liczb miejsc po przecinku (domylnie 6) dla wywietlanych
liczb zmiennoprzecinkowych.
Znacznik formatujcy rozpoczyna si znakiem % i koczy (obowizkowym) znakiem

(znak_konwersji) okrelajcym typ formatowanych danych, np.: c — znak, d — licz-
ba cakowita dziesitna, f — liczba zmiennoprzecinkowa, s — acuch znaków. Wi-
cej szczegóów znajdziemy w dokumentacji klasy Formater: http://docs.oracle.com/
javase/1.5.0/docs/api/java/util/Formatter.html.
Klasa Math zawiera zestaw funkcji matematycznych i dwie stae (pola klasy) — przy-
blienie liczby S i podstawy logarytmu naturalnego e. Wszystkie funkcje zostay zde-
finiowane jako metody statyczne, wic nie tworzymy obiektów klasy Math, a jedynie
wywoujemy zdefiniowane metody, np. Math.sqrt(2) zwróci warto (przyblion)
pierwiastka kwadratowego z liczby 2. Wykaz funkcji znajdziemy w dokumentacji:
http://docs.oracle.com/javase/6/docs/api/java/lang/Math.html.
Zadanie 10.1.
4
Przedstaw uamek 7
z dokadnoci do 5 miejsc po przecinku.
Dzielc 4 przez 7, otrzymasz uamek dziesitny, o ile co najmniej jedn z tych liczb
zamienisz na liczb zmiennoprzecinkow, np. stosujc tzw. rzutowanie double x =
(double) 4. Do sformatowania wyniku moesz uy metody System.out.printf().
Zadanie 10.2.
Wywietl w konsoli z dokadnoci do 10 miejsc po przecinku nastpujce liczby nie-
wymierne: e, S i M (liczba Fibonacciego). Liczby poprzed komentarzem sownym
i ustaw w kolumnie wyrównanej do prawej strony.
1 5
Liczby e i S s zdefiniowane w klasie Math jako stae, natomiast M .
2
Zadanie 10.3.
Napisz aplikacj, która wywietli w konsoli w trzech kolumnach liczby naturalne 2, 3,
5, 7, 11, 13 i 17, pierwiastki kwadratowe i pierwiastki szecienne z tych liczb. Warto-
ci pierwiastków wywietlaj z dokadnoci do 8 miejsc po przecinku, w kolumnach
o szerokoci 15 znaków.
Liczby 2, 3, 5, 7, 11, 13 i 17 umie w tablicy. Zastosuj ptl typu for each do

przegldania tablicy, oblicze i wywietlania pierwiastków.

Rozdzia 2. i Drugi krok — operacje wejcia-wyjcia i instrukcje sterujce w Javie 33
Zadanie 10.4.
Napisz aplikacj, która wywietli w konsoli pierwiastki arytmetyczne od stopnia 2. do
10. z liczby 5 z dokadnoci do 6 miejsc po przecinku.
Zgodnie z definicj n x x n , wic do obliczania pierwiastków mona wykorzysta

metod Math.pow(podstawa, wykadnik).
Zadanie 10.5.
Wywietl w konsoli kody ósemkowe, dziesitkowe i szesnastkowe wielkich liter alfa-
betu aciskiego. W pierwszym wierszu umie opisy poszczególnych kolumn: Znak,
OCT, DEC i HEX.
Wykorzystaj specyfikatory %o, %d i %x w acuchu formatujcym.
Zadanie 10.6.
Wywietl w konsoli miar kta o rozwartoci 1 radiana w stopniach (z maksymaln
moliw precyzj), w stopniach i minutach ktowych oraz w stopniach, minutach i se-
kundach ktowych.
W klasie Math znajdziesz metody zamieniajce radiany na stopnie i stopnie na ra-

diany. Pozostaje opracowa samodzielnie zamian czci dziesitnych stopnia na
minuty (1° = 60') i sekundy ktowe (1' = 60").
Zadanie 10.7.
Wywietl w konsoli miary któw 1°, 1' i 1" w radianach z dokadnoci do 15 miejsc
po przecinku.
Zadanie 10.8.
Oblicz kty ostre w trójkcie egipskim (trójkcie prostoktnym o proporcji boków
3:4:5). Wyniki podaj:
a) w radianach, z dokadnoci do 4 miejsc po przecinku,
b) w stopniach, z dokadnoci do 1 miejsca po przecinku,
c) w stopniach i minutach ktowych, z dokadnoci do 1',
d) w stopniach, minutach i sekundach ktowych z dokadnoci do 1".
W klasie Math znajdziesz funkcje trygonometryczne (argumenty w radianach) oraz

funkcje do nich odwrotne (wartoci w radianach).

11. Wczytywanie danych

— klasa Scanner
Pobieranie danych ze standardowego strumienia wejciowego System.in moemy zre-
alizowa za pomoc obiektu klasy Scanner:
Scanner input = new Scanner(System.in);
Klasa Scanner oferuje m.in. metody testujce, czy w strumieniu znajduje si kolejny
token okrelonego typu, oraz metody odczytujce jego warto ze strumienia:
hasNextLine() — zwraca warto true, gdy w strumieniu znajduje si wiersz
danych, w przeciwnym wypadku zwraca warto false;
nextLine() — odczytuje jeden wiersz danych;
hasNext() — zwraca warto true, gdy w strumieniu znajduje si nastpny
token (np. sowo ograniczone spacjami);
next() — odczytuje ze strumienia jeden token (jedno sowo);
hasNextInt() — zwraca warto true, gdy kolejny token w strumieniu
reprezentuje liczb cakowit;
nextInt() — odczytuje ze strumienia kolejny token, interpretujc go jako
liczb cakowit.
Podobne metody zdefiniowano dla pozostaych prostych typów danych. Szczegóowe

informacje znajdziemy w dokumentacji pod adresem http://docs.oracle.com/javase/
1.5.0/docs/api/java/util/Scanner.html.
Zadanie 11.1.
Napisz program zamieniajcy temperatur podan w stopniach Celsjusza na tempe-
ratur wyraon w stopniach Fahrenheita. Dane wejciowe wprowadzamy z klawiatu-
ry w postaci liczby dziesitnej; wynik naley obliczy i wywietli z dokadnoci do
0,1 stopnia.
Wzór do zamiany temperatury ze skali Celsjusza na skal Fahrenheita: °F = °C·1,8+32.
Zadanie 11.2.
Napisz program zamieniajcy temperatur podan w stopniach Fahrenheita na tempe-
ratur wyraon w stopniach Celsjusza. Dane wejciowe wprowadzamy z klawiatury
w postaci liczby cakowitej, wynik naley obliczy i wywietli z dokadnoci do 0,1
stopnia.
Przekszta wzór podany w zadaniu 11.1.

Zadanie 11.3.
Napisz program obliczajcy dugo przeciwprostoktnej w trójkcie prostoktnym,
majc dane:
a) dugoci przyprostoktnych,
b) dugo przyprostoktnej i miar kta ostrego (podan w stopniach) lecego
naprzeciw tej przyprostoktnej.
Dane uytkownik wprowadza z klawiatury. Wyniki naley wywietli z dokadnoci

do 0,001.
Zadanie 11.4.
Napisz program, który odczyta z konsoli dwie liczby zapisane w naturalnym kodzie bi-
narnym, obliczy ich sum i wywietli wynik w postaci binarnej. Zaproponuj ogranicze-
nie liczby cyfr binarnych stosownie do przyjtej metody oblicze i uytych zmiennych.
Odczytaj cigi cyfr binarnych i zamie je na liczby cakowite, dodaj uzyskane rezul-
taty i przedstaw wynik w postaci binarnej. Póniej wykonamy te obliczenia na ci-
gach cyfr, bez konwersji na liczby.
Zadanie 11.5.
Napisz program, który zamieni uamek zwyky na procent. Uamek zwyky wprowa-
dzamy z klawiatury w postaci acucha znaków zoonego z dwóch liczb cakowitych
(licznika i mianownika) oddzielonych znakiem / (bez odstpów). Wynik naley wy-
wietli z dokadnoci do 0,1%.
Zadanie 11.6.

acuch znaków zawiera oddzielone odstpami imi i nazwisko pracownika, liczb
przepracowanych godzin i stawk godzinow. Napisz program obliczajcy na tej pod-
stawie wynagrodzenie nalene pracownikowi.
Wykorzystaj metody klasy Scanner do przeczytania danych z acucha znaków.
Zadanie 11.7.
Plik tekstowy dane.txt zawiera wiersz tekstu, a w nim oddzielone odstpami imi i na-
zwisko pracownika, liczb przepracowanych godzin i stawk godzinow. Napisz pro-
gram obliczajcy na tej podstawie wynagrodzenie nalene pracownikowi.
Wykorzystaj metody klasy Scanner do przeczytania danych z pliku tekstowego.

12. Operacje na tekstach

— klasy StringBuffer
i StringBuilder
Skadanie acucha znaków z krótszych acuchów moemy zrealizowa przy uyciu
obiektu klasy StringBuffer lub StringBuilder (od wersji JDK 5.0).
Obie klasy maj ten sam interfejs. Podstawowe metody to: append() (dodawanie zna-
ków na kocu acucha — dane rónych typów s konwertowane na typ String i do-
czane do budowanego obiektu), delete() (usuwanie znaków z acucha), insert()
(wstawianie znaków do acucha), replace() (zastpowanie znaków w acuchu).
W budowanym obiekcie mamy dostp do odczytu pojedynczych znaków (metoda
charAt()) i podacuchów (metoda substring()) oraz moliwo zmiany pojedynczego
znaku (setCharAt()).
Wicej informacji mona znale w dokumentacji: http://docs.oracle.com/javase/1.5.0/

docs/api/java/lang/StringBuffer.html.
Zadanie 12.1.
Wykresem funkcji kwadratowej f ( x) ax 2 bx c, a z 0 jest parabola o wierzchoku
§ b ' · . Napisz program, który obliczy i wywietli w konsoli wspórzdne wierz-
¨ , ¸
© 2 a 4a ¹
choka paraboli. Zakadamy, e uytkownik bdzie podawa poprawne wspóczynniki
trójmianu.
Wykorzystaj obiekt klasy StringBuffer lub StringBuilder i metod append() do

zbudowania acucha znaków przedstawiajcego wspórzdne wierzchoka. Meto-
da append() dodaje na kocu acucha znaki, acuchy znaków, wartoci wbudo-
wanych typów danych zamienione na acuch znaków lub obiekty zamienione na
acuch znaków.
Zadanie 12.2.
Rozwi zadanie 12.1, stosujc obiekt i metod insert() klasy StringBuffer lub
StringBuilder.
Zacznij od zbudowania acucha znaków "(, )", do którego nastpnie wstawisz

obliczone wartoci wspórzdnych wierzchoka paraboli. Zwró uwag na kolejno
wstawiania tych wartoci do pocztkowego acucha.

Zadanie 12.3.
Rozwi zadanie 12.1, stosujc obiekt i metod replace() klasy StringBuffer lub
StringBuilder.
Zacznij od zbudowania acucha znaków "(#1, #2)". Podacuchy "#1" i "#2"

(o dugoci 2 znaków) wskazuj miejsca, w których zastpisz te podacuchy obli-
czonymi wartociami wspórzdnych wierzchoka paraboli. Aby znale miejsca
wstawiania obliczonych wartoci, zastosuj metod indexOf().
Zadanie 12.4.
Napisz program, który obliczy rónic liczby cakowitej dodatniej wprowadzonej
z konsoli i liczby zapisanej tymi samymi cyframi w odwrotnej kolejnoci. Wynik wy-
wietl w postaci caego wyraenia, np.: 452-254 = 198.
W klasie StringBuffer lub StringBuilder znajdziesz metod reverse() odwraca-

jc kolejno znaków w acuchu oraz metod toString() konwertujc budo-
wany acuch na obiekt klasy String.
Zadanie 12.5.
Symbol [a, b] w geometrii analitycznej oznacza wektor o wspórzdnych a i b (w prze-
strzeni dwuwymiarowej, czyli na paszczy nie). Napisz program obliczajcy dugo
wektora [a, b] wprowadzonego przez uytkownika z klawiatury w postaci acucha
znaków, np. [2.5, -4]. Zakadamy, e uytkownik bdzie podawa poprawn posta
danych (nawiasy prostoktne, przecinek i liczby dziesitne w notacji z kropk).
Z acucha znaków naley wydoby podacuchy reprezentujce liczby a i b

(wspórzdne wektora), zamieni je na liczby i obliczy dugo wektora ze wzoru
u a2 b2 .
Zadanie 12.6.
Napisz program obliczajcy dugo wektora [a, b, c] (w przestrzeni trójwymiarowej)
wprowadzonego przez uytkownika z klawiatury w postaci acucha znaków. Zaka-
damy, e uytkownik bdzie podawa poprawn posta danych (nawiasy prostoktne,
dwa przecinki oddzielajce wspórzdne i trzy liczby dziesitne w notacji z kropk).
Dugo wektora obliczymy ze wzoru u a 2 b2 c2 .

13. Instrukcje warunkowe

i instrukcja selekcji
Instrukcje warunkowe stosujemy w sytuacji, gdy dalszy przebieg programu zaley od
spenienia pewnego warunku (wyraenia logicznego o wyniku typu boolean).
Instrukcja warunkowa ma posta

if (wyraenie) instrukcja;
lub
if (wyraenie) instrukcja1; else instrukcja2;
Najpierw obliczana jest warto wyraenia logicznego. Jeeli wyraenie ma warto

true, to wykonywana jest instrukcja (lub instrukcja1 w drugiej postaci instrukcji
warunkowej). Jeeli wyraenie ma warto false, to wykonanie instrukcji w pierw-
szym przypadku jest pomijane, a w drugim przypadku wykonywana jest instrukcja2.
Instrukcje mog by instrukcjami prostymi, zoonymi (cig instrukcji ujtych w na-
wiasy klamrowe {}, tzw. blok) lub instrukcjami warunkowymi (tzw. zagniedanie
instrukcji warunkowych).
Instrukcja selekcji pozwala na wybór jednego z kilku wariantów. Skadnia instrukcji

jest nastpujca:
switch (wyraenie) {
case warto1: instrukcja1;
break;
break;
break;
// itd.
....default: instrukcja;
break;
}
Wyraenie przyjmuje wartoci cakowite. Instrukcja (switch) porównuje warto wy-

raenia z wartociami warto1, warto2 itd. Jeli jedna z nich jest równa wartoci
obliczonego wyraenia, to wykonywana jest odpowiednia instrukcja z ciaa instrukcji
switch. Instrukcja break powoduje natychmiastowe zakoczenie instrukcji switch.
Pominicie instrukcji break jest dopuszczalne, ale spowoduje wykonywanie kolejnych
instrukcji wystpujcych po wybranej instrukcji (do koca instrukcji selekcji lub wy-
stpienia break). Jeli wyraenie nie przyjmuje adnej z podanych wartoci, to wyko-
nywana jest instrukcja domylna (default). Instrukcja domylna jest opcjonalna i mo-
emy j pomin.
Instrukcje selekcji mona zagnieda.

Zadanie 13.1.
Napisz program, który zapyta uytkownika o imi, a nastpnie wykorzystujc podane
imi, wywietli w konsoli napis w postaci: "Jan jest mczyzn." lub "Anna jest
kobiet.".
Wykorzystaj fakt, e typowe polskie imiona eskie s zakoczone na liter a.
Zadanie 13.2.
Napisz program obliczajcy pole powierzchni i obwód kwadratu. Dugo boku kwa-
dratu uytkownik wprowadzi z klawiatury. Program powinien sprawdzi, czy wpro-
wadzona dugo boku jest poprawna (dodatnia).
Zadanie 13.3.
Uytkownik wprowadza z klawiatury dwie liczby rzeczywiste a i b. Napisz program,
który wywietli (zapisany w sposób symboliczny) zbiór zoony z tych liczb oraz
wszystkich liczb zawartych midzy nimi.
Jeli liczby s równe, to otrzymamy zbiór jednoelementowy {a}, w przeciwnym razie

szukanym zbiorem bdzie przedzia domknity.
Zadanie 13.4.
Uytkownik wprowadza z klawiatury wspóczynniki funkcji kwadratowej
f ( x) ax 2 bx c
Napisz program, który wyznaczy zbiór wartoci tej funkcji lub wywietli komunikat,
e podane wspóczynniki nie s poprawne (przypadek a 0 ).
Do zapisania zbioru wartoci funkcji, który jest przedziaem nieograniczonym, b-

dzie potrzebny symbol f . W konsoli moemy ten symbol „zoy ” z dwóch znaków
oo, co w poczeniu ze znakiem + lub — bdzie wystarczajco czytelne (–oo lub +oo).
Zadanie 13.5.
Uytkownik wprowadza z klawiatury wspóczynniki funkcji kwadratowej
f ( x) ax 2 bx c
Napisz program, który wyznaczy przedziay monotonicznoci i ekstremum tej funkcji.

Zadanie 13.6.
Napisz program rozwizujcy równanie liniowe ax b 0 . Wspóczynniki równania
uytkownik wprowadzi z klawiatury. Rozwa wszystkie moliwe przypadki dla wspó-
czynników równania.
Zadanie 13.7.
Uytkownik wprowadza z klawiatury trzy liczby a, b i c. Napisz program, który wywie-
tli najmniejsz (lub najwiksz) z tych liczb. Nie wprowadzaj dodatkowych zmiennych.
Zadanie 13.8.
Uytkownik wprowadza z klawiatury trzy liczby a, b i c. Napisz program, który wy-
wietli te liczby w sposób uporzdkowany, w kolejnoci od najmniejszej do najwik-
szej (lub od najwikszej do najmniejszej). Nie wprowadzaj dodatkowych zmiennych.
Zadanie 13.9.
Stosujc instrukcj selekcji, napisz program, który liczb naturaln jednocyfrow za-
pisze sownie.
Zadanie 13.10.
Napisz program, który podan liczb naturaln mniejsz od 100 zapisze sowami.
Zadanie 13.11.
Napisz program, który podan liczb naturaln mniejsz od 1000 zapisze sowami.
Zadanie 13.12.
Napisz program, który sprawdzi poprawno daty z obecnego wieku, zapisanej w po-
staci dd.mm.rrrr, i wywietli odpowiedni komunikat.
Zadanie 13.13.
Napisz program, który dat podan w postaci dd.mm.rrrr zapisze w formacie rrrr-mm-
-dd. Przyjmij, e wprowadzana data jest poprawna (np. sprawdzona programem z za-
dania 13.12).
Zadanie 13.14.
Napisz program, który dat podan w formacie dd.mm.rrrr zapisze w postaci tradycyjnej:
a) z miesicem zapisanym sownie, np. 15 marca 2012;
b) z miesicem zapisanym w systemie rzymskim, np. 15 III 2012.
Przyjmij, e wprowadzona przez uytkownika data jest poprawna.

Zadanie 13.15.
Napisz program, który na podstawie daty podanej w formacie dd.mm.rrrr okreli, jaki
to dzie tygodnia. Przyjmij, e wprowadzona przez uytkownika data jest poprawna.
Poszukaj informacji na temat wzoru Zellera.
14. Instrukcja ptli typu do-while

Ptla ze sprawdzaniem warunku na kocu ma posta:
do
instrukcja;
while(warunek);
Najpierw jest wykonywana instrukcja, potem obliczana jest warto wyraenia lo-
gicznego (warunek). Jeli warunek ma warto true, to powracamy do wykonywania
instrukcji, i cykl si powtarza.
Cech charakterystyczn tej ptli jest to, e instrukcja wykona si co najmniej raz (do
instrukcja; while(false);). Naley zwróci uwag, aby instrukcja miaa wpyw
na badany warunek, poniewa moemy uzyska ptl nieskoczon (do instrukcja;
while(true);).
Ptl nieskoczon, utworzon wiadomie, moemy przerwa, uywajc w ciele ptli

instrukcji warunkowej i instrukcji break.
Zadanie 14.1.
Uytkownik wprowadza z klawiatury seri liczb rónych od zera, zero natomiast jest
sygnaem zakoczenia wprowadzania danych. Napisz program, który obliczy sum
tych liczb.
Zadanie 14.2.
Podczas wprowadzania danych niejednokrotnie potrzebujemy liczb speniajcych okre-
lone warunki, np. dodatnich. Napisz program, który przyjmie z konsoli wycznie
warto dodatni zmiennej. Jeli uytkownik poda liczb ujemn lub zero, to program
powinien ponowi danie podania waciwej wartoci.
Wczytywanie wartoci zmiennej umie w ptli ze sprawdzaniem warunku na kocu.
Zadanie 14.3.
Napisz program, który wywietli w konsoli wielokrotnoci liczby 7 mniejsze od 100.

Zadanie 14.4.
Napisz program obliczajcy pole powierzchni koa. Promie koa uytkownik wpro-
wadza z klawiatury. Program powinien zasygnalizowa bdne dane (liczb ujemn
lub zero) i ponownie zapyta o dugo promienia.
Zadanie 14.5.
Napisz program obliczajcy pole powierzchni piercienia koowego o promieniu ze-
wntrznym R i wewntrznym r. Dugoci promieni uytkownik wprowadza z klawia-
tury. Program powinien zasygnalizowa bdne dane i ponownie zapyta o potrzebn
warto.
Zadanie 14.6.
Napisz program wywietlajcy w konsoli cig liczb Fibonacciego mniejszych od 1000.
Cig liczb Fibonacciego okrelamy w nastpujcy sposób: F(1) = 1, F(2) = 1, F(n)

= F(n–1)+F(n–2) dla n =3, 4, 5…. Pomimo rekurencyjnego charakteru wzoru mo-
emy zrealizowa obliczenia w sposób iteracyjny, uywajc trzech zmiennych i od-
powiednio przestawiajc w nich wartoci trzech kolejnych liczb cigu Fibonacciego.
Zadanie 14.7.
Napisz program obliczajcy, ile jest liczb w cigu Fibonacciego mniejszych od poda-
nej przez uytkownika liczby cakowitej n.
Zadanie 14.8.
Napisz program obliczajcy pole powierzchni trójkta równobocznego i umoliwiaj-
cy wielokrotne powtarzanie oblicze. Jako znak zakoczenia oblicze przyjmij poda-
nie dugoci boku równej 0. Dla wartoci ujemnych wywietl stosowny komunikat
i ponów pytanie o dugo boku.
Zadanie 14.9.
Napisz program umoliwiajcy wielokrotne wykonywanie oblicze (np. dugoci okr-
gu). Po wykonaniu oblicze program powinien wywietli pytanie Czy obliczamy da-
lej (t/n)?. W pytaniu zawarta jest sugestia sposobu udzielenia odpowiedzi: t — tak,
n — nie (inne odpowiedzi powinny by ignorowane).
15. Instrukcja ptli typu while

Ptla ze sprawdzaniem warunku na pocztku ma posta:
while(warunek) instrukcja;

Najpierw obliczana jest warto wyraenia logicznego warunek. Jeeli warunek ma

warto true, to wykonywana jest instrukcja i nastpuje powrót do badania warunku
(cykl si powtarza). Jeeli warunek przyjmie warto false, to dziaanie ptli zostanie
zakoczone.
Cech charakterystyczn tej ptli jest to, e instrukcja moe nie wykona si ani razu
(while(false) instrukcja;). Naley zwróci uwag, aby instrukcja miaa wpyw na
badany warunek, gdy moemy uzyska ptl nieskoczon (while(true) instrukcja;).
Poniewa skadnia ptli dopuszcza uycie instrukcji pustej, powstaje moliwo przy-
padkowego utworzenia ptli nieskoczonej w postaci while(true); instrukcja; (wsta-
wienie znaku rednika pomidzy warunek i instrukcj).
Zadanie 15.1.
Uytkownik wprowadza z klawiatury dwie liczby naturalne. Nie korzystajc z opera-
tora dodawania (+), oblicz sum tych liczb. Napisz program obliczajcy sum tych
liczb, majc do dyspozycji operatory inkrementacji (++) i dekrementacji (––).
Wyobra sobie dwa stosy patyczków. Dodawanie realizujesz, przekadajc po jednym

patyczku z jednego stosu na drugi. Wykorzystaj ten pomys do rozwizania zadania.
Zadanie 15.2.
Uytkownik wprowadza z klawiatury dwie liczby cakowite. Napisz program oblicza-
jcy sum tych liczb, korzystajc z operatorów inkrementacji (++) i dekrementacji (––).
Zadanie 15.3.
Napisz program obliczajcy iloczyn liczb cakowitych, nie korzystajc z operatora *.
Do dyspozycji masz operatory + i ––. Zadanie rozwi:
a) dla pary liczb cakowitych dodatnich,
b) dla pary dowolnych liczb cakowitych.
W zadaniu b rozwa wszystkie moliwe przypadki i sprowad je ewentualnie do przy-

padku z zadania a.
Zadanie 15.4.
Korzystajc z operatora odejmowania (–), napisz program obliczajcy iloraz cakowity
pary liczb cakowitych.
Zadanie 15.5.
Korzystajc z operatora odejmowania (–), napisz program obliczajcy reszt z dziele-
nia pary liczb cakowitych.

Zadanie 15.6.
Napisz program obliczajcy cakowity pierwiastek kwadratowy z podanej liczby natu-
ralnej. Nie korzystaj przy tym z funkcji bibliotecznych oraz innych metod przyblio-
nego obliczania pierwiastka kwadratowego i zaokrglenia otrzymanego wyniku zmien-
noprzecinkowego do liczby cakowitej.
Cakowity pierwiastek kwadratowy z liczby n jest najwiksz liczb naturaln p spe-

niajc nierówno p d n .
2
Zadanie 15.7.
Napisz program wyznaczajcy najmniejsz wspóln wielokrotno (NWW) dla pary
liczb cakowitych dodatnich.
Obliczaj wielokrotnoci jednej liczby i sprawdzaj, czy obliczona wielokrotno jest

wielokrotnoci drugiej liczby (czy dzieli si bez reszty przez drug liczb).
Zadanie 15.8.
Korzystajc z algorytmu Euklidesa, napisz program wyznaczajcy najwikszy wspól-
ny dzielnik (NWD) pary liczb cakowitych dodatnich.
Zadanie 15.9.
Mamy dwie róne liczby cakowite dodatnie. Bierzemy mniejsz z nich i obliczamy
jej wielokrotno do chwili, gdy wielokrotno osignie lub przekroczy warto dru-
giej liczby. W przypadku równoci mamy ju gotowy wynik. Jeli jednak wielokrot-
no pierwszej liczby przekroczya warto drugiej liczby, to zaczynamy liczy wie-
lokrotnoci drugiej liczby i porównywa wyniki z obliczon wielokrotnoci pierwszej
liczby. Naprzemienne liczenie kolejnych wielokrotnoci zakoczymy w chwili, gdy
obie wielokrotnoci bd równe. Uzasadnij, e to postpowanie si zakoczy. Napisz
na tej podstawie program wyznaczajcy najmniejsz wspóln wielokrotno (NWW)
pary liczb cakowitych dodatnich.
16. Instrukcja ptli typu for

Instrukcja ptli typu for ma skadni:
for(instrukcja_inicjujca; wyraenie_logiczne; instrukcja_modyfikujca) instrukcja;
Na pocztku wykonywana jest (tylko raz) instrukcja_inicjujca. Nastpnie oblicza-

na jest warto wyraenia logicznego (wyraenie_logiczne). Jeeli wyraenie logicz-
ne ma warto true, to wykonywana jest instrukcja, w przeciwnym razie (gdy wyra-
enie logiczne ma warto false) ptla zostaje zakoczona. Po wykonaniu instrukcji

(instrukcja) wykonywana jest instrukcja_modyfikujca i nastpuje powrót do obli-

czania wartoci wyraenia logicznego (cykl jest kontynuowany).
Instrukcja for czsto przyjmuje posta (n jest ustalon liczb naturaln):

for(int i = 0; i < n; ++i) instrukcja; // odliczanie w gór
lub:
for(int i = n; i > 0; --i) instrukcja; // odliczanie w dó
W obu przypadkach instrukcja zostanie wykonana n razy, przy czym w pierwszym

przypadku zmienna i (zwana czsto zmienn sterujc lub licznikiem) przyjmie ko-
lejno wartoci 0, 1, 2 … n-1, a w drugim przypadku n, n–1, … 1. W kadym cyklu
instrukcja_modyfikujca zmienia warto zmiennej i (++i — inkrementacja, czyli
zwikszenie wartoci zmiennej i o 1, lub ––i — dekrementacja, czyli zmniejszenie
zmiennej i o 1).
Ptla for nie ogranicza si do przedstawionych wyej zastosowa. W uzasadnionych

sytuacjach mona poszczególne instrukcje pomija. W skrajnym przypadku uzyskamy
nieskoczon ptl w postaci for(;;);, wykonujc instrukcj pust.
Zadanie 16.1.
Napisz program, który nie wykonujc mnoenia, obliczy kwadrat liczby naturalnej.
Wykorzystaj fakt, e suma kolejnych liczb nieparzystych jest kwadratem liczby na-
turalnej: 1 12 , 1 3 4 22 , 1 3 5 9 32 itd.
Zadanie 16.2.
Napisz program, który sprawdzi, czy wprowadzone z klawiatury sowo jest palindro-
mem, czyli brzmi tak samo czytane od strony lewej do prawej i od prawej do lewej.
Przykadem palindromu jest sowo kajak lub imi Anna (bez rozróniania wielkoci liter).
Moesz porównywa podany tekst z tekstem zapisanym tymi samymi znakami

w odwrotnej kolejnoci lub porównywa pierwszy znak z ostatnim, drugi z przed-
ostatnim itd.
Zadanie 16.3.
Napisz program, który sprawdzi, czy wprowadzone z klawiatury zdanie jest palindro-
mem, czyli brzmi tak samo czytane od strony lewej do prawej i od prawej do lewej.
Przykadem zdania-palindromu jest Kobya ma may bok (bez rozróniania wielkoci
liter i uwzgldniania odstpów midzy sowami).
Zadanie 16.4.
Napisz program wywietlajcy na ekranie tabliczk mnoenia.

Zadanie 16.5.
Napisz program wywietlajcy na ekranie tabliczk dodawania i tabliczk mnoenia
w pitkowym ukadzie pozycyjnym.
Zadanie 16.6.
Napisz program obliczajcy sum n pocztkowych wyrazów cigu harmonicznego.
Liczb n uytkownik wprowadza z klawiatury.
Zadanie 16.7.
Napisz program obliczajcy silni liczby naturalnej n. Liczb n uytkownik wprowa-
dza z klawiatury.
Zadanie 16.8.
Napisz program umoliwiajcy wielokrotne obliczanie potg o wykadniku naturalnym
n i podstawie rzeczywistej a. Nie korzystaj z funkcji klasy Math. Podanie wykadnika
–1 powinno przerwa dziaanie programu.

Rozdzia 3.
Trzeci krok — budujemy
wasne metody i klasy
17. Obsuga wyjtków
Wyjtek (ang. exception) — nietypowa sytuacja pojawiajca si podczas dziaania pro-
gramu. Kady wyjtek w Javie jest obiektem okrelonego typu, przekazywanym do
metody, której dziaanie doprowadzio do pojawienia si bdu. Metoda moe prze-
chwyci wyjtek i wykona instrukcje zapobiegajce przerwaniu dziaania programu.
Konstrukcja obsugi wyjtków przedstawia si nastpujco:

try { instrukcja }
catch (typ_wyjtku_1 e) { instrukcja_obsugi_wyjtku_1 }
catch (typ_wyjtku_2 e) { instrukcja_obsugi_wyjtku_2 }
...
catch (typ_wyjtku_n e) { instrukcja_obsugi_wyjtku_n }
[finally { instrukcja }]
Opcjonalny blok finally jest zawsze wykonywany przed powrotem do instrukcji wy-
stpujcej za konstrukcj try-catch.
W kodzie programu moemy generowa wyjtki, stosujc instrukcj throw.
Zadanie 17.1.
Podczas wprowadzania danych liczbowych uytkownik moe wiadomie lub przez
pomyk wprowadzi cig znaków niebdcy poprawnie zapisan liczb. Spowoduje
to przerwanie pracy programu. Napisz program umoliwiajcy wczytywanie z klawiatu-
ry liczby zmiennoprzecinkowej typu double przy uyciu metody nextDouble() z klasy
Scanner i reagujcy poprawnie na popeniony bd.
Naley przechwyci i obsuy wyjtek InputMismatchException (pakiet java.util),

a nastpnie ponowi proces wczytywania liczby.

Zadanie 17.2.
Dane liczbowe ze standardowego wejcia moemy wczytywa w postaci acucha
znaków, a nastpnie konwertowa je na liczby odpowiedniego typu. Napisz program,
który w ten sposób wczyta z klawiatury liczb zmiennoprzecinkow i zareaguje po-
prawnie na popenione bdy.
Podczas konwersji acucha na liczb moe wystpi wyjtek NumberFormatExcep-

tion. Naley przechwyci i obsuy ten wyjtek, a nastpnie ponowi proces wczy-
tywania danych.
Zadanie 17.3.
Napisz program, który odczyta i obliczy sum piciu liczb cakowitych, wprowadzo-
nych ze standardowego wejcia. Pomi liczby zmiennoprzecinkowe i acuchy znaków
niebdce liczbami.
Wykorzystaj wyjtki lub informacj, e klasa Scanner oferuje metody sprawdzaj-

ce, jaki kolejny token znajduje si w strumieniu. Na przykad metoda hasNextInt()
sprawdza, czy kolejny token jest liczb cakowit typu int.
Zadanie 17.4.
Napisz program obliczajcy odwrotno liczby cakowitej wprowadzonej z klawiatury.
a) Przechwy i obsu wszystkie wyjtki, jakie mog pojawi si podczas
wczytywania danych i wykonywania oblicze.
b) Zrealizuj zadanie bez obsugi wyjtków.
Zadanie 17.5.
Napisz program obliczajcy wynik dzielenia z reszt dwóch liczb cakowitych wpro-
wadzonych z klawiatury. Przechwy i obsu wyjtki, jakie mog pojawi si podczas
wczytywania danych i wykonywania oblicze.
18. Liczby pseudolosowe i tablice

jednowymiarowe — budujemy
metody statyczne
Liczby losowe powstaj w wyniku dziaania mechanizmu losujcego (rzut kostk do
gry, losowanie ponumerowanych kul z urny itp.) — rozkad tych liczb jest nieregularny
i trudny do przewidzenia. Otrzymywanie liczb losowych w programach komputero-
wych jest bardzo skomplikowane, wic czsto zastpuje si je liczbami pseudoloso-

Rozdzia 3. i Trzeci krok — budujemy wasne metody i klasy 49
wymi (rozkad tych liczb ma pewne regularnoci, które w wielu zastosowaniach mo-
emy pomin).
Do generowania liczb pseudolosowych moemy stosowa statyczn metod java.lang.

Math.random(), zwracajc liczb typu double z przedziau 0, 1 , lub obiekt klasy java.
util.Random i jedn z dostpnych w klasie metod.
Tablica jednowymiarowa — struktura danych do przechowywania okrelonej liczby

danych jednego typu.
Ogólna definicja tablicy przedstawia si nastpujco:

typ_danych [] nazwa_tablicy = new typ_danych[rozmiar_tablicy];
natomiast tablica zainicjowana podanymi wartociami to:

typ_danych [] nazwa_tablicy = { warto_1, warto_2, ..., warto_n };
W Javie tablica jest obiektem. Rozmiar tablicy zapisany jest w polu length. Indek-
sowanie elementów tablicy rozpoczyna si od 0. Jeli podamy indeks spoza zakresu
(0..rozmiar_tablicy-1), to zostanie wygenerowany wyjtek java.lang.ArrayIndex-
OutOfBoundsException.
Metody statyczne, dostpne w klasie java.util.Arrays pozwalaj na wykonywanie

podstawowych operacji na tablicy — sortowanie, wyszukiwanie binarne, kopiowanie itp.
Zadanie 18.1.
Napisz program, który przeprowadzi symulacj 100 rzutów kostk i wywietli wyniki
w konsoli.
Zadanie 18.2.
Napisz program, który przeprowadzi symulacj 1000 rzutów kostk i sporzdzi zesta-
wienie wyników.
Nie zapamituj wyników kolejnych rzutów — wystarczy, e bdziesz na bieco zli-

cza, ile razy wypad dany wynik. Rol licznika moe odgrywa tablica.
Zadanie 18.3.
Dwukrotnie rzucamy kostk do gry i zapisujemy sum wyrzuconych oczek. Napisz
program, który przeprowadzi symulacj 3000 powtórze dowiadczenia i sporzdzi
zestawienie wyników.
Zadanie 18.4.
Utwórz funkcj rand() z dwoma parametrami a i b, losujc liczb rzeczywist nale-
c do przedziau a, b , gdzie a i b s liczbami cakowitymi i a < b. Wynik losowa-
nia powinien by podany z precyzj do 0,1. Napisz program demonstrujcy dziaanie
tej funkcji.

Zadanie 18.5.
Napisz program losujcy 500 liczb rzeczywistych z przedziau 0, 5. Przedstaw roz-
kad wylosowanych liczb w przedziaach o dugoci 1.
Zadanie 18.6.
Utwórz funkcj (metod statyczn) lotto() losujc 6 rónych liczb z 49 i zwracajc
wynik w postaci tablicy liczb cakowitych. Napisz program demonstrujcy dziaanie
tej metody.
Zadanie 18.7.
Utwórz funkcj (metod statyczn) lotto() z dwoma parametrami m i n, losujc m
rónych liczb sporód liczb od 1 do n i zwracajc wynik w postaci tablicy liczb ca-
kowitych. Napisz program demonstrujcy dziaanie tej metody.
Rozwizujc kolejne zadania (18.8 – 18.18), zbudujemy klas MyRandomArray, groma-

dzc metody umoliwiajce tworzenie jednowymiarowych tablic wypenionych pseu-
dolosowymi liczbami typu cakowitego int lub zmiennoprzecinkowego double.
Zadanie 18.8.
Utwórz statyczn metod int[] rndArray(int n, int m) suc do budowania tabli-
cy liczb cakowitych o podanym wymiarze n, wypenionej pseudolosowymi wartocia-
mi z zakresu 0, 1, …, m-1. Zdefiniuj metody uatwiajce wywietlanie elementów ta-
blicy oddzielonych odstpem void arrayPrint(int[] tab) i void arrayPrintln(int[]
tab) — nazwy sugeruj rónic w dziaaniu tych metod. Utwórz równie metod do-
dajc do wszystkich elementów tablicy okrelon warto void addToArray(int[]
tab, int d). Napisz program demonstrujcy dziaanie tych metod.
Tworzone metody skopiuj do pliku MyRandomArray.java w biecym folderze.

import java.util.Random;
public class MyRandomArray {
/* Tu skopiuj kody metod */
}
Bdziesz móg z nich korzysta podczas rozwizywania innych zada, np. kod:
int[] los = MyRandomArray.rndArray(6, 49);
MyRandomArray.addToArray(los, 1);
MyRandomArray.arrayPrintln(los);
stanowi przykad losowania 6 liczb z 49 (podobnie jak w rozwizaniu zadania 18.6
— w tym przypadku jednak liczby mog si powtarza ) przy uyciu metod statycz-
nych z klasy MyRandomArray.
Zadanie 18.9.
Utwórz statyczn metod int[] rndUniqueArray(int n, int m) suc do budowa-
nia tablicy liczb cakowitych o podanym wymiarze (n) i niepowtarzajcych si elemen-

tach, wypenionej pseudolosowymi wartociami z okrelonego zakresu 0, 1, …, m-1.

Napisz program demonstrujcy dziaanie tej metody. Docz j do klasy MyRandomArray.
Skorzystaj z rozwizania zadania 18.6.
Zadanie 18.10.
Utwórz statyczne metody int[] rndSortArray(int n, int m) i int[] rndSortUnique-
Array(int n, int m), które bd suy do budowania posortowanych tablic liczb
cakowitych o podanym wymiarze (n), wypenionych pseudolosowymi wartociami
z zakresu 0, 1, …, m-1. Druga metoda powinna zwraca tablic o niepowtarzajcych
si elementach. Napisz program demonstrujcy dziaanie tych metod. Docz je do
klasy MyRandomArray.
Skorzystaj z rozwizania zadania 18.9 oraz metody sortujcej z klasy Arrays.
Zadanie 18.11.
Utwórz statyczn metod double[] rndArray(int n, double a), która bdzie suy
do budowania tablicy liczb zmiennoprzecinkowych typu double o podanym wymiarze
(n), wypenionej pseudolosowymi wartociami z przedziau 0, a . Zdefiniuj meto-
dy uatwiajce wywietlanie elementów tablicy oddzielonych odstpem void array-
Print(double[] tab), void arrayPrintln(double[] tab) i void arrayPrintf(String
spec, double[] tab) — nazwy sugeruj sposób dziaania tych metod. Ponadto utwórz
metod dodajc do wszystkich elementów tablicy okrelon warto void addToAr-
ray(double[] tab, double d). Napisz program demonstrujcy dziaanie tych metod.
Metody te maj nazwy takie same jak metody istniejce w klasie MyRandomArray,
ale róni si typami parametrów wywoania. Moemy wic te metody dodawa do
klasy MyRandomArray — wykorzystujemy tutaj moliwo przeciania metod.
Zadanie 18.12.
Utwórz statyczn metod double[] rndUniqueArray(int n, double a), która bdzie
suy do budowania tablicy liczb zmiennoprzecinkowych o podanym wymiarze (n)
i niepowtarzajcych si elementach, wypenionej pseudolosowymi wartociami z prze-
dziau 0, a . Napisz program demonstrujcy dziaanie tej metody. Docz j do klasy
MyRandomArray.

Zadanie 18.13.
Utwórz statyczne metody double[] rndSortArray(int n, double a) i double[] rnd-
SortUniqueArray(int n, double a), które bd suy do budowania posortowanych
tablic liczb zmiennoprzecinkowych o podanym wymiarze (n), wypenionych pseudo-
losowymi wartociami z przedziau 0, a . Druga metoda powinna zwraca tablic
o niepowtarzajcych si elementach. Napisz program demonstrujcy dziaanie tych
metod. Docz je do klasy MyRandomArray.
Zadanie 18.14.
Utwórz statyczn metod void roundArray(double[] tab, int prec), która bdzie
zaokrgla wszystkie liczby w tablicy tab do okrelonej liczby miejsc po przecinku
(parametr prec). Napisz program demonstrujcy dziaanie tej metody. Docz j do
klasy MyRandomArray.
Zadanie 18.15.
Utwórz statyczn metod double[] rndArray(int n, double a, int prec), która b-
dzie suy do budowania tablicy liczb zmiennoprzecinkowych o podanym rozmiarze
(n) i wartociach z przedziau 0, a oraz o okrelonej liczbie miejsc po przecinku (pa-
rametr prec). Napisz program demonstrujcy dziaanie tej metody. Docz j do klasy
MyRandomArray.
Zadanie 18.16.
Utwórz statyczn metod double[] rndArray(int n, double a, double step), która
bdzie suy do budowania tablicy liczb zmiennoprzecinkowych o podanym rozmiarze
(n) i wartociach z przedziau 0, a bdcych wielokrotnoci parametru step. Na-
pisz program demonstrujcy dziaanie tej metody. Docz j do klasy MyRandomArray.
Zadanie 18.17.
Utwórz statyczne metody void inputArray(int[] tab) i void inputArray(double[]
tab), które bd umoliwia wprowadzanie danych z klawiatury do tablicy odpowied-
niego typu. Napisz program demonstrujcy dziaanie tych metod. Utwórz klas MyAr-
ray i umie w niej te dwie metody oraz wczeniej zdefiniowane metody suce do
wywietlania zawartoci tablic jednowymiarowych i do zaokrglania wartoci w ta-
blicy liczb typu double (z klasy MyRandomArray).
Zadanie 18.18.
Utwórz statyczn metod konwertujc tablic liczb cakowitych na tablic liczb zmien-
noprzecinkowych (double[] intArrayToDouble(int[] tab)) oraz metod (int[] dou-
bleArrayToInt(double[] tab)) dziaajc odwrotnie.

Utwórz drug tablic o takim samym rozmiarze, z odpowiednim typem danych,

i przepisz do niej elementy z pierwszej tablicy, stosujc rzutowanie typów.
19. Dokumentacja klasy

JDK zawiera narzdzie javadoc, generujce na podstawie komentarzy dokumentacyj-
nych w plikach ródowych dokumentacj w formie plików HTML.
W komentarzach mona umieszcza dowolny tekst, znaczniki jzyka HTML oraz spe-
cjalne znaczniki dokumentacyjne (zaczynajce si od znaku @).
Komentarz dokumentacyjny zaczyna si od znaku /** i koczy si znakiem */. Ko-
mentarze blokowe /* ... */ i liniowe // ... s podczas tworzenia dokumentacji
pomijane.
W kolejnych zadaniach poznasz wybrane przykady z zakresu tworzenia dokumentacji.
Zadanie 19.1.
Przygotuj „cigawk” z instrukcj obsugi aplikacji javadoc.exe dla uywanego ro-
dowiska JDK.
W konsoli wykonaj polecenie javadoc –help > opis.txt. W pliku opis.txt znajdziesz
wszystkie opcje aplikacji javadoc.exe.
Zadanie 19.2.
Utwórz plik ródowy Z19_2.java, który bdzie zawiera nastpujcy kod:
public class Z19_2 {
private static final String HELLO = "Hello World!";
static String hello() {

return HELLO;
}

System.out.println(hello());
}
}
Skompiluj i uruchom przykad. Dokumentacj klasy Z19_2 moesz sporzdzi, post-

pujc wedug schematu:
otwórz konsol,
przejd do folderu z plikiem Z19_2.java,

wykonaj polecenie: javadoc Z19_2.java (zapoznaj si z treci uwagi),

otwórz plik index.html i obejrzyj dokumentacj klasy.
Powtórz zadanie, tworzc kilka wersji dokumentacji — zapamitaj znaczenie uytych

opcji:
a) javadoc –d Z19_2a -nohelp Z19_2.java
b) javadoc –d Z19_2b -notree Z19_2.java
c) javadoc –d Z19_2c -noindex Z19_2.java
d) javadoc –d Z19_2d -nodeprecatedlist Z19_2.java
e) javadoc –d Z19_2e –nodeprecatedlist -noindex -notree -nohelp
–private Z19_2.java
Aby unikn kolizji pomidzy plikami dokumentacji (nadpisywanie plików), przyjmij

za zasad tworzenie dokumentacji dla poszczególnych zada w odrbnych folde-
rach. Nazwy folderów niech zawieraj numer zadania. W zwizku z tym ju od tego
zadania uywaj opcji –d, wskazujc folder, w którym zostanie zapisana dokumen-
tacja. Zatem zamiast polecenia javadoc Z19_2.java zastosuj polecenie javadoc
–d Z19_2 Z19_2.java. Dokumentacja klasy zostanie zapisana w biecym folde-
rze, w podfolderze Z19_2.
Zadanie 19.3.
Utwórz plik ródowy Z19_3.java, który bdzie zawiera kod z zadania 19.2. Wstaw
komentarze w postaci /** tekst komentarza */ przed kodem klasy, definicj staej
i definicjami metod. W komentarzach zawrzyj zwize opisy przedstawianych elemen-
tów. Sporzd dokumentacj i przeanalizuj otrzymany dokument. Zastosuj opcje –d
<directory> i –private.
Zadanie 19.4.
Rozwizujc zadania 18.8, 18.11, 18.17 i 18.18, utworzylimy kilka statycznych me-
tod uatwiajcych prac z jednowymiarowymi tablicami liczb cakowitych typu int
i tablicami liczb zmiennoprzecinkowych typu double. Metody zostay zgromadzone
w klasie MyArray. Na tej podstawie utwórz klas MyIntArray, która bdzie zawiera
metody dziaajce na tablicach liczb cakowitych (moesz zmieni nazwy metod lub
doda dodatkowe metody), i sporzd dokumentacj tej klasy (dokumentacj zapisz
w folderze MyIntArray). W dokumentacji umie informacje o autorze i wersji klasy.
W komentarzu do klasy wykorzystaj znaczniki @author i @version. Dokumentacj

utwórz z opcjami –author i –version.
Zadanie 19.5.
Na podstawie rozwiza zada 18.8, 18.11, 18.17, 18.18 i 19.4 zbuduj klas MyDouble-
Array, która bdzie zawiera statyczne metody uatwiajce prac z jednowymiarowy-

mi tablicami liczb typu double. Sporzd dokumentacj klasy i zapisz j w folderze

MyDoubleArray.
Zadanie 19.6.
Na podstawie rozwizania zadania 19.5 zbuduj klas MyFloatArray, która bdzie za-
wiera statyczne metody uatwiajce prac z jednowymiarowymi tablicami liczb typu
float. Sporzd dokumentacj klasy i zapisz j w folderze MyFloatArray.
Utwórz wspóln dokumentacj klas MyIntArray, MyDoubleArray i MyFloatArray w fol-

derze MyArrays.
Zadanie 19.7.
W pliku MyRandomArray.java, utworzonym podczas rozwizywania zada z rozdzia-
u 18., wpisz komentarze dokumentacyjne. Utwórz dokumentacj klasy MyRandomArray
i zapisz t dokumentacj w folderze o tej samej nazwie.
20. Dziaania na uamkach

— budujemy klas Fraction
Rozwizujc systematycznie kolejne zadania, bdziemy tworzy wasn klas Frac-
tion (uamki) oraz programy ukazujce moliwoci tej klasy. Na bieco zbudujemy
dokumentacj klasy.
Zadanie 20.1.
Zbuduj klas Fraction, która bdzie zawiera dwa prywatne pola reprezentujce licz-
nik i mianownik uamka. W klasie tej umie konstruktor z dwoma parametrami, który
bdzie budowa uamek na podstawie dwóch liczb cakowitych (licznika i mianowni-
ka), oraz publiczn metod toString(), zwracajc uamek w postaci acucha zna-
ków, np. "4/13" (licznik, kreska uamkowa / i mianownik). Napisz program pokazu-
jcy dziaanie konstruktora i zdefiniowanej metody.
Zadanie 20.2.
Dodaj do klasy Fraction konstruktor bezparametrowy budujcy uamek odpowiadaj-
cy liczbie 0 oraz konstruktor z jednym parametrem cakowitym m budujcy uamek
m/1. Napisz program pokazujcy dziaanie tych konstruktorów.
Zadanie 20.3.
Utwórz w klasie Fraction konstruktor kopiujcy i napisz program pokazujcy dziaa-
nie tego konstruktora.

Zadanie 20.4.
Zauwamy, e obiekty new Fraction(-3, 4) i new Fraction(3, -4) reprezentuj ten
3
sam uamek . Po zamianie obiektów na acuchy znaków (metod toString())
4
otrzymamy odpowiednio "-3/4" i "3/-4". Podobnie wygldaaby sytuacja dla obiek-
tów new Fraction(2, 5) i new Fraction(-2, -5) reprezentujcych uamek 2/5. Zapis
uamka w postaci "3/-4" lub "-2/-5" nie wyglda korzystnie (lepszy bdzie zapis
"-3/4" lub "2/5"). Mona przyj, e bdziemy zapamitywali zawsze dodatni mianow-
nik, a znak licznika zadecyduje o znaku uamka. Dodaj do klasy Fraction prywatn
metod, która wywoana wewntrz konstruktora skoryguje licznik i mianownik uam-
ka zgodnie z przyjt umow. Napisz program pokazujcy skutki dziaania tej metody.
Metod nazwij correction() (poprawka). Bdzie ona przydatna podczas wyznacza-

nia odwrotnoci ujemnego uamka lub dzielenia przez taki uamek.
Zadanie 20.5.
Zauwamy, e obiekty new Fraction(3, 4) i new Fraction(15, 20) reprezentuj ten
sam uamek 3/4. Dodaj do klasy Fraction publiczne metody suce do skracania
uamka (przez najwikszy wspólny dzielnik licznika i mianownika lub inn podan
warto) oraz publiczn metod pozwalajc na rozszerzanie uamka. Napisz program
pokazujcy dziaanie tych metod.
Metod skracajc uamek nazwij reduce() (ang. reducing fraction — skraca ua-
mek). Do realizacji tej metody niezbdna bdzie prywatna metoda obliczajca naj-
mniejszy wspólny dzielnik (ang. Greatest Common Factor — GCF). Proponujemy
w tym przypadku uycie polskiego skrótu nwd. Metod rozszerzajc uamek nazwij
equivalent() (ang. equivalent fraction — uamek).
Zadanie 20.6.
W klasie Fraction utwórz metody zwracajce nowy obiekt Fraction, bdcy iloczynem
uamka reprezentowanego przez ten obiekt i inny obiekt lub liczb cakowit. Napisz
program pokazujcy dziaanie tych metod.
Dziki moliwoci przeciania nazw metod obie metody mog mie t sam na-
zw mult() (ang. multiplication — mnoenie).
Zadanie 20.7.
W klasie Fraction utwórz metody statyczne (o nazwie product(), ang. product — ilo-
czyn) zwracajce obiekt Fraction, bdcy iloczynem dwóch uamków, uamka i licz-
by cakowitej lub dwóch liczb cakowitych. Napisz program demonstrujcy dziaanie
tych metod.

Zadanie 20.8.
W klasie Fraction utwórz metod zwracajc nowy obiekt Fraction, reprezentujcy
uamek odwrotny do uamka zawartego w obiekcie wywoujcym t metod. Utwórz
metod statyczn o podobnej funkcjonalnoci. Napisz program pokazujcy dziaanie
tych metod. Wykorzystaj odwrotno do obliczenia ilorazu dwóch uamków.
Metodom nadaj nazw multInv(), pochodzc od okrelenia ang. multiplicative

inverse — odwrotno (liczby).
Zadanie 20.9.
W klasie Fraction utwórz metody zwracajce nowy obiekt Fraction, bdcy ilorazem
uamka reprezentowanego przez ten obiekt i inny obiekt lub liczb cakowit.
Metodom nadaj nazw div() (ang. division — dzielenie).
Zadanie 20.10.
W klasie Fraction utwórz metody statyczne (o nazwie quot(), ang. quotient — iloraz)
zwracajce obiekt Fraction, bdcy ilorazem dwóch uamków, uamka i liczby cakowitej
lub dwóch liczb cakowitych. Napisz program demonstrujcy dziaanie tych metod.
Zadanie 20.11.
W klasie Fraction utwórz metody (o nazwie add(), ang. addition — dodawanie) zwra-
cajce nowy obiekt Fraction, bdcy sum uamka reprezentowanego przez ten obiekt
i inny obiekt lub liczb cakowit. Napisz program pokazujcy dziaanie tych metod.
Podczas dodawania uamków o rónych mianownikach niezbdne jest sprowadze-

nie uamków do wspólnego mianownika.
Wspólnym mianownikiem moe by iloczyn mianowników, czyli dodawanie moemy
a c ad bc ad bc
wykona wedug wzoru . Korzystniej bdzie jednak
b d bd bd bd
obliczy najmniejsz wspóln wielokrotno (NWW(b, d)) mianowników i t liczb
przyj jako wspólny mianownik (zob. rozwizania zada 15.7 lub 15.9). Prywatn
metod nww() dodaj do klasy Fraction.
Zadanie 20.12.
W klasie Fraction utwórz metody statyczne (o nazwie sum(), ang. sum — suma) zwra-
cajce obiekt Fraction, bdcy sum dwóch uamków lub uamka i liczby cakowitej.
Napisz program demonstrujcy dziaanie tych metod.

Zadanie 20.13.
W klasie Fraction utwórz metod zwracajc nowy obiekt Fraction, reprezentujcy
uamek przeciwny do uamka zawartego w obiekcie wywoujcym t metod. Utwórz
metod statyczn o podobnej funkcjonalnoci. Napisz program pokazujcy dziaanie
tych metod. Wykorzystaj uamek przeciwny do obliczenia rónicy dwóch uamków.
Metodom nadaj nazw addInv(), pochodzc od okrelenia ang. additive inverse

— liczba przeciwna.
Zadanie 20.14.
W klasie Fraction utwórz metody (o nazwie sub(), ang. subtraction — odejmowanie)
zwracajce nowy obiekt Fraction, bdcy rónic uamka reprezentowanego przez
ten obiekt i inny obiekt lub liczb cakowit. Napisz program pokazujcy dziaanie
tych metod.
a c ad bc ad bc
Odejmowanie moemy wykona wedug wzoru lub
b d bd bd bd
stosujc jako wspólny mianownik NWW(b, d). Proponujemy uproci spraw i za-
a c a c
stpi odejmowanie dodawaniem liczby przeciwnej: .
b d b d
Zadanie 20.15.
W klasie Fraction utwórz metody statyczne (o nazwie diff(), ang. difference — ró-
nica) zwracajce obiekt Fraction, bdcy rónic dwóch uamków lub uamka i licz-
by cakowitej. Napisz program demonstrujcy dziaanie tych metod.
Zadanie 20.16.
Dodaj do klasy Fraction metody (getNum() i getDen()) pozwalajce na odczytanie
wartoci prywatnych pól obiektu (licznika i mianownika uamka reprezentowanego
przez obiekt). Napisz program demonstrujcy dziaanie tych metod.
Zadanie 20.17.
Dopuszcza si zmiany wartoci prywatnych pól obiektu (przy uyciu metod) w celu
zmiany jego wartoci bez tworzenia nowej instancji obiektu. Zdefiniuj w klasie Frac-
tion metody setNum(int), setDen(int) i setFrac(int, int), które bd zmienia war-
to licznika, mianownika lub jednoczenie licznika i mianownika uamka (obiektu).
Zadanie 20.18.
Metoda Object.equals() jest dziedziczona przez wszystkie klasy i pozwala ustali,
czy dwa obiekty s identyczne. W klasie Fraction za równe uznamy te obiekty, które
reprezentuj ten sam uamek. Utwórz i docz do klasy metod equals(), przesania-

jc metod Object.equals(), oraz napisz program testujcy poprawno dziaania

zbudowanej metody.
a c
Do porównania uamków wykorzystaj zaleno ad bc . Metoda ta
b d
zawiedzie, gdy warto iloczynów (ad lub bc) przekroczy zakres liczb cakowitych.
Bezpieczniejszym rozwizaniem byoby doprowadzenie obu uamków do postaci
nieskracalnej — takie uamki bd równe wtedy i tylko wtedy, gdy bd miay rów-
12 4 20 4 12 20
ne liczniki i równe mianowniki, np. i , wic .
27 9 45 9 27 45
Metoda equals() powinna by zwrotna, symetryczna i przechodnia (cechy rela-

cji równowanoci). Ponadto powinna by spójna, czyli wielokrotne wywoywanie
x.equals(y) musi konsekwentnie zwraca t sam warto (albo true, albo fal-
se), o ile nie zostaa zmodyfikowana adna dana wykorzystywana do porównywania
(w naszym przypadku skracanie lub rozszerzanie uamka nie moe mie wpywu na
wynik porównania). Jeli x jest niepust referencj (wskazuje obiekt), to x.equals
(null) musi zwraca warto false.
Jeli w klasie przedefiniujemy metod equals(), to naley równie przedefiniowa
metod hashCode(). Jest to konieczne do prawidowej wspópracy klasy z kolek-
cjami korzystajcymi z kodowania mieszajcego (np. HashSet).
Zadanie 20.19.
Dodaj do klasy Fraction metody zwracajce warto dziesitn uamka reprezentowa-
nego przez obiekt. Napisz program demonstrujcy dziaanie tych metod.
Podziel licznik przez mianownik, pamitajc o tym, aby co najmniej jedn z liczb rzu-
towa przed wykonaniem dzielenia na typ zmiennoprzecinkowy. Sugerowane nazwy
metod to doubleValue() i floatValue(); dla metod statycznych: toDouble(Frac-
tion), toFloat(Fraction).
Zadanie 20.20.
Uamek moe by przedstawiony jako acuch znaków w postaci "4/7" (uamek zwy-
ky), "5" (liczba cakowita odpowiadajca uamkowi 5/1), "2.45" (uamek dziesitny
odpowiadajcy uamkowi 245/100) lub "2,45" (wedug zasad zapisu obowizujcych
w Polsce). Zbuduj konstruktor, który na podstawie acucha znaków utworzy odpo-
wiedni obiekt klasy Fraction lub zgosi wyjtek, gdy acuch znaków nie bdzie przed-
stawia uamka. Napisz program demonstrujcy dziaanie tego konstruktora.
Zadanie 20.21.
Zbuduj kilka metod statycznych o nazwie valueOf() z jednym parametrem (typu float,
double, int, String) lub dwoma parametrami (typu int), zwracajcych obiekt Fraction

reprezentujcy uamek o wartoci odpowiadajcej podanemu parametrowi. Napisz pro-

gram demonstrujcy dziaanie tych metod.
W kolejnych zadaniach (20.22 – 20.27) wykorzystamy obiekty i metody klasy Fraction,

uzyskujc wyniki oblicze w postaci dokadnej, wyraonej uamkami zwykymi.
Zadanie 20.22.
Okrelamy nieskoczony cig liczbowy w nastpujcy sposób: a1 1 , a2 1 1 ,
1
1 , 1 …. Korzystajc z obiektów i metod klasy Fraction, na-
a3 1 1
1 a4 1
1 1
1 1
1
1
pisz program obliczajcy 15 pocztkowych wyrazów cigu. Ile maksymalnie wyrazów
tego cigu mógby w tym programie obliczy?
Zadanie 20.23.
Korzystajc z obiektów i metod klasy Fraction, napisz program obliczajcy sumy cz-
ciowe nieskoczonego szeregu 1 1 1 1 1 ... .
2 4 8 16
Zadanie 20.24.
Korzystajc z obiektów i metod klasy Fraction, napisz program obliczajcy sumy cz-
ciowe nieskoczonego szeregu 1 1 1 1 1 ... .
2 4 8 16
Zadanie 20.25.
Napisz program rozwizujcy równanie o postaci ax b 0 w zbiorze liczb wymier-
nych, posugujc si obiektami i metodami klasy Fraction.
Zadanie 20.26.
Napisz program rozwizujcy metod wyznaczników ukad dwóch równa liniowych
z dwiema niewiadomymi w zbiorze liczb wymiernych. Wykorzystaj obiekty i metody
klasy Fraction. Utwórz metod det(), która bdzie oblicza wyznacznik, oraz metod
inputFraction() do wprowadzania z klawiatury wartoci obiektów klasy Fraction.
Wygodnie jest zbudowa metod inputFraction() z jednym parametrem typu

String, bdcym opisem poprzedzajcym wprowadzanie (tzw. znak zachty). Wpro-
wadzenie wartoci obiektu a moe wyglda tak: Fraction a = inputFraction
("a = "); — w konsoli pojawi si napis a = i migajcy kursor; uytkownik wpisu-
je warto i naciska klawisz Enter. Z konsoli pobierzemy tekst i zamienimy go na
obiekt Fraction, stosujc metod valueOf(). Pozwoli to na poprawne zinterpreto-
wanie danych o postaci "2,45", "2.45", "-5" lub "2/3".

Zadanie 20.27.
Pierwiastek drugiego stopnia z liczby nieujemnej a moemy obliczy ze wzoru itera-
1§ a·
cyjnego x ¨ x ¸ , biorc warto pocztkow x = 1. Korzystajc z obiektów i me-
2© x¹
tod klasy Fraction, napisz program obliczajcy przyblienie liczby 5 w postaci uamka
zwykego.
Ten proces iteracyjny jest szybko zbieny i 4 – 5 iteracji wystarczy do wyznaczenia

wyniku. Wiksza liczba iteracji nie jest moliwa do wykonania przy uyciu klasy
Fraction (zbyt szybko rosncy licznik i mianownik uamka).
21. Klasa opakowujca Angle

— miara kta i funkcje
trygonometryczne
Zadanie 21.1.
Utwórz klas Angle zawierajc jedno pole prywatne x typu double przechowujce
miar kta podan w radianach. W klasie zbuduj konstruktor z jednym parametrem
double (miara kta w radianach) i sze metod zwracajcych wartoci funkcji trygo-
nometrycznych kta reprezentowanego przez obiekt. Napisz program demonstrujcy
dziaanie konstruktora i utworzonych metod.
Oprócz powszechnie znanych funkcji trygonometrycznych sinus, cosinus tangens

1
i cotangens w klasie Angle uwzgldnimy mniej popularne funkcje secans ( sec x )
cos x
1
i cosecans ( csc x ).
sin x
Zadanie 21.2.
Docz do klasy Angle publiczne metody (radian() i degree()) zwracajce liczb typu
double, miar kta reprezentowanego przez obiekt wyraon w radianach i stopniach.
Zadanie 21.3.
Docz do klasy Angle publiczn metod toString(), która bdzie zwraca acuch
znaków (o postaci 45°30'15") przedstawiajcy miar kta reprezentowanego przez
obiekt wyraon w stopniach, minutach i sekundach. Napisz program demonstrujcy
dziaanie tej metody.

Metoda toString() przesoni metod o tej samej nazwie, dziedziczon z klasy Ob-
ject. Metod t naley zdefiniowa z adnotacj Override (@Override).
Zadanie 21.4.
Docz do klasy Angle trzy konstruktory — z jednym, dwoma lub trzema parametrami
typu int — umoliwiajce zbudowanie obiektu reprezentujcego kt o podanej licz-
bie stopni, stopni i minut lub stopni, minut i sekund. Ogranicz liczb stopni do zakre-
su od 0° do 360°, a liczb minut i sekund do zakresu od 0 do 60. Napisz program de-
monstrujcy dziaanie tych konstruktorów.
Zadanie 21.5.
Cig znaków o postaci 105°30'15" przedstawia miar kta w stopniach, minutach i se-
kundach ktowych. Utwórz konstruktor w klasie Angle, który zbuduje obiekt reprezen-
tujcy kt o podanej w ten sposób mierze. Napisz program demonstrujcy dziaanie
tego konstruktora.
Zadanie 21.6.
Utwórz w klasie Angle sze metod o nazwie setOfXxx, gdzie Xxx oznacza nazw funk-
cji trygonometrycznej, ustawiajcych miar kta reprezentowanego przez obiekt na
podstawie podanej wartoci odpowiedniej funkcji (metody te odpowiadaj funkcjom
odwrotnym do funkcji trygonometrycznych). Metody zmieniaj warto obiektu, ale
nie zwracaj adnej wartoci. Napisz program demonstrujcy dziaanie tych metod.
Zadanie 21.7.
Na paszczy nie z ukadem wspórzdnych czsto potrzebujemy wyznaczy miar
kta nachylenia prostej przechodzcej przez pocztek ukadu wspórzdnych i punkt
P(x, y) do osi OX. Utwórz w klasie Angle metod o nazwie setOfPoint(), ustawiajc
miar tego kta jako warto obiektu. Napisz program demonstrujcy dziaanie meto-
dy setOfPoint().
Zadanie 21.8.
Utwórz w klasie Angle konstruktor z dwoma parametrami typu double, tworzcy no-
wy obiekt reprezentujcy miar kta nachylenia prostej przechodzcej przez pocztek
ukadu wspórzdnych i punkt P(x, y) do osi OX. Napisz program demonstrujcy dzia-
anie tego konstruktora.
Zadanie 21.9.
Zbuduj w klasie Angle statyczne funkcje o nazwie valueOf(), o rónych parametrach
(takich samych jak konstruktory zbudowane w zadaniach 21.1, 21.4, 21.5 i 21.8), zwra-
cajce obiekt klasy Angle odpowiadajcy ktowi o podanych parametrach. Napisz pro-
gram demonstrujcy dziaanie tych metod.

Zadanie 21.10.
Na miarach któw moemy wykonywa dodawanie i odejmowanie. Dodaj do klasy
Angle metody add() (sub()), które bd zwraca nowy obiekt, bdcy sum (rónic)
miary kta reprezentowanego przez obiekt wywoujcy metod i miary kta w obiek-
cie podanym jako parametr. Napisz program demonstrujcy dziaanie tych metod.
Zadanie 21.11.
Docz do klasy Angle statyczne metody sum() (diff()), które bd oblicza sum (ró-
nic) dwóch obiektów podanych jako parametry (miar któw reprezentowanych przez
te obiekty). Wynik powinien by obiektem klasy Angle. Napisz program demonstruj-
cy dziaanie tych metod.
Zadanie 21.12.
Miary któw mona mnoy (dzieli) przez liczb. Napisz metod mult() (div()), która
bdzie zwraca nowy obiekt, reprezentujcy kt o mierze bdcej iloczynem (ilorazem)
miary kta reprezentowanego przez obiekt i liczby podanej jako parametr (cakowitej
lub zmiennoprzecinkowej). Napisz program demonstrujcy dziaanie tych metod.
Zadanie 21.13.
Napisz metod prod() (quot()), która bdzie zwraca obiekt klasy Angle, reprezentu-
jcy kt o mierze bdcej iloczynem (ilorazem) miary kta (obiektu) podanego jako
parametr i liczby podanej jako drugi parametr. Napisz program demonstrujcy dziaa-
nie tych metod.
Zadanie 21.14.
Docz do klasy Angle statyczne pola przechowujce stae wartoci obiektów repre-
zentujcych wybrane kty: RIGHT_ANGLE (kt prosty), STRAIGHT_ANGLE (kt pópeny)
i FULL_ANGLE (kt peny), RADIAN (1 radian), DEGREE (1 stopie), ARCMINUTE (1 minuta k-
towa) i ARCSECOND (1 sekunda ktowa). Napisz program pokazujcy wartoci tych staych.
Stae w Javie s waciwie zmiennymi deklarowanymi ze sowem kluczowym final.

Wartoci staych w czasie dziaania programu nie moemy zmieni .
Zadanie 21.15.
Dodaj do klasy Angle metod compl() (ang. complementary angle — kt dopeniajcy),
zwracajc obiekt reprezentujcy dopenienie kta (obiektu) podanego jako parametr,
i metod suppl() (ang. supplementary angle — kt przylegy), zwracajc obiekt re-
prezentujcy miar kta przylegego do kta (obiektu) podanego jako parametr. Napisz
program demonstrujcy dziaanie tych metod.
Klasa Angle jest ju dostatecznie rozbudowana. W kilku kolejnych zadaniach pokae-
my przykady wykorzystania pochodzcych z niej obiektów i metod.

Zadanie 21.16.
Utwórz metod inputAngle() z jednym parametrem typu String (przeznaczonym do
opisania wprowadzanej wielkoci), zwracajc obiekt Angle reprezentujcy kt o mie-
rze podanej w stopniach. Metoda ta powinna poprawnie interpretowa takie dane: liczba
cakowita stopni, liczba rzeczywista (uamek dziesitny) bez podawania symbolu stop-
nia oraz cig znaków zawierajcych stopnie, minuty i sekundy ktowe z odpowiedni-
mi symbolami jednostek (np. 24°30'15").
Napisz program rozwizujcy nastpujce zadanie: W trójkcie równoramiennym kt

przy wierzchoku ma miar D . Oblicz miar kta E przylegego do podstawy tego
trójkta. Sprawd obliczenia, dodajc miary wszystkich któw wewntrznych trójkta.
Podczas wprowadzania danych symbol stopnia (°) moesz uzyska , wpisujc Alt+0176
(przytrzymaj lewy klawisz Alt i wprowad kod 0176 z klawiatury numerycznej). Sym-
bole minuty i sekundy to apostrof i cudzysów (dostpne bezporednio na klawia-
turze). Miary któw speniaj zaleno D 2E 180q .
Zadanie 21.17.
Napisz program rozwizujcy zadanie: W trójkcie równoramiennym kt przylegy
do podstawy ma miar E . Oblicz miar kta D lecego naprzeciw podstawy tego
trójkta. Sprawd obliczenia, dodajc miary wszystkich któw wewntrznych trójkta.
Zadanie 21.18.
Napisz program rozwizujcy zadanie: Oblicz miary któw w trójkcie równoramien-
nym o podstawie a i ramieniu dugoci b. Sprawd obliczenia, dodajc miary wszyst-
kich któw wewntrznych trójkta.
Zadanie 21.19.
Napisz program rozwizujcy zadanie: Oblicz miary któw w trójkcie równoramien-
nym o podstawie a i wysokoci (opuszczonej na podstaw) h. Sprawd obliczenia, do-
dajc miary wszystkich któw wewntrznych trójkta.
Zadanie 21.20.
Napisz program rozwizujcy zadanie: Oblicz miary któw w trójkcie o bokach a, b
i c. Sprawd obliczenia, dodajc miary wszystkich któw wewntrznych trójkta.
22. Liczby rzymskie i klasa Roman

Zadanie 22.1.
Napisz program zamieniajcy liczby naturalne podawane z klawiatury w postaci dzie-
sitnej na liczby zapisane w systemie rzymskim. Warunkiem zakoczenia programu
powinno by podanie liczby 0.

Stosujc symbole I, V, X, L, C, D i M oraz reguy zapisu liczb rzymskich, moemy

zapisa liczb naturaln z zakresu od 0 do 3999.
Zadanie 22.2.
Napisz program odczytujcy warto dziesitn liczby zapisanej znakami rzymskimi.
Dane wprowadzamy z klawiatury. Warunkiem zakoczenia programu powinno by
wprowadzenie pustego acucha znaków.
Zadanie 22.3.
Utwórz metod statyczn decToRoman(), która bdzie zamienia liczb naturaln z za-
kresu od 1 do 3999 na liczb w zapisie rzymskim. Napisz program demonstrujcy dzia-
anie tej metody.
Skorzystaj z tablic zbudowanych w rozwizaniu zadania 22.1.
Zadanie 22.4.
W procesie kodowania liczb rzymskich stosujemy dwie tablice — tablic z wartocia-
mi wybranych liczb rzymskich i tablic z odpowiadajcymi im wartociami dziesitny-
mi. Utwórz klas RN (ang. roman numbers), która bdzie zawiera dwa pola: pole typu
String (symbol rzymski) oraz pole typu int (warto dziesitna tej liczby rzymskiej).
Klasa powinna udostpnia jedynie tablic z parami wartoci ("M", 1000), ("CM", 900)
itd. Zmodyfikuj metod decToRoman() (z zadania 22.3) tak, aby wykorzystywaa tabli-
c z klasy RN.
Zadanie 22.5.
Utwórz metod statyczn romanToDec(), która bdzie zamienia liczb zapisan w syste-
mie rzymskim na liczb dziesitn. Napisz program demonstrujcy dziaanie tej metody.
Skorzystaj z rozwiza zada 22.2 i 22.4.
Zadanie 22.6.
Utwórz klas Roman, która bdzie mie jedno pole typu int zawierajce liczb naturaln
z zakresu od 1 do 3999. W klasie tej zbuduj konstruktory tworzce obiekt na podsta-
wie parametru bdcego liczb cakowit lub acuchem znaków przedstawiajcym
liczb w zapisie rzymskim. Docz do klasy inne metody przydatne do pracy z licz-
bami rzymskimi. Napisz program demonstrujcy moliwoci tej klasy.
Skorzystaj z rozwiza zada 22.1 – 22.5 oraz dowiadcze zdobytych podczas

tworzenia klasy Angle.

Zadanie 22.7.
Korzystajc z klasy Roman, napisz aplikacj sprawdzajc umiejtno odczytywania
wartoci liczb rzymskich. Liczba pyta powinna by z góry ustalona, a wartoci liczb
powinny by losowane z podanego zakresu.
Do losowania liczb mona uy metod z klasy MyRandomArray.
Zadanie 22.8.
Korzystajc z klasy Roman, napisz aplikacj sprawdzajc umiejtno zapisywania
liczb w systemie rzymskim. Liczba pyta powinna by z góry ustalona, a wartoci
liczb powinny by losowane z podanego zakresu.
23. Trójmian kwadratowy

i klasa QuadratPoly
Zadanie 23.1.
Zbuduj klas QuadratPoly (ang. quadratic polynomial — trójmian kwadratowy)
umoliwiajc rozwizywanie rónych zada dotyczcych trójmianu kwadratowego
( ax 2 bx c, a z 0 ) o wspóczynnikach cakowitych. W klasie tej utwórz konstruk-
tor z trzema parametrami i metod value() z jednym parametrem, zwracajc warto
trójmianu kwadratowego dla podanego argumentu. Napisz program demonstrujcy
dziaanie konstruktora i zdefiniowanej metody.
Zadanie 23.2.
Dodaj do klasy QuadratPoly pole delta przechowujce warto wyrónika trójmianu
kwadratowego ( ' b 2 4ac ) i metod getDelta() zwracajc warto wyrónika
trójmianu. Obliczenie wyrónika powinno by zrealizowane w konstruktorze podczas
tworzenia nowego obiektu. Napisz program demonstrujcy dziaanie tej metody.
Zadanie 23.3.
Utwórz i docz do klasy QuadratPoly metod toString() zwracajc trójmian w po-
staci tekstowej, np. "2x^2-x+3". Napisz program demonstrujcy dziaanie tej metody.
Zwró uwag na sposób przedstawiania wspóczynników –1, 1 i 0 — pomi liczby -1

i 1 przed wyraeniem x^2 lub x, pozostawiajc odpowiedni znak; nie wypisuj wyrae-
nia 0x oraz wyrazu wolnego 0.

Zadanie 23.4.
Utwórz w klasie QuadratPoly metod sgnDelta() zwracajc znak wyrónika trójmia-
nu. Od znaku wyrónika zaley liczba pierwiastków trójmianu. Napisz program infor-
mujcy o liczbie rzeczywistych pierwiastków trójmianu kwadratowego.
Funkcja sgn (ac. signum — znak) zwraca –1, gdy argument jest ujemny, 1, gdy ar-
gument jest dodatni, oraz 0 dla wartoci zero.
Zadanie 23.5.
Docz do klasy QuadratPoly metody getX1() i getX2() zwracajce pierwiastki trój-
mianu kwadratowego reprezentowanego przez obiekt. Jeli trójmian nie ma pierwiast-
ków rzeczywistych, to metody mog zwraca warto NaN. Korzystajc z tych metod,
napisz program rozwizujcy równanie kwadratowe o wspóczynnikach cakowitych,
wprowadzonych z klawiatury.
Zadanie 23.6.
Wykresem trójmianu kwadratowego ax 2 bx c, a z 0 jest parabola. Charaktery-
stycznym punktem paraboli jest jej wierzchoek, czyli punkt o wspórzdnych (p, q),
gdzie p b i q ' . Docz do klasy QuadratPoly metody getP() i getQ() zwra-
2a 4a
cajce wspórzdne wierzchoka paraboli. Napisz program demonstrujcy dziaanie
tych metod.
Zadanie 23.7.
Docz do klasy QuadratPoly metod isAPositve() zwracajc warto true, gdy a jest
dodatnie, i false, gdy a jest ujemne. Napisz program wyznaczajcy zbiór wartoci dla
podanego trójmianu kwadratowego.
Jeli a > 0, to zbiorem wartoci trójmianu ax bx c jest przedzia q, f , a dla

2
a < 0 — przedzia f, q .
Zadanie 23.8.
Napisz program, który dla danego trójmianu kwadratowego okreli jego warto ekstre-
maln (minimum lub maksimum). Dane trójmianu uytkownik wprowadzi z klawiatury.
Zadanie 23.9.
Docz do klasy QuadratPoly metod getVertex() (ang. vertex — wierzchoek), która
bdzie zwraca wspórzdne wierzchoka paraboli bdcej wykresem trójmianu re-
prezentowanego przez obiekt. Wynik powinien by podany w postaci acucha zna-
ków. Napisz program demonstrujcy dziaanie tej metody.

Zadanie 23.10.
Docz do klasy QuadratPoly metod getCodomain() (ang. codomain — przeciwdzie-
dzina funkcji), która bdzie zwraca zbiór wartoci trójmianu (przedzia liczbowy) zapi-
sany w postaci acucha znaków. Napisz program demonstrujcy dziaanie tej metody.
Zadanie 23.11.
Napisz program sporzdzajcy opis przebiegu zmiennoci funkcji kwadratowej
f ( x ) ax 2 bx c, a z 0 .
Opis zredaguj w punktach. Umie w opisie dziedzin funkcji, zbiór wartoci, mo-
notoniczno , ekstremum, miejsca zerowe i krótkie objanienie wykresu.
Zadanie 23.12.
Napisz program rozwizujcy nierówno kwadratow ax 2 bx c ! 0, a z 0 .
Zadanie 23.13.
Napisz program rozwizujcy nierówno kwadratow ax 2 bx c t 0, a z 0 .
Zadanie 23.14.
Docz do klasy QuadratPoly metod mult() z parametrem bdcym liczb cakowit
rón od zera, która zwraca nowy obiekt, iloczyn tej liczby i trójmianu reprezentowa-
nego przez obiekt wywoujcy t metod. Napisz program demonstrujcy jej dziaanie.
Zadanie 23.15.
Docz do klasy QuadratPoly metod solutionOfQE() (ang. solution — rozwizanie),
która bdzie zwraca rozwizanie równania kwadratowego w postaci zbioru pierwiast-
ków (acuch znaków), np. {–2, 0.5}, {–3} lub {} (odpowiednio: dwa róne pierwiast-
ki, pierwiastek dwukrotny lub brak pierwiastków rzeczywistych — zbiór pusty). Na-
pisz program demonstrujcy dziaanie tej metody.
W zestawie znaków dla konsoli nie znajdziemy symbolu zbioru pustego (), wic
proponujemy zastpienie go pust par nawiasów klamrowych {}.
Zadanie 23.16.
Docz do klasy QuadratPoly dwie prywatne metody: solutionQIe1() i solutionQIe2(),
które bd zwraca zbiór rozwiza nierównoci kwadratowej ax 2 bx c ! 0, a z 0
(pierwsza metoda) i ax 2 bx c t 0, a z 0 (druga metoda). Wynik powinien by
podany w postaci acucha znaków. Korzystajc z tych metod, zbuduj publiczn me-
tod solutionQIe() (ang. quadratic inequality — nierówno kwadratowa) z jednym

parametrem (typu String) o postaci "<", "<=", ">" lub ">=", okrelajcym typ nierów-
noci. Napisz program demonstrujcy rozwizywanie nierównoci kwadratowych.
Wykorzystaj zbudowane metody prywatne i fakt, e nierówno ax bx c 0

2
( ax bx c d 0 ) ax 2 bx c ! 0
2
jest równowana nierównoci
( ax bx c t 0 ).
2
Zadanie 23.17.
Napisz program rozwizujcy równanie dwukwadratowe o wspóczynnikach cakowi-
tych ( ax 4 bx 2 c 0, a z 0 ).
Zadanie 23.18.
Trójmiany kwadratowe mona dodawa lub odejmowa. Wynik nie zawsze jednak
bdzie trójmianem kwadratowym. Docz do klasy metody add() i sub(), które bd
zwraca nowy obiekt QuadratPoly, odpowiednio sum i rónic obiektu wywoujce-
go metod i obiektu przekazanego jako parametr.
Zadanie 23.19.
Zbuduj klas FloatQP lub DoubleQP (ang. quadratic polynomial — trójmian kwadra-
towy), która bdzie umoliwia rozwizywanie rónych zada dotyczcych trójmianu
kwadratowego ( ax 2 bx c, a z 0 ) o wspóczynnikach zmiennoprzecinkowych (typu
float lub double). Jeli wynik nie jest obiektem klasy, to zgo wyjtek. Do klasy dodaj
metod div() zwracajc nowy obiekt, wynik dzielenia trójmianu przez liczb rón
od zera. Napisz program demonstrujcy dziaanie konstruktora i wybranych metod.
24. Liczby zespolone

— budujemy klas Complex
Brak rozwizania równania kwadratowego x 2 1 w zbiorze liczb rzeczywistych do-
prowadzi do odkrycia jednostki urojonej i — takiej, e i 2 1 — oraz liczb urojonych
(bdcych iloczynami liczby rzeczywistej i jednostki urojonej — ai). W konsekwencji
doprowadzio to do powstania teorii liczb zespolonych.
Liczb zespolon moemy zapisywa w postaci pary liczb rzeczywistych (a, b), gdzie
a oznacza cz rzeczywist liczby zespolonej, b — cz urojon. T par liczb moemy
interpretowa jako wspórzdne punktu na paszczy nie (tzw. paszczyzna zespolona).
Inn moliwoci jest zapis a+bi, czyli posta kanoniczna liczby zespolonej.

Zadanie 24.1.
Zbuduj klas Complex, której obiekty bd reprezentoway liczby zespolone. Klasa po-
winna posiada dwa prywatne pola typu double, co najmniej jeden konstruktor z dwoma
parametrami (typu double), metody ustawiajce warto czci rzeczywistej i urojonej
oraz moliwo przedstawienia liczby w postaci algebraicznej (kanonicznej). Napisz
aplikacj pokazujc dziaanie konstruktorów metod tej klasy.
Prywatne pola klasy Complex oznaczmy identyfikatorami re (ang. real — cz rze-
czywista liczby zespolonej) i im (ang. imaginary — cz urojona). Metody setRe
(double x) i setIm(double y) powinny umoliwi zmian wartoci liczby zespolo-
nej reprezentowanej przez obiekt, natomiast metoda toString() zwróci acuch
znaków reprezentujcy posta kanoniczn liczby.
Zadanie 24.2.
Napisz aplikacj rozwizujc równanie kwadratowe o wspóczynnikach rzeczywi-
stych w zbiorze liczb zespolonych.
Algorytm rozwizywania równania jest taki sam jak w zbiorze liczb rzeczywistych.
Jedynie w przypadku, gdy wyrónik jest ujemny ( ' 0 ), rozwizaniem równania
bdzie para liczb zespolonych, poniewa ' 'i .
Zadanie 24.3.
Docz do klasy Complex metody zwracajce sum (add() — ang. addition) i rónic
(sub() — ang. subtraction) wartoci zespolonej reprezentowanej przez obiekt i warto-
ci podanej jako parametr. Napisz aplikacj pokazujc dziaanie tych metod.
Zadanie 24.4.
Docz do klasy Complex metody zwracajce liczb zespolon przeciwn (opp() —
ang. opposite lub additive inverse), sprzon (conj() — ang. conjugate) i odwrotn
(rec() — ang. reciprocal lub multiplicative inverse) do wartoci zespolonej reprezen-
towanej przez obiekt. Napisz aplikacj pokazujc dziaanie tych metod.
Zadanie 24.5.
Docz do klasy Complex metody zwracajce iloczyn (mult() — ang. multiplication)
i iloraz (div() — ang. division) wartoci zespolonej reprezentowanej przez obiekt
i wartoci podanej jako parametr. Napisz aplikacj pokazujc dziaanie tych metod.
Zadanie 24.6.
Dodaj do klasy Complex stae ZERO (zero), ONE (jeden), I (jednostka urojona i — ang.
imaginary unit). Napisz aplikacj pokazujc znaczenie tych staych.

Staa ZERO jest elementem neutralnym dla dodawania, a staa ONE stanowi ele-
ment neutralny dla mnoenia. Korzystajc ze staej I, moemy pokaza potgi jed-
nostki urojonej.
Zadanie 24.7.
Docz do klasy Complex metody zwracajce bezwzgldn warto (modu) liczby ze-
spolonej (abs() — ang. absolute value) i argument gówny liczby zespolonej (arg())
reprezentowanej przez obiekt. Napisz aplikacj pokazujc dziaanie tych metod.
Zadanie 24.8.
Docz do klasy Complex metody zwracajce cz rzeczywist (getRe()) i cz uro-
jon (getIm()) liczby zespolonej reprezentowanej przez obiekt. Napisz aplikacj po-
kazujc dziaanie tych metod.
Zadanie 24.9.
Dodaj do klasy Complex bezparametrowe metody print() i println() wywietlajce
posta kanoniczn liczby zespolonej w konsoli. Zbuduj te metody równie z jednym
parametrem typu String. Podany acuch znaków powinien poprzedza wywietlan
liczb zespolon. Napisz aplikacj pokazujc dziaanie tych metod.
Zaproponowane metody skróc nam zapis wielu rozwiza zada. Rónica w dzia-
aniu metody println() i print() jest oczywista i w naszej implementacji nie po-
winna odbiega od przyjtego standardu.
Zadanie 24.10.
Docz do klasy Complex konstruktor kopiujcy oraz metod umoliwiajc porów-
nywanie obiektu wywoujcego t metod z innym obiektem podanym jako parametr.
Napisz aplikacj pokazujc porównywanie obiektów.
Zadanie 24.11.
Docz do klasy Complex konstruktor tworzcy obiekt na podstawie acucha znaków
przedstawiajcego liczb zespolon w postaci "–3.4+2.75i". Napisz aplikacj poka-
zujc dziaanie tego konstruktora.
Konstruktor powinien poprawnie przetwarza acuchy o postaci: "1", "–2.5", "+3.5",

"i", "+i", "–i", "2+3i", "–2.3+3i", "2–3i", "–2.3+3i", "+2–3.7i", "+2+3.7i",
"1+i", "2.1–i". Aby zbytnio nie komplikowa kodu, zrezygnujemy z zapisywania
liczb w notacji naukowej.
Zadanie 24.12.
Zbuduj w klasie Complex metod statyczn parseComplex() zamieniajc acuch zna-
ków na liczb zespolon. Napisz aplikacj pokazujc dziaanie tej metody.

Zastosuj konstruktor zbudowany w rozwizaniu zadania 24.11.
Zadanie 24.13.
Utwórz poza klas Complex funkcj power() obliczajc potg o wykadniku cakowi-
tym dla dowolnej liczby zespolonej. Napisz aplikacj pokazujc dziaanie tej funkcji.
Zadanie 24.14.
Dodaj opracowan w zadaniu 24.13 funkcj power() do klasy Complex jako metod
statyczn oraz niestatyczn. Napisz aplikacj pokazujc dziaanie metod power().
W metodzie statycznej podstawa potgi przekazywana jest jako parametr wywoania,

natomiast w metodzie niestatycznej podstaw potgi stanie si warto obiektu
wywoujcego t metod (wykorzystaj sowo kluczowe this).
Zadanie 24.15.
Docz do klasy Complex metody obliczajce kwadrat liczby zespolonej (sqr()) i pier-
wiastek kwadratowy (sqrt()) z liczby zespolonej. Napisz aplikacj pokazujc dzia-
anie tych metod.
W zbiorze liczb zespolonych okrelamy dwa pierwiastki drugiego stopnia. S one

liczbami przeciwnymi. Podczas rozwizywania zada naley o tym pamita . Mo-
na utworzy metod nextSqrt(), wyznaczajc drugi pierwiastek z liczby zespolo-
nej, lub poda w metodzie sqrt()parametr, wskazujcy, który z tych pierwiastków
chcemy obliczy .
Zadanie 24.16.
Docz do klasy Complex metody printf() i printlnf(), które bd wywietla w kon-
soli liczb zespolon z okrelon precyzj domyln (6 miejsc po przecinku). Napisz
program demonstrujcy dziaanie tych metod.
Zob. rozwizanie zadania 24.9.
Zadanie 24.17.
Napisz program rozwizujcy w zbiorze liczb zespolonych równanie kwadratowe
o wspóczynnikach zespolonych, np.: 1 2i z 2 iz 1 0 .
Zadanie 24.18.
Docz do klasy Complex cztery metody statyczne (sum(), diff(), prod() i quot()),
które bd realizowa cztery podstawowe dziaania (dodawanie, odejmowanie, mno-
enie i dzielenie) w zbiorze liczb zespolonych.

Liczb zespolon z x yi moemy przeksztaci na posta z z (sin M i cos M )

nazywan postaci trygonometryczn liczby zespolonej ( z — modu, M — argument
liczby z).
Posta trygonometryczn liczby zespolonej moemy skojarzy z biegunowym uka-

dem wspórzdnych — liczb zespolon moemy przedstawia jako par r , M , gdzie
r jest (promieniem) odlegoci punktu P(x, y) od pocztku ukadu wspórzdnych,
a M jest ktem pomidzy promieniem i osi X ukadu wspórzdnych.
Zadanie 24.19.
Utwórz klas PolarComplex, której obiekty bd reprezentoway liczby zespolone po-
dane we wspórzdnych biegunowych (ang. polar coordinates). Zbuduj podstawowe
konstruktory klasy PolarComplex, metod zamieniajc obiekt klasy PolarComplex
na obiekt Complex i metod toString() zamieniajc obiekt na acuch znaków, np.
"[r=1,500000; fi=1,000000]". Napisz program demonstrujcy dziaanie tych kon-
struktorów i metod.
Podany cig znaków "[r=1,500000; fi=1,000000]" jest propozycj, z któr Czy-

telnik niekoniecznie musi si zgadza . Nie ma w tym przypadku standardu zapi-
su liczb podobnego do postaci kanonicznej liczby zespolonej i atwego do za-
pisania w postaci acucha znaków. Posta trygonometryczna liczby zespolonej
z r sin M i cos M i posta wykadnicza z re iM wykorzystuj elementy pary
r , M , ale do tego celu niezbyt si nadaj. Pozostamy zatem przy zaproponowa-
nej w zadaniu postaci acucha.
Zadanie 24.20.
Docz do klasy PolarComplex konstruktor kopiujcy i konstruktor z parametrem typu
Complex. Napisz program demonstrujcy dziaanie tych konstruktorów.
Zadanie 24.21.
Docz do klasy Complex konstruktor z parametrem typu PolarComplex i metod toPo-
larComplex(), która bdzie zwraca obiekt klasy PolarComplex odpowiadajcy obiekto-
wi Complex. Napisz program demonstrujcy dziaanie tego konstruktora i tej metody.
Zadanie 24.22.
Docz do klasy PolarComplex metod mult(), która bdzie zwraca iloczyn liczby ze-
spolonej reprezentowanej przez obiekt i liczby przekazanej jako parametr. Napisz pro-
gram demonstrujcy dziaanie tej metody.
Zadanie 24.23.
Docz do klasy PolarComplex metod div(), która bdzie zwraca iloraz liczby zespo-
lonej reprezentowanej przez obiekt i liczby przekazanej jako parametr. Napisz program
demonstrujcy dziaanie tej metody.

Zadanie 24.24.
Docz do klasy PolarComplex metody sqr() i cube(), które bd zwraca kwadrat
i szecian liczby zespolonej reprezentowanej przez obiekt. Napisz program demonstru-
jcy dziaanie tych metod.
Zadanie 24.25.
Docz do klasy PolarComplex metod power() z jednym parametrem n typu cakowi-
tego (int), która bdzie zwraca potg o wykadniku n liczby zespolonej reprezento-
wanej przez obiekt. Napisz program demonstrujcy dziaanie tej metody.
Zadanie 24.26.
Liczba zespolona ma dwa pierwiastki kwadratowe. Docz do klasy PolarComplex me-
tod sqrt() z jednym parametrem k typu int, która bdzie zwraca obiekt PolarCom-
plex wskazany przez parametr k — pierwiastek kwadratowy z liczby zespolonej. Na-
Wyznacz reszt z dzielenia k przez 2 (k%2) — reszta 0 lub 1 wskae numer pier-
wiastka.
Zadanie 24.27.
Liczba zespolona ma trzy pierwiastki szecienne (trzeciego stopnia). Docz do klasy
PolarComplex metod cbrt() z jednym parametrem k typu int, która bdzie zwraca
obiekt PolarComplex wskazany przez parametr k, pierwiastek trzeciego stopnia z licz-
by zespolonej. Napisz program demonstrujcy dziaanie tej metody.
Wyznacz reszt z dzielenia k przez 3 (k%3) — reszta 0, 1 lub 2 wskae numer pier-
wiastka.
Zadanie 24.28.
Docz do klasy PolarComplex bezparametrowe metody sqrt() i cbrt(), które bd
zwraca pierwiastki kwadratowe i szecienne z liczby reprezentowanej przez obiekt
w postaci tablicy obiektów klasy Complex. Napisz program demonstrujcy dziaanie
tych metod.
Zadanie 24.29.
Napisz program rozwizujcy w zbiorze liczb zespolonych równanie o wspóczynni-
kach rzeczywistych:
a) az c 0, a z 0 ,
2
b) z a
3
0.

Zadanie 24.30.
Napisz program rozwizujcy w zbiorze liczb zespolonych równanie o wspóczynni-
kach zespolonych:
a) az c 0 , a z 0 0i ,
2
b) z a
3
0.
Zadanie 24.31.
Liczba zespolona ma n pierwiastków n-tego stopnia. Docz do klasy PolarComplex
metod root() z dwoma parametrami n i k typu int, która bdzie zwraca obiekt Po-
larComplex wskazany przez parametr k — pierwiastek n-tego stopnia z liczby zespo-
lonej. Napisz program demonstrujcy dziaanie tej metody.
Zadanie 24.32.
Docz do klasy PolarComplex metod root() z jednym parametrem n okrelajcym
stopie pierwiastka, która bdzie zwraca tablic obiektów klasy Complex z pierwiast-
kami n-tego stopnia z liczby zespolonej reprezentowanej przez obiekt (wywoujcy
metod). Napisz program demonstrujcy dziaanie tej metody.
Zadanie 24.33.
Napisz program wyznaczajcy dla liczby naturalnej n podanej przez uytkownika z kla-
wiatury wszystkie pierwiastki równania:
a) z n 1 0,
b) z i
n
0,
c) z
2n
iz n 1 0 .


Rozdzia 4.
Czwarty krok — pliki,
tablice i macierze
25. Operacje na plikach tekstowych
Zadanie 25.1.
Korzystajc z obiektów i metod klasy FileWriter, napisz program zapisujcy do pliku
tekstowego tekst.txt jeden wiersz tekstu: Programowanie obiektowe.
Zadanie 25.2.
Plik tekstowy tekst.txt zawiera jeden wiersz tekstu: Programowanie obiektowe. Ko-
rzystajc z obiektu i metod klasy FileWriter, napisz program dopisujcy do tego pli-
ku w pierwszym wierszu tekst: w jzyku Java, a w kolejnym wierszu tekst: jest bardzo
interesujce.
W systemie Windows koniec wiersza w pliku tekstowym skada si z dwóch znaków
CR (ang. carriage return, warto ASCII 13, znak '\r') i LF (ang. line feed warto
ASCII 10, znak '\n'). W systemach UNIX i Linux kocem wiersza jest LF, a w sys-
temie Mac OS — znak CR.
Zadanie 25.3.
Korzystajc z obiektu i metod klasy FileWriter, napisz program obliczajcy i zapi-
sujcy w pliku silnia.txt wartoci n! (n silnia) dla n = 1, 2, …, 12. Kady wynik zapisz
w odrbnym wierszu, w postaci 12! = 479001600.
Przypomnijmy znaczenie symbolu n!: 1! = 1, 2! = 1!·2 = 1·2, 3! = 2!·3 = 1·2·3 itd.

W tym zadaniu i zadaniach podobnych starajmy si, aby plik wyjciowy nie zawie-
ra na kocu pustego wiersza (jeli obecno tego ostatniego wiersza nie jest za-
mierzona). Taki wiersz moe nam sprawi róne niespodzianki, gdy plik bdzie od-
czytywany.
Zadanie 25.4.
Napisz program zapisujcy w pliku pierwiastki.txt wartoci pierwiastków kwadrato-
wych i szeciennych dla liczb naturalnych od 2 do 15. Kady wiersz pliku powinien
zawiera trzy liczby oddzielone znakami tabulatora — liczb naturaln, pierwiastek
kwadratowy z tej liczby i pierwiastek szecienny. Pierwiastki podaj z precyzj do 8
miejsc po przecinku.
Do formatowania wyników uyj metody format() z klasy String.
Zadanie 25.5.
Napisz program zapisujcy w pliku tekstowym sto.txt sto liczb cakowitych wyloso-
wanych z zakresu od 1 do 20. Liczby w pliku powinny by oddzielone odstpami.
Zadanie 25.6.
Napisz program zapisujcy w pliku tekstowym dane.txt 50 par liczb. Kada para liczb
powinna by umieszczona w odrbnym wierszu. Pierwsza liczba w parze powinna
by rzeczywista, dodatnia i nie wiksza od 10 oraz podana z dokadnoci do dwóch
miejsc po przecinku, druga liczba powinna by cakowita i ma nalee do przedziau
2, 8 . Liczby w wierszu oddzielamy odstpem.
Po rozwizaniu zada 25.1 – 25.6 bdziemy mieli w biecym folderze pi plików:
tekst.txt, silnia.txt, pierwiastki.txt, sto.txt i dane.txt. Zawarto tych plików bdziemy
odczytywali w kolejnych zadaniach.
Zadanie 25.7.
Korzystajc z obiektu i metod klasy FileReader, napisz program odczytujcy zawar-
to pliku tekstowego i wywietlajcy jego zawarto w konsoli.
Bezparametrowa metoda read() z klasy FileReader odczytuje z pliku jeden znak

i zwraca jego kod, liczb typu int z zakresu od 0 do 65 535 lub liczb –1, gdy nie
mona odczyta znaku. Metoda ready() zwraca warto logiczn true, gdy z pliku
mona odczyta kolejny znak, i false w przeciwnym wypadku.

Rozdzia 4. i Czwarty krok — pliki, tablice i macierze 79
Zadanie 25.8.
Korzystajc z obiektu i metod klasy FileReader, utwórz metod (readLine()) odczy-
tujc wiersz pliku tekstowego. Napisz program odczytujcy i wywietlajcy w kon-
soli wszystkie wiersze pliku tekstowego.
Klasa FileReader nie zawiera metody readLine(), wic musisz j sam zbudowa .
Plik tekstowy otwórz przed wywoaniem metody, obiekt (klasy FileReader) skojarzo-
ny z plikiem przeka jako parametr do metody readLine(), która przeczytany z pli-
ku wiersz tekstu zwróci w postaci acucha znaków.
Zadanie 25.9.
Napisz program wywietlajcy w konsoli kod ródowy programu w jzyku Java wraz
z numerami linii. Nazw pliku (bez rozszerzenia) uytkownik powinien podawa z kla-
wiatury. Jeli w okrelonej lokalizacji nie ma wskazanego pliku, to program powinien
wywietli odpowiedni komunikat.
Do wprowadzenia nazwy pliku z konsoli oraz do odczytania wierszy tekstu z pliku

wykorzystaj obiekty klasy BufferedReader i metod readLine() z tej klasy. Obec-
no pliku moesz sprawdzi , stosujc metod exists() z klasy File.
Zadanie 25.10.
Napisz program zapisujcy do pliku kod ródowy programu w jzyku Java wraz z nu-
merami linii. Nazw pliku (bez rozszerzenia) uytkownik powinien podawa z kla-
wiatury. Jeli w okrelonej lokalizacji nie ma wskazanego pliku, to program powinien
wywietli odpowiedni komunikat. Nazwa pliku wyjciowego powinna by taka jak
nazwa pliku ródowego, rozszerzenie java zamienimy na rozszerzenie txt.
Do wprowadzenia nazwy pliku z konsoli oraz do odczytania wierszy tekstu z pliku

wykorzystaj obiekty klasy Scanner. Do zapisania pliku wyjciowego uyj metod kla-
sy PrintWriter.
Zadanie 25.11.
W pliku tekstowym wpisany jest cig liczb cakowitych oddzielonych odstpami. Na-
pisz program, który odczyta i wywietli w konsoli liczby z pliku oraz obliczy ich sum.
Do testów moesz uy pliku sto.txt (rozwizanie zadania 25.5). Nie wykorzystuj
jednak faktu, e znasz ilo liczb zapisanych w tym pliku.

Zadanie 25.12.
W pliku tekstowym wpisany jest cig liczb cakowitych oddzielonych odstpami. Na-
pisz program, który znajdzie najmniejsz liczb w tym pliku oraz obliczy, ile razy ta
liczba w tym pliku wystpuje.
Do testów moesz uy pliku sto.txt (rozwizanie zadania 25.5). Nie wykorzystuj
jednak faktu, e znasz ilo liczb zapisanych w pliku.
Zadanie 25.13.
W pliku tekstowym zapisane s w kolejnych wierszach pary liczb — liczba zmienno-
przecinkowa i liczba cakowita. Napisz program, który odczytuje pary liczb z pliku,
oblicza iloczyn kadej pary i sumuje iloczyny. Wynik oblicze naley wypisa w kon-
soli i zapisa w ostatnim wierszu pliku z danymi.
Do testów moesz uy pliku dane.txt (rozwizanie zadania 25.6).
26. Tablice jednowymiarowe

i wielomiany
Jednym z zastosowa tablic jednowymiarowych moe by przechowywanie wspó-
czynników wielomianu.
Wielomian n-tego stopnia jednej zmiennej w( x) a n x n a n 1 x n 1 ... a1 x a 0 ma n+1

wspóczynników, które moemy zapisa w tablicy double[] a = {a0, a1, ..., an};.
Zadanie 26.1.
Napisz program obliczajcy wartoci wielomianu. Stopie wielomianu, wspóczynni-
ki i kolejne wartoci argumentu uytkownik bdzie wprowadza z klawiatury. Podanie
argumentu x = 0 bdzie sygnaem do zakoczenia pracy programu.
Do obliczenia wartoci wielomianu wykorzystaj schemat Hornera.
Zadanie 26.2.
Napisz program, który obliczy i zapisze w pliku tekstowym (wielomian.txt) tablic
wartoci wielomianu w( x) 2 x 3 5 x 2 x 3 w przedziale 2, 3 z krokiem h = 0,125.
Plik powinien zawiera trzy wiersze z informacjami o rozwizywanym zadaniu, we-
dug schematu: stopie wielomianu (pierwszy wiersz), wspóczynniki wielomianu
oddzielone odstpami w drugim wierszu (zaczynajc od wyrazu wolnego) i krace

przedziau oraz krok w trzecim wierszu. W kolejnych wierszach umiecimy pary liczb
(argument i warto) oddzielone odstpem.
Zadanie 26.3.
Napisz program, który obliczy i wywietli w konsoli sum dwóch wielomianów.
Skorzystaj z metod dostpnych w klasie Arrays. Przyjmij, e wywietlajc wynik

lub prezentujc dane, wielomian w( x) a n x n a n 1 x n 1 ... a1 x a 0 zapiszemy
w postaci acucha znaków "w = [a0, a1, ... an]", gdzie a0, a1, …, an s licz-
bami wyraajcymi wspóczynniki wielomianu.
Zadanie 26.4.
Napisz program, który obliczy i wywietli w konsoli rónic dwóch wielomianów.
Zadanie 26.5.
Napisz program, który obliczy i wywietli w konsoli iloczyn wielomianu przez liczb.
Zadanie 26.6.
Napisz program, który obliczy i wywietli w konsoli iloczyn dwóch wielomianów.
Zadanie 26.7.
Napisz program, który obliczy i wywietli w konsoli pochodn wielomianu.
Zadanie 26.8.
Napisz program, który obliczy i wywietli w konsoli cak nieoznaczon (funkcj pier-
wotn) wielomianu.
Zadanie 26.9.
Utwórz klas Polynomial (plik Polynomial.java) umoliwiajc wykonywanie pod-
stawowych dziaa na wielomianach zapisanych w postaci tablicy wspóczynników.
Napisz aplikacj prezentujc moliwoci utworzonych metod i konstruktorów.
Zadanie 26.10.
Napisz program wykonujcy dzielenie wielomianu
w( x) a n x n a n 1 x n 1 ... a1 x a 0
przez dwumian o postaci (x–c).

Zadanie 26.11.
Docz do klasy Polynomial dwie metody — division() i remainder() — obliczajce
iloraz i reszt z dzielenia wielomianu reprezentowanego przez obiekt wywoujcy me-
tod przez dwumian (x-c), gdzie liczba c typu double jest parametrem wywoania me-
tody. Napisz program demonstrujcy dziaanie tych metod.
Zadanie 26.12.
b
Napisz program obliczajcy cak oznaczon s ³ w( x)dx dla wielomianu

a
w( x) a n x n a n 1 x n 1 ... a1 x a 0
Wszystkie potrzebne dane uytkownik powinien wprowadzi z klawiatury — najpierw
dane wielomianu (stopie i wspóczynniki), a pó niej granice cakowania.
Do wyznaczenia funkcji pierwotnej uyj metody (integral()) opracowanej w rozwiza-

b
niach zada 26.8 i 26.9, a nastpnie skorzystaj ze wzoru

³ w( x)dx
a
F (b) F (a) .
Zadanie 26.13.
Majc dane wszystkie pierwiastki rzeczywiste wielomianu ( x1 , x2 , ..., xn ), napisz pro-
gram wyznaczajcy wspóczynniki wielomianu.
27. Obliczenia statystyczne

Zadania 27.1 – 27.19 wykonamy dla n-elementowej próbki zapisanej w tablicy:
double[] x = {1.35, 2.45, 2.05, 1.20, 2.15, 1.70, 1.45, 1.95, 2.00, 1.65, 1.65,
2.05, 1.75, 1.25, 2.25, 1.40};
Czytelnik moe samodzielnie zmieni zestaw danych lub sposób ich pobierania przez
program — wprowadzanie danych z klawiatury lub odczytywanie z pliku. Naley
zwróci uwag na rozbienoci pomidzy zakresem indeksów. W tablicach w jzyku
Java indeksowanie rozpoczynamy od 0 i koczymy na indeksie o 1 mniejszym od
rozmiaru tablicy, natomiast we wzorach statystyki opisowej indeksy wartoci próbki
bd w granicach od 1 do n.
W zadaniach bardzo czsto bdziemy mieli do czynienia z obliczaniem sumy cigu

n
liczb x1, x2, …, xn (oznaczanej symbolem ¦ x ) zapisanego w tablicy x[0], x[1], …,

i 1
i
x[n–1]. Zrealizujemy to przy uyciu instrukcji ptli:

double suma = 0;
for(double xi: x)
suma += xi;

lub:
double suma = 0;
for(int i = 0; i < n; ++i))
suma += x[i];
Zadanie 27.1.
Dla podanej próbki n-elementowej x1, …, xn wyznacz najmniejsz i najwiksz war-
to w cigu oraz rozstp badanej cechy.
Rozstpem badanej cechy jest rónica pomidzy wartoci maksymaln i minimaln

R xmax xmin .
Zadanie 27.2.
Dla podanej próbki n-elementowej x1, …, xn wyznacz redni arytmetyczn.
1 n
redni arytmetyczn liczb x1, …, xn nazywamy liczb x ¦ xi
ni1
.
Zadanie 27.3.
Dla podanej próbki n-elementowej x1, …, xn wyznacz redni geometryczn.
n
redni geometryczn dodatnich liczb x1, …, xn nazywamy liczb g n
x
i 1
i .
1 n
Jeeli wszystkie xi > 0, to log g ¦ log xi
ni1
.
Zadanie 27.4.
Dla podanej próbki n-elementowej x1, …, xn wyznacz redni harmoniczn.
redni harmoniczn rónych od zera liczb x1, …, xn nazywamy liczb

1
§1 n 1 · n
1
h ¨¨ ¦ ¸¸ , gdy ¦ xi
z 0 (odwrotno redniej arytmetycznej
© n i 1 xi ¹ i 1
odwrotnoci tych liczb).
Zadanie 27.5.
Dla podanej próbki n-elementowej x1, …, xn wyznacz redni potgow rzdu r. Obli-
czenia wykonaj dla r = 2 i r = 3.

redni potgow rzdu r dodatnich liczb x1, …, xn nazywamy liczb

n
¦x
1
p (r ) r
i
r
. Dla r 1 otrzymujemy redni harmoniczn ( p ( 1) h ),
n i 1
a dla r 1 redni arytmetyczn ( p (1) x ).
Zadanie 27.6.
Dla podanej próbki n-elementowej x1, …, xn wyznacz median.
Posortuj tablic z danymi i wybierz element rodkowy, gdy n jest nieparzyste, lub
oblicz redni arytmetyczn dwóch rodkowych liczb, gdy n jest parzyste:
x n1 , gdy n jest nieparzyste

°° 2
me ®1 § ·
° ¨¨ x n x n ¸¸, gdy n jest parzyste
°¯ 2 © 2 2 ¹
1
Naley pamita o przesuniciu indeksu wynikajcego z rónicy pomidzy indeksa-

mi we wzorach a indeksami w tablicach.
Zadanie 27.7.
Wyznacz warto modaln (dominant) n-elementowej próbki x1, …, xn.
Wartoci modaln (dominant, mod) próbki x1, …, xn o powtarzajcych si war-

tociach nazywamy najczciej powtarzajc si warto , o ile taka istnieje. Po-
nadto warto ta nie moe by wartoci minimaln lub maksymaln.
Zadanie 27.8.
Oblicz wariancj n-elementowej próbki x1, …, xn. Wykorzystaj wszystkie niej poda-
ne wzory i porównaj uzyskane wyniki.
Wariancj s2 (dyspersj) próbki x1, …, xn nazywamy redni arytmetyczn kwadratów

n
¦ x x
1 2
odchyle wartoci xi od redniej arytmetycznej x próbki: s 2 i
.
n i 1
n
¦x
1
Mona zastosowa wzory równowane s 2 2
i
x 2 lub
n i 1
n
¦ x a x a , gdzie a jest dowoln sta.

2 1 2 2
s i
n i 1

Zadanie 27.9.
Oblicz odchylenie standardowe n-elementowej próbki x1, …, xn.
Odchylenie standardowe s próbki x1, …, xn jest równe pierwiastkowi kwadratowe-

mu z wariancji s2 (zob. zadanie 27.8).
Zadanie 27.10.
Oblicz odchylenie przecitne d próbki x1, …, xn od staej a. Obliczenia wykonaj dla a = 2.
Odchyleniem przecitnym d od staej a próbki x1, …, xn nazywamy redni arytme-

tyczn wartoci bezwzgldnych odchyle poszczególnych wartoci xi od staej a:
n
¦ x a .
1
d i
n i 1
Zadanie 27.11.
Oblicz odchylenie przecitne d1 próbki x1, …, xn od wartoci redniej x .
Zadanie 27.12.
Oblicz odchylenie przecitne d2 próbki x1, …, xn od mediany me .
Zadanie 27.13.
Wyznacz kwartyl dolny Q1 i kwartyl górny Q3 próbki x1, …, xn. Oblicz odchylenie
wiartkowe Q.
Wartoci uporzdkowanej próbki dzielimy na dwie grupy: wartoci mniejsze od me-

diany i median oraz median i wartoci wiksze od mediany. Kwartylem dolnym
(Q1) jest mediana pierwszej grupy, a górnym (Q3) mediana drugiej grupy. Odchyle-
Q3 Q1
nie wiartkowe Q obliczamy ze wzoru Q .
2
Zadanie 27.14.
Oblicz moment zwyky ml rzdu l próbki x1, …, xn. Obliczenia wykonaj dla l = 2, 3 i 4.
¦x ,
1
Wzór ml l
i
lN .
n i 1

Zadanie 27.15.
Oblicz moment centralny Ml rzdu l próbki x1, …, xn. Obliczenia wykonaj dla l = 2, 3 i 4.
¦ (x x) ,
1
Wzór M l i
l
l N . Z wasnoci redniej arytmetycznej wynika, e
n i 1
M1 = 0, natomiast M2 jest wariancj.
Zadanie 27.16.
Oblicz moment absolutny zwyky al rzdu l próbki x1, …, xn. Obliczenia wykonaj dla
l = 2, 3 i 4.
¦| x | ,
1
Wzór al i
l
lN .
n i 1
Zadanie 27.17.
Oblicz moment absolutny centralny bl rzdu l próbki x1, …, xn. Obliczenia wykonaj
dla l = 2, 3 i 4.
¦| x x | ,
1
Wzór bl i
l
l N . Absolutny moment centralny rzdu pierwszego
n i 1
jest odchyleniem przecitnym od redniej arytmetycznej.
Zadanie 27.18.
Oblicz wspóczynnik zmiennoci v próbki x1, …, xn.
s
Wzór v 100% , gdzie s jest odchyleniem standardowym, a x redni arytme-
x
tyczn próbki.
Zadanie 27.19.
Oblicz wspóczynnik nierównomiernoci H próbki x1, …, xn.
d1
Wzór H 100% , gdzie d1 jest odchyleniem przecitnym od redniej arytme-
x
tycznej x .

W zadaniach 27.1 – 27.19 przedstawiono podstawowe wzory zwizane z obliczenia-

mi statystyki opisowej dla pojedynczej próbki, zwykle nieprzekraczajcej 30 elemen-
tów. Czytelnik moe samodzielnie na podstawie rozwiza tych zada konstruowa
programy majce na celu rozwizywanie problemów z zakresu statystyki.
Zadanie 27.20.
Na podstawie problemów zawartych w zadaniach 27.1 – 27.19 utwórz klas Stat za-
wierajc metody statyczne do oblicze statystycznych. Napisz aplikacj konsolow
pokazujc dziaanie wybranych metod z klasy Stat. Sporzd dokumentacj tej klasy.
Zadanie 27.21.
Na podstawie problemów zawartych w zadaniach 27.1 – 27.19 utwórz klas Statpr
umoliwiajc utworzenie obiektu (próbki) zawierajcego metody do rozwizywania
tych problemów. Napisz aplikacj konsolow pokazujc dziaanie wybranych metod
z klasy Statpr. Sporzd dokumentacj tej klasy.
28. Tablice wielowymiarowe i macierze

Zadanie 28.1.
Utwórz dwuwymiarow tablic liczb cakowitych o trzech wierszach. W pierwszym
wierszu tablicy umie liczby od 1 do 10, w drugim kwadraty tych liczb, a w trzecim
szeciany liczb z pierwszego wiersza. Napisz program tworzcy i wywietlajcy t
tablic w konsoli.
Zadanie 28.2.
W tablicy dwuwymiarowej nie wszystkie wiersze musz mie ten sam rozmiar. Napisz
program, który utworzy tablic liczb cakowitych o dziesiciu wierszach. Wypenij
tablic kolejnymi liczbami naturalnymi, zaczynajc od liczby 1. W pierwszym wier-
szu umie jedn liczb, w drugim dwie liczby, w trzecim trzy itd. — w dziesitym
dziesi liczb. Oblicz sumy liczb w kolejnych wierszach i sum wszystkich liczb za-
pisanych w tablicy. Wywietl w konsoli tablic liczb oraz obliczone sumy.
Zadanie 28.3.
Utwórz klas TInt, która bdzie zawiera metody statyczne input() i print() umo-
liwiajce wprowadzanie danych z konsoli do tablicy lub wywietlanie danych z tabli-
cy w konsoli. Parametrem wywoania tych metod powinna by tablica liczb cakowi-
tych jedno- lub dwuwymiarowa. Napisz program demonstrujcy dziaanie tych metod.
Zadanie 28.4.
Utwórz w klasie TInt metod statyczn setRandom(), która wypeni tablic liczb ca-
kowitych wartociami wylosowanymi z zakresu od 0 do n (liczba cakowita n > 0).

Tablic oraz zakres wartoci podaj jako parametry metody. Napisz program demon-
strujcy dziaanie tej metody.
Zadanie 28.5.
Dodaj do klasy TInt metod statyczn printf() wywietlajc tablic liczb cakowi-
tych w konsoli. Metoda ta powinna mie dwa parametry: acuch formatujcy i iden-
tyfikator tablicy. Napisz program demonstrujcy dziaanie tej metody.
Zadanie 28.6.
Na podstawie zada 28.3, 28.4 i 28.5 utwórz klas TDouble z metodami statycznymi
input(), print(), printf() i setRandom(), uatwiajcymi pobieranie i wypisywanie
danych oraz losowe ustawianie wartoci w jedno- i dwuwymiarowych tablicach liczb
zmiennoprzecinkowych typu double. Napisz program pokazujcy dziaanie wybranych
metod z tej klasy.
Macierz jest uporzdkowan prostoktn tablic liczb, dla której zdefiniowane s dzia-
ania algebraiczne dodawania (odejmowania) i mnoenia:
Dodawanie (odejmowanie) dwóch macierzy jest moliwe tylko dla macierzy
o jednakowych liczbach kolumn (n) i wierszy (m). Suma (rónica) macierzy
A i B jest macierz C tak, e cij aij bij ( cij aij bij ).
Mnoenie macierzy jest moliwe, gdy liczba kolumn pierwszej macierzy (m)
jest równa liczbie wierszy drugiej macierzy. Iloczyn macierzy A i B jest
m
macierz C tak, e cij ¦ aik bkj . Mnoenie macierzy nie jest przemienne.
k 1
Zawsze okrelone jest mnoenie macierzy przez liczb O , polegajce na

pomnoeniu kadego elementu macierzy przez t liczb ( cij Oaij ).
Macierze moemy przedstawia w programach jako tablice dwuwymiarowe. Naley

pamita, e tablice s indeksowane od zera, a indeksy macierzy rozpoczynamy od
jedynki.
Zadanie 28.7.
Utwórz metod sum() dodajc dwie macierze zapisane w postaci tablic dwuwymia-
rowych. Napisz program demonstrujcy dziaanie metody sum().
W tym i kolejnych zadaniach do wprowadzania danych uywaj metod z klasy TInt

lub TDouble.
Zadanie 28.8.
Utwórz metod difference() obliczajc rónic dwóch macierzy zapisanych w po-
staci tablic dwuwymiarowych. Napisz program demonstrujcy dziaanie metody dif-
ference().

Zadanie 28.9.
Utwórz metod product() obliczajc iloczyn dwóch macierzy zapisanych w postaci
tablic dwuwymiarowych. Napisz program demonstrujcy dziaanie metody product().
Zadanie 28.10.
Utwórz metod product() obliczajc iloczyn macierzy zapisanej w postaci tablicy dwu-
wymiarowych przez liczb. Napisz program demonstrujcy dziaanie metody product().
Zadanie 28.11.
Zbuduj metod transp() tworzc macierz transponowan z macierzy podanej jako
parametr metody. Napisz program demonstrujcy dziaanie metody transp().
Macierz transponowana (przestawiona) powstaje z danej macierzy poprzez zamia-

n jej wierszy na kolumny i kolumn na wiersze.
Zadanie 28.12.
Utwórz metod statyczn toDouble() konwertujc macierz o elementach cakowi-
tych na macierz o elementach zmiennoprzecinkowych. Napisz program demonstruj-
cy dziaanie tej metody. Docz j do klasy TInt.
Zadanie 28.13.
Docz do klasy TDouble metod statyczn o nazwie valueOf(), zwracajc tablic
(macierz) z elementami typu double o elementach odpowiadajcych elementom tabli-
cy (macierzy) liczb cakowitych. Napisz program demonstrujcy dziaanie tej metody.
Zadanie 28.14.
W klasie TDouble utwórz statyczn metod toInt(), która bdzie zwraca tablic (ma-
cierz) o wartociach cakowitych, odpowiadajcych (zamiana przez rzutowanie) tablicy
liczb zmiennoprzecinkowych podanej jako parametr. Napisz program demonstrujcy
Zadanie 28.15.
W klasie TInt utwórz statyczn metod valueOf(), która bdzie budowa tablic (ma-
cierz) o wartociach cakowitych, odpowiadajcych (zamiana przez rzutowanie) tabli-
cy liczb zmiennoprzecinkowych podanej jako parametr. Napisz program demonstru-
jcy dziaanie tej metody.
Macierze, w których liczba wierszy jest równa liczbie kolumn, nazywamy ma-
cierzami kwadratowymi. Z macierzami kwadratowymi zwizany jest szereg
poj, takich jak: lad macierzy, wyznacznik macierzy, macierz diagonalna,
macierz trójktna, macierz jednostkowa i macierz odwrotna.

Zadanie 28.16.
Utwórz statyczn metod trace() wyznaczajc lad macierzy. Napisz program de-
monstrujcy dziaanie tej metody.
Zadanie 28.17.
Utwórz statyczn metod getI() zwracajc macierz jednostkow stopnia n (stopie
podamy jako parametr wywoania metody). Napisz program demonstrujcy dziaanie
tej metody.
Zadanie 28.18.
Utwórz statyczn metod setI() tworzc z macierzy kwadratowej podanej jako pa-
rametr macierz jednostkow. Napisz program demonstrujcy dziaanie tej metody.
Zadanie 28.19.
Utwórz metod statyczn det() obliczajc wyznacznik macierzy kwadratowej. Do
obliczenia wyznacznika uyj rozwinicia Laplace’a. Napisz program demonstrujcy
Zadanie 28.20.
Utwórz metod statyczn upperTriangular() przeksztacajc macierz kwadratow
podan jako parametr na macierz trójktn górn. Napisz program demonstrujcy dzia-
anie tej metody.
Zadanie 28.21.
Utwórz metod statyczn lowerTriangular() przeksztacajc macierz kwadratow
podan jako parametr na macierz trójktn doln. Napisz program demonstrujcy dzia-
anie tej metody.
Zadanie 28.22.
Utwórz metod statyczn diagonal() przeksztacajc macierz kwadratow podan jako
parametr na macierz diagonaln. Napisz program demonstrujcy dziaanie tej metody.
Zadanie 28.23.
Utwórz metod statyczn inverse() obliczajc i zwracajc macierz odwrotn do
macierzy kwadratowej podanej jako parametr. Napisz program demonstrujcy dziaa-
nie tej metody.
Zadanie 28.24.
Napisz program rozwizujcy ukad n-równa liniowych z n niewiadomymi (n < 10).
Ukad równa rozwi, stosujc metod wyznaczników. Wszystkie niezbdne metody
umie w klasie programu.

Zadanie 28.25.
Napisz program rozwizujcy ukad n-równa liniowych z n niewiadomymi. Ukad
równa rozwi, stosujc rachunek macierzy: A X B , X A 1 B , gdzie A — ma-
cierz podstawowa ukadu, X — wektor niewiadomych, B — kolumna wyrazów wol-
nych. Wszystkie niezbdne metody umie w klasie programu.
Zadanie 28.26.
Napisz program rozwizujcy ukad n-równa liniowych z n niewiadomymi. Ukad
równa rozwi, stosujc metod eliminacji. Wszystkie niezbdne metody umie
w klasie programu.
Zadanie 28.27.
Utwórz klas Matrix, która na podstawie tablic dwuwymiarowych, podanych wymia-
rów macierzy lub innych obiektów klasy Matrix (konstruktor kopiujcy) bdzie umo-
liwia tworzenie obiektów reprezentujcych macierze. Utwórz metody uatwiajce do-
stp do elementów macierzy (pól obiektu), wprowadzanie i wywietlanie danych oraz
wypenianie macierzy wartociami losowymi. Napisz program demonstrujcy dziaa-
nie metod klasy Matrix.
Zadanie 28.28.
Docz do klasy Matrix metody umoliwiajce wykonywanie podstawowych dziaa
na macierzach: dodawanie, odejmowanie i mnoenie macierzy oraz mnoenie macie-
rzy przez skalar. Napisz program demonstrujcy dziaania na macierzach.
Zadanie 28.29.
Docz do klasy Matrix metody umoliwiajce przeksztacanie macierzy kwadratowych
na posta trójktn lub diagonaln. Napisz program demonstrujcy dziaanie tych metod.
Zadanie 28.30.
Docz do klasy Matrix metod umoliwiajc obliczanie wyznacznika macierzy. Na-
Zadanie 28.31.
Docz do klasy Matrix metod umoliwiajc obliczanie macierzy odwrotnej. Napisz
program demonstrujcy obliczanie macierzy odwrotnej. Sprawd uzyskany wynik, wy-
konujc odpowiednie mnoenie.
Zadanie 28.32.
Wykorzystujc moliwoci klasy Matrix i obliczenia na macierzach, rozwi ukad
n-równa liniowych z n niewiadomymi.

Zadanie 28.33.
Wykorzystujc moliwoci klasy Matrix i metod wyznaczników, rozwi ukad
n-równa liniowych z n niewiadomymi.
Utwórz metod pomocnicz replaceCol(), która w macierzy wywoujcej t meto-

d zastpi wskazan kolumn kolumn przekazan jako parametr (bdzie to ko-
lumna wyrazów wolnych).
29. Obliczanie wartoci funkcji,

rekurencja i inne zadania
Zadanie 29.1.
Napisz aplikacj testujc dziaanie podanej metody dla rónych argumentów. Okrel,
co oblicza ta metoda. Nadaj jej odpowiedni nazw.
static double f(double x) {
return (x > 0)?x:-x;
}
Zadanie 29.2.
x, gdy x d y x, gdy x t y
Okrelono dwie funkcje: min( x, y ) ® oraz max( x, y ) ® .
¯ y, gdy x ! y ¯ y, gdy x y
Utwórz klas MinMax z metodami min() i max() obliczajcymi i zwracajcymi wartoci
tych funkcji. Napisz aplikacj pokazujc dziaanie tych metod.
Zadanie 29.3.
1, gdy x 0
°
Okrelono funkcj f ( x) ®0, gdy x 0 . Co oblicza ta funkcja? Utwórz metod ob-
°1, gdy x ! 0
¯
liczajc warto tej funkcji. Napisz aplikacj pokazujc dziaanie zbudowanej metody.
Zadanie 29.4.
0, gdy x 0
°
Okrelono funkcj f ( x) ® x . Co oblicza ta funkcja? Utwórz metod ob-
° , gdy x z 0
¯x
liczajc warto tej funkcji. Napisz aplikacj pokazujc dziaanie zbudowanej metody.

Zadanie 29.5.
Napisz aplikacj testujc wartoci funkcji okrelonych wzorami:
x y x y
a) f x, y
2
x y x y
b) g x, y
2
c) h( x) f ( x, x)
Co obliczaj te funkcje? Utworzonym metodom nadaj odpowiednie nazwy.
Zadanie 29.6.
Napisz definicje metod square() i cube() obliczajcych kwadrat i szecian liczby x.
Zastosuj utworzone metody do obliczenia kwadratów i szecianów liczb:
a) cakowitych od 1 do 15,
b) rzeczywistych od 1 do 3 z krokiem 0,25.
Zadanie 29.7.
Potg o wykadniku cakowitym dodatnim okrelamy wzorem a n a
a ...
a . Utwórz
n
metod adoen() obliczajc an. Napisz aplikacj pokazujc dziaanie tej metody.
Zadanie 29.8.
Potg o wykadniku cakowitym nieujemnym moemy okreli wzorem rekurencyj-
1, dla n 0
nym: a n ® . Napisz definicj metody rekurencyjnej adoen() obli-
¯a a , dla n ! 0
n 1
czajcej an oraz aplikacj pokazujc dziaanie tej metody.
Zadanie 29.9.
Szybkie potgowanie — inn wersj metody rekurencyjnej obliczajcej an (szybsz ze
wzgldu na mniejsz liczb wywoa rekurencyjnych i zredukowanie liczby mnoe)
moemy zrealizowa na podstawie wzoru:

°
°1 dla n 0
° § n 1 · 2
°
an ®a ¨ a ¸ dla n nieparzystego (n ! 0) .
2
° © ¹
° n 2
°§¨ a 2 ·¸ dla n parzystego (n ! 0)
¯°© ¹

Utwórz metod adoen() obliczajc an. Napisz aplikacj pokazujc dziaanie tej metody.
Zadanie 29.10.
Potg o podstawie a rónej od 0 i wykadniku cakowitym n moemy zdefiniowa
a a ... a, dla n ! 0
°

°
n
n
w nastpujcy sposób: a ®1, dla n 0 .
°1
° n , dla n 0
¯a
Napisz definicj metody power() (prototyp: double power(double a, int n)) oblicza-
jcej an dla dowolnej liczby cakowitej oraz aplikacj pokazujc dziaanie tej funkcji.
Funkcj adoen (zob. zadanie 29.7, 29.8 lub 29.9) obliczajc an dla n > 1 wykorzy-
1
stamy w funkcji power (do obliczania a n lub a n dla n 1, 2, 3, ... ).
an
Zadanie 29.11.
Pierwiastek drugiego stopnia z liczby dodatniej a moemy obliczy metod iteracyjn
1§ a·
na podstawie wzoru x ¨ x ¸ , przyjmujc jako pierwsze przyblienie x 1 . Ob-
2© x¹
liczenia kontynuujemy do chwili, gdy rónica pomidzy dwoma kolejnymi przyblie-
niami pierwiastka bdzie dostatecznie maa. Napisz metod sqrt() (ang. square root)
obliczajc pierwiastek kwadratowy z podanej liczby dodatniej. Zbuduj aplikacj po-
kazujc dziaanie metody sqrt() i porównujc otrzymane wyniki z wynikami metody
bibliotecznej Math.sqrt().
Zadanie 29.12.
Pierwiastek trzeciego stopnia z liczby dodatniej a moemy obliczy metod iteracyjn
na podstawie wzoru x 1 §¨ 2 x a ·¸ , przyjmujc jako pierwsze przyblienie x 1 . Ob-
3© x2 ¹
liczenia kontynuujemy do chwili, gdy rónica pomidzy dwoma kolejnymi przyblie-
niami pierwiastka bdzie dostatecznie maa. Napisz metod cbrt() (ang. cube root)
obliczajc pierwiastek trzeciego stopnia z podanej liczby dodatniej. Zbuduj aplikacj
pokazujc dziaanie metody cbrt() i porównujc otrzymane wyniki z wynikami me-
tody bibliotecznej Math.cbrt().
Podany wzór wynika z metody Newtona-Raphsona — iteracyjnego algorytmu wy-

znaczania przyblionej wartoci pierwiastka funkcji. Dotyczy to równie wzoru z za-
dania 29.11.

Zadanie 29.13.
Pierwiastek n-tego stopnia z liczby dodatniej a moemy obliczy metod iteracyjn
na podstawie wzoru x 1 §¨ n 1x a ·¸ , przyjmujc jako pierwsze przyblienie
n© x n 1 ¹
x 1 . Obliczenia kontynuujemy do chwili, gdy rónica pomidzy dwoma kolejnymi
przyblieniami pierwiastka bdzie dostatecznie maa. Na podstawie podanego wzoru
napisz metod nRoot() obliczajc pierwiastek n-tego stopnia z podanej liczby do-
datniej. Zbuduj aplikacj pokazujc dziaanie metody nRoot() i porównujc otrzy-
mane wyniki z wynikami uzyskanymi przy zastosowaniu funkcji bibliotecznej.
1
Poniewa n a a n , to warto pierwiastka moemy obliczy przy zastosowaniu
funkcji Math.pow(a, 1.0/n).
Skorzystaj z opracowanej w zadaniu 29.7 metody power() do obliczania warto-

ci x n 1 .
Zadanie 29.14.
W klasie Math zdefiniowano metody obliczajce funkcje hiperboliczne — sinus hiper-
boliczny (Math.sinh()) i cosinus hiperboliczny (Math.cosh()). Napisz program wywie-
tlajcy na ekranie tablice wszystkich funkcji hiperbolicznych w przedziale 5, 5
z krokiem 0,1. Wyniki oblicze zapisz w pliku tekstowym FunkcjeHiperboliczne.txt.
Wyniki pracy programu mona zapisa w pliku tekstowym, stosujc w konsoli po-
lecenie:
java Z29_14 > FunkcjeHiperboliczne.txt
(przyjmujemy, e rozwizanie zadania zapisano w pliku ródowym Z29_14.java).
Zadanie 29.15.
W klasie Math zdefiniowano metod Math.exp() obliczajc warto funkcji wykad-
niczej e x . Rozwi zadanie 29.14, nie korzystajc z metod Math.sinh() i Math.cosh().
e x e x
Wartoci funkcji mona wyliczy na podstawie wzorów: sinh x ,
2
e x e x itp.
cosh x
2

Zadanie 29.16.
Zbuduj klas FH (funkcje hiperboliczne) zawierajc metody statyczne obliczajce war-
toci wszystkich funkcji hiperbolicznych i funkcji do nich odwrotnych. Napisz aplika-
cj pokazujc dziaanie tych metod.
Zadanie 29.17.
Zbuduj klas FTD, która bdzie zawiera metody statyczne obliczajce warto szeciu
funkcji trygonometrycznych i szeciu funkcji do nich odwrotnych. Argumenty funkcji
trygonometrycznych i wartoci funkcji odwrotnych powinny by wyraane w stop-
niach. Udostpnij równie metody konwersji stopni na radiany i radianów na stopnie.
Napisz aplikacj pokazujc moliwoci metod statycznych zawartych w tej klasie.
Zadanie 29.18.
Zbuduj klas FTR, która bdzie zawiera metody statyczne obliczajce warto szeciu
funkcji trygonometrycznych i szeciu funkcji do nich odwrotnych. Argumenty funkcji
trygonometrycznych i wartoci funkcji odwrotnych powinny by wyraane w radia-
nach. Udostpnij równie metody konwersji stopni na radiany i radianów na stopnie.
Napisz aplikacj pokazujc moliwoci metod statycznych zawartych w tej klasie.

Rozdzia 5.
Rozwizania zada
1. Historia Javy i pierwsze zadania
Zadanie 1.1.
Podane rozwizanie ma charakter pogldowy i byo w caoci aktualne, gdy powsta-

wa ten tekst. Zmiany na stronach producenta Javy spowodoway, e Czytelnik nie
moe dokadnie wykorzysta tego rozwizania i musi, wzorujc si na nim, samo-
dzielnie pobra i zainstalowa rodowisko JDK.
Zakadamy, e dysponujesz komputerem klasy PC z systemem operacyjnym Windows

XP lub nowszym i dostpem do internetu. Wykonaj nastpujce czynnoci:
1. Otwórz stron internetow firmy Oracle http://www.oracle.com/pl/index.html.
2. Przejd do dziau Do pobrania.
3. Odszukaj link Java SE i przejd do tej podstrony.
4. Wybierz wersj Java 6 Update 27 i klikajc przycisk Download, pobierz JDK
(Java Development Kit) — http://www.oracle.com/technetwork/java/javase/
downloads/jdk-6u27-download-440405.html.
5. Zapoznaj si z licencj i zaakceptuj j.
6. Wybierz plik instalacyjny waciwy dla posiadanego systemu operacyjnego
i zapisz go na swoim dysku lokalnym:
jdk-6u27-windows-i586.exe (76,81 MB) — dla systemu 32-bitowego,
jdk-6u27-windows-x64.exe (67,40 MB) — dla systemu 64-bitowego.
7. Otwórz zapisany plik instalacyjny i przeprowad proces instalacji.

Podczas typowej instalacji rodowisko JDK zostanie zainstalowane w folderze C:\Pro-

gram Files\Java\jdk1.6.0_27\bin1. Pliki binarne (wykonywalne) znajduj si w podfol-
derze \bin. Naley doda do systemowej cieki przeszukiwa ciek C:\Program
Files\Java\jdk1.6.0_27\bin (lub inn, wynikajc z przebiegu instalacji). W Panelu
sterowania otwórz aplet System i przejd do zakadki Zaawansowane. Kliknij przy-
cisk Zmienne rodowiskowe, na licie Zmienne uytkownika odszukaj i edytuj zmien-
n Path (dopisz potrzebn ciek).
Zadanie 1.2.
Otwórz konsol (w Windows: Start/Uruchom… — w polu edycyjnym w pisz polece-
nie cmd i kliknij przycisk OK), wpisz w konsoli polecenie java i nacinij Enter. Jeli
w konsoli zostanie wywietlona informacja o sposobie uruchomiania programu (help),
to znaczy, e masz zainstalowane rodowisko uruchomieniowe Javy (JRE). Po wpisa-
niu polecenia java –version uzyskasz informacj o wersji posiadanej maszyny wirtu-
alnej Javy.
Wpisz w konsoli polecenie javac. Jeli w konsoli pojawi si informacja o sposobie
i opcjach uruchomienia kompilatora, to masz poprawnie zainstalowane rodowisko
JDK. Moesz sprawdzi wersj kompilatora (javac –version). Niepowodzenie testu,
w postaci komunikatu: Nazwa 'javac' nie jest rozpoznawana jako polecenie we-
wntrzne lub zewntrzne, program wykonywalny lub plik wsadowy, nie wiadczy
o braku JDK. By moe nie zostaa poprawnie ustawiona cieka dostpu (path) do
folderu bin zawierajcego kompilator javac.exe. Sprawd to.
Zadanie 1.3.
Uruchom aplikacj w linii komend i przekieruj wywietlane dane do pliku, np. java –?
> java.txt lub java –help > java.txt (wystarczy równie polecenie java > java.txt).
Nastpnie w dowolnym edytorze tekstowym sformatuj ten tekst wedug swoich po-
trzeb i wydrukuj. Moesz przetumaczy opisy (ale nie sowa bdce opcjami!) na j-
zyk polski, np.:
-? -help print this help message
-? -help wywietl komunikat pomocy
Wydrukuj „cigawk”, czsto z niej zapewne skorzystasz.

Usage: java [-options] class [args...] (to execute a class)
or java [-options] -jar jarfile [args...] (to execute a jar file)
where options include:
-client to select the "client" VM
-server to select the "server" VM
-hotspot is a synonym for the "client" VM [deprecated]. The default VM is client.
-cp <class search path of directories and zip/jar files>
-classpath <class search path of directories and zip/jar files>
A ; separated list of directories, JAR archives,
and ZIP archives to search for class files.
1
Wersja 32-bitowa JDK w 64-bitowym systemie operacyjnym Windows 7 zainstaluje si w folderze
C:\Program Files (x86)\Java\jdk1.6.0_27\bin.

Rozdzia 5. i Rozwizania zada 99
-D<name>=<value> set a system property

-verbose[:class|gc|jni] enable verbose output
-version print product version and exit
-version:<value> require the specified version to run
-showversion print product version and continue
-jre-restrict-search | -jre-no-restrict-search include/exclude user private JREs
in the version search
-? -help print this help message
-X print help on non-standard options
-ea[:<packagename>...|:<classname>]
-enableassertions[:<packagename>...|:<classname>] enable assertions
-da[:<packagename>...|:<classname>]
-disableassertions[:<packagename>...|:<classname>] disable assertions
-esa | -enablesystemassertions enable system assertions
-dsa | -disablesystemassertions disable system assertions
-agentlib:<libname>[=<options>] load native agent library <libname>, e.g.
-agentlib:hprof, see also, -agentlib:jdwp=help and -agentlib:hprof=help
-agentpath:<pathname>[=<options>] load native agent library by full pathname
-javaagent:<jarpath>[=<options>] load Java programming language agent, see
java.lang.instrument
-splash:<imagepath> show splash screen with specified image
Zadanie 1.4.
Uruchomienie aplikacji javac.exe bez podania parametrów powoduje wywietlenie na-
stpujcej instrukcji:
Usage: javac <options> <source files>
where possible options include:
-g Generate all debugging info
-g:none Generate no debugging info
-g:{lines,vars,source} Generate only some debugging info
-nowarn Generate no warnings
-verbose Output messages about what the compiler is doing
-deprecation Output source locations where deprecated APIs are used
-classpath <path> Specify where to find user class files and annotation
processors
-cp <path> Specify where to find user class files and annotation
processors
-sourcepath <path> Specify where to find input source files
-bootclasspath <path> Override location of bootstrap class files
-extdirs <dirs> Override location of installed extensions
-endorseddirs <dirs> Override location of endorsed standards path
-proc:{none,only} Control whether annotation processing and/or compilation
is done.
-processor <class1>[,<class2>,<class3>...] Names of the annotation processors
to run; bypasses default discovery process
-processorpath <path> Specify where to find annotation processors
-d <directory> Specify where to place generated class files
-s <directory> Specify where to place generated source files
-implicit:{none,class} Specify whether or not to generate class files for
implicitly referenced files
-encoding <encoding> Specify character encoding used by source files
-source <release> Provide source compatibility with specified release
-target <release> Generate class files for specific VM version
-version Version information
-help Print a synopsis of standard options

-Akey[=value] Options to pass to annotation processors

-X Print a synopsis of nonstandard options
-J<flag> Pass <flag> directly to the runtime system
Przechwycenie tego tekstu poleceniem javac > opis.txt do pliku opis.txt si nie po-
wiedzie. Moemy natomiast tekst w konsoli zaznaczy (menu wywoane prawym przy-
ciskiem myszy) i skopiowa zaznaczony fragment lub cay tekst do schowka (naciska-
jc klawisz Enter).
Zadanie 1.5.
1. Plik console.bat — otwieranie konsoli w biecym folderze.
cmd
Moesz ten plik wsadowy rozbudowa tak, aby automatycznie wywoywa

kolejne dwa pliki wsadowe.
call setpath
call setdrive
cls
cmd
Do pliku console.bat utwórz skrót na pulpicie lub w innym dogodnym miejscu.

2. Plik setpath.bat — ustawianie cieki dostpu do folderu bin na komputerach,
na których nie mamy uprawnie do zmian konfiguracyjnych w systemie lub
nie chcemy tych zmian dokonywa2.
path C:\Program Files\Java\jdk1.6.0_27\bin; %PATH%
3. Plik setdrive.bat — ustawienie folderu z plikami ródowymi jako dysku X:3.

subst X: H:\!JAVA_ZZ\Pliki
X:
4. Plik kompiluj.bat — kompilacja pliku ródowego o nazwie podanej jako

parametr dla pliku wsadowego (nazw podamy bez rozszerzenia .java i to
jest nasze mae uproszczenie pracy).
javac %1.java
Moemy ten plik rozbudowa, dodajc ciek do kompilatora.

C:\Program Files\Java\jdk1.6.0_27\bin\javac %1.java
5. Plik uruchom.bat — uruchomienie wirtualnej maszyny Javy (JVM)

i przekazanie do wykonania kodu skompilowanej klasy. Nazw klasy
podajemy jako parametr pliku wsadowego (tu adnego uproszczenia pracy
nie wida).
java %1
2
Na komputerze Czytelnika cieka moe by inna, zalena od tego, gdzie zainstalowano JDK. Autor
uywa cieki dla standardowego przebiegu procesu instalacji rodowiska Javy.
3
Autor w czasie opracowywania niniejszego zbioru zada korzysta z pendrive’a, który instalowa si
w systemie jako dysk H:. Na materiay zwizane z tworzonym zbiorem autor utworzy folder !JAVA_ZZ,
a pliki ródowe zapisywa w folderze !JAVA_ZZ\Pliki. Na komputerze Czytelnika cieka z plikami
moe by inna.

Program cmd.exe umoliwia uycie dziesiciu zmiennych do oznaczania

parametrów pliku wsadowego (od %0 do %9). Zmienna %0 przekazuje nazw
pliku wsadowego, a zmienne od %1 do %9 zawieraj kolejne argumenty wpisane
przez uytkownika w wierszu polecenia. Moemy zatem do pliku wsadowego
przekaza nazw klasy (%1) i maksymalnie 8 parametrów (od %2 do %9).
java %1 %2 %3 %4 %5 %6 %7 %8 %9
6. Plik edytuj.bat — uruchomienie systemowego Notatnika (notepad.exe)

i przekazanie do edycji kodu ródowego klasy. Nazw klasy podajemy
jako parametr pliku wsadowego (nazwa pliku powstanie z nazwy klasy
i rozszerzenia .java).
start notepad.exe %1.java
Przypomnijmy na koniec, e dysk X: moemy usun poleceniem subst X: /D. Nie

powoduje to oczywicie utraty danych, które s bezpiecznie przechowywane w folde-
rze dotychczas skojarzonym z napdem X:. Konsol natomiast zamkniemy poleceniem
exit. Na listingu 1.1 przedstawiono wersj pliku console.bat uywan przez autora.
Listing 1.1. console.bat

path C:\Program Files\Java\jdk1.6.0_27\bin; %PATH%
subst X: H:\!JAVA_ZZ\Pliki
X:
cls
call cmd
c:
subst X: /D
Dwa kocowe wiersze s wykonywane dopiero po zamkniciu konsoli poleceniem

exit (nie naley zamyka okna konsoli w inny sposób).
Na rysunku 1.1 widoczne jest rozwizanie zastosowane w konfiguracji skrótu na pulpicie.
2. JDK, Notatnik i klasyczny

przykad „Hello World”
Zadanie 2.1. Hello.java, Z02_1.java
Kolejno postpowania bdzie nastpujca:
1. Przygotuj do pracy dysk X: (otwórz skrót z pulpitu). Dalej pracuj w konsoli
na dysku X:.
2. Poleceniem edytuj Hello utwórz plik tekstowy Hello.java (w Notatniku)
i przepisz podany kod. Zapisz tekst (Ctrl+S) i zamknij Notatnik (Alt+F4).

Rysunek 1.1.
Propozycja
konfiguracji
skrótu na
pulpicie
public class Hello {

}
}
3. Skompiluj kod ródowy poleceniem kompiluj Hello (stosujc plik wsadowy

kompiluj.bat) lub javac Hello.java. Jeli kompilacja si nie powioda
(s komunikaty o bdach), wró do punktu 2.
4. Uruchom aplikacj poleceniem uruchom Hello (plik wsadowy uruchom.bat)
lub java Hello. Pamitaj o wielkoci liter (Java rozrónia wielko liter
— sowa: hello, Hello i HELLO s trzema rónymi identyfikatorami).
Jako parametr uruchomienia podajemy nazw klasy, a nie nazw pliku.
Pierwsza aplikacja zostaa uruchomiona. Przedstawion tu procedur stosuj do dalszych

zada. Zapamitaj równie kilka wanych informacji.
Prosta aplikacja w jzyku Java skada si z jednej publicznej klasy. Nazw klasy rozpoczyna-
my zwykle od wielkiej litery. Jeli nazwa klasy skada si z kilku sów, to czymy je w jedno
sowo, stosujc tzw. notacj wielbdzi (CamelCase), np.: MojaPierwszaKlasa.
Klasa ta musi zawiera publiczn i statyczn metod main, od której rozpoczyna si wykona-
nie aplikacji.
Nazwa pliku ródowego musi by zgodna (równie pod wzgldem wielkoci liter) z nazw kla-
sy. Wymagane jest rozszerzenie .java, np. MojaPierwszaKlasa.java.
Kompilujemy kod ródowy klasy, np. javac MojaPierwszaKlasa.java. Efektem kompilacji jest
kod bajtowy (B-kod, betakod, ang. bytecode) zapisany w pliku MojaPierwszaKlasa.class.
Aplikacj uruchamiamy, otwierajc wirtualn maszyn Javy (JVM) i przekazujc do interpreta-
cji (jako parametr) nazw skompilowanej klasy, np. java MojaPierwszaKlasa.

Umiesz ju przepisa kod, skompilowa plik ródowy i uruchomi aplikacj. Przeana-
lizujmy ten prosty przykad.
Zacznijmy od budowy klasy. Kod klasy skada si ze sowa kluczowego class, iden-
tyfikatora (nazwy klasy) i ciaa klasy ujtej w nawiasy klamrowe {}, np. class Pusta
{ }. W naszym przypadku wystpuje jeszcze sowo kluczowe public, okrelajce do-
stp (publiczny) do klasy.
W ciele klasy wystpuje publiczna i statyczna metoda main:

public static void main(String args[]) { }
Sowo kluczowe public oznacza, e metoda main() jest widoczna dla wszystkich ele-
mentów programu. Metoda statyczna (sowo kluczowe static) jest dostpna bez ko-
niecznoci tworzenia obiektu klasy. Przed nazw metody main wystpuje sowo klu-
czowe void, informujce, e metoda nie zwraca adnej wartoci (pusty typ wyniku).
W nagówku metody main() konieczne jest zadeklarowanie tablicy argumentów String
args[] lub String[] args (obie postacie deklaracji oznaczaj to samo). String jest
nazw klasy (typu obiektowego) sucej do wykonywania operacji na acuchach
znaków (tekstach), args jest identyfikatorem deklarowanego obiektu4, a symbol []
oznacza tablic zoon z kilku obiektów. Podczas uruchomienia aplikacji ta tablica
jest wypeniana przez system parametrami wywoania. Szczegóy wkrótce. W tym
przykadzie nie korzystamy z tablicy argumentów, ale taka deklaracja musi by w na-
gówku metody main().
W ciele metody wystpuje jeden wiersz, odpowiedzialny za wywietlenie tekstu Hello

World w konsoli:
W klasie System zdefiniowana jest statycznie zmienna obiektowa out. Metody tej zmien-
nej dziaaj na standardowym strumieniu wyjciowym. Uyta w przykadzie metoda
println() wysya na standardowe wyjcie (konsol) dane przekazane jako parametr
podczas wywoania metody i kod koca wiersza5. W tym przykadzie argumentem jest
staa warto tekstowa, czyli litera acuchowy "Hello World".
Zadanie 2.2. Witam.java, Z02_2.java

To kolejny przykad wykorzystania metody System.out.println opisanej w rozwi-
zaniu zadania 2.1. Problem prawidowego wywietlania liter z polskimi znakami dia-
krytycznymi w konsoli omówiono, podajc wskazówk do zadania.
4
Ten identyfikator mona zmieni, ale nie ma potrzeby tego robi. Sowo args jest po prostu skrótem
od sowa argumenty (ang. arguments).
5
Parametr moe by wielkoci sta (literaem), zmienn dowolnego typu lub wyraeniem. Metoda
println() wywoana bez parametru powoduje tylko przeniesienie kursora na pocztek nowej linii. Ist-
nieje te podobnie dziaajca metoda print(), która wypisuje informacj na standardowym wyjciu,
ale nie przenosi kursora do nowego wiersza.

public class Witam {

System.out.println("Witaj, wiecie.");
System.out.println("Ucz si programowa w jzyku Java.");
}
}
Zadanie 2.3. Adres.java, Z02_3.java

W acuchu znaków umieszczono specjalny znak \n, powodujcy przejcie tekstu
umieszczonego za znakiem do nowego wiersza.
public class Adres {
/* Dane osoby i adres s zupenie fikcyjne */
System.out.println("Ewa Nowak\nul. Krótka 1\n11-111 Fikcja
Dolna");
}
}
W ten sposób w acuchu moemy umieci inne znaki specjalne: \b — backspa-

ce, \t — tabulacja, \r — powrót karetki, \" — cudzysów, \' — apostrof, \\ —
lewy ukonik.
Zadanie 2.4. Etykieta.java, Z02_4.java

public class Etykieta {
System.out.println("******* Programowanie *******");
System.out.println("* obiektowe w jzyku Java *");
System.out.println("* Jan Nowak *");
System.out.println("*****************************");
}
}
3. Znaki, tablice znaków i klasa String

Zadanie 3.1. Witaj.java, Z03_1.java
Deklarujemy tablic znaków (char[]) o nazwie witaj. Rozmiar tablicy nie zosta ustalony.
Poniewa czymy deklaracj z inicjowaniem elementów tablicy, to kompilator na tej
podstawie obliczy rozmiar tablicy i wypeni j odpowiednimi wartociami. Zwrómy
uwag na sposób zapisu znaków z uyciem apostrofów i zapamitajmy zasadnicz
rónic: 'A' — znak, litera A; "A" — acuch znaków (jednoelementowy), zawieraj-
cy jeden znak A. Jeli potrzebujemy wywietli wszystkie znaki zapisane w tablicy
(w kolejnoci ich wystpowania), to moemy uy metody print lub println, przeka-
zujc nazw tablicy jako parametr wywoania metody.
public class Witaj {

char[] witaj = {'D', 'z', 'i', 'e', ' ', ' ', 'd', 'o',
'b', 'r', 'y'};
System.out.println(witaj);
}
}
Zadanie 3.2. Informatyka.java, Z03_2.java

W dziaaniach zwizanych z przetwarzaniem tablic czsto wykorzystujemy instrukcje
iteracyjne (ptle). Zawarto tablicy moemy wywietli, uywajc ptli typu for each
(wprowadzonej do jzyka Java SE 5.0):
for(typ_zmiennej zmienna : kolekcja) instrukcja;
W powyszym zapisie for jest sowem kluczowym definiujcym ptl, identyfikator

zmienna oznacza zmienn typu typ_zmiennej zawartego w kolekcji, dwukropek (:)
oddziela zmienn od identyfikatora kolekcji (wymaga tego skadnia ptli for each),
kolekcja w tym przypadku oznacza nazw tablicy6. Identyfikator zmiennej i nazwa
kolekcji ujte s w nawiasy ( ), natomiast za nawiasem znajduje si instrukcja do
powtarzania. Instrukcja powtarzana jest tyle razy, ile elementów zawiera kolekcja;
w kadym powtórzeniu cyklu warto zmiennej jest równa wartoci kolejnego elemen-
tu kolekcji. Naley doda, e ptla typu for each suy do odczytywania kolekcji i za
porednictwem zmiennej nie moemy modyfikowa wartoci elementów kolekcji.
Ptla for(char x : a) System.out.print(x); wywietli w konsoli po kolei wszystkie

znaki zapisane w tablicy a. Oczywicie moemy z wartoci zmiennej x wykona in-
ne, bardziej skomplikowane operacje ni tylko wywietlanie w konsoli.
a) W ptli for(char znak : dane) ... pobieramy do zmiennej znak kolejne
elementy z tablicy dane. Kady pobrany z tablicy znak wywietlamy
w odrbnym wierszu konsoli System.out.println(znak).
b) Pisanie tekstem rozstrzelonym (spacjowanie) polega na pisaniu tekstu znak
po znaku, oddzielajc kolejne znaki odstpami (spacjami). W ptli pobieramy
z tablicy kolejne znaki i wywietlamy w konsoli System.out.print(znak);
System.out.print(" ");.
c) W klasie Character zdefiniowano statyczn metod toUpperCase()
zmieniajc ma liter na odpowiadajc jej wielk liter.
Wykorzystujemy t metod do zamiany znaków odczytywanych
z tablicy System.out.print(Character.toUpperCase(znak));.
d) Pobrane z tablicy dane znaki (mae lub wielkie litery), zamieniamy na mae
litery (Character.toLowerCase(znak)) i wywietlamy w konsoli.
public class Informatyka {
char dane[] = {'I', 'n', 'f', 'o', 'r', 'm', 'a', 't', 'y',
'k', 'a'};
/* Zadanie 3.2a */
System.out.println("Pionowo: ");
6
Dalej bd przedstawione inne kolekcje.

for(char znak : dane)

System.out.println(znak);
System.out.println();
/* Zadanie 3.2b */
System.out.print("Tekst rozstrzelony: ");
for(char znak : dane) {
System.out.print(znak);
System.out.print(" ");
}
/* Zadanie 3.2c */
System.out.print("Wielkie litery: ");
System.out.print(Character.toUpperCase(znak));
/* Zadanie 3.2d */
System.out.print("Mae litery: ");
System.out.print(Character.toLowerCase(znak));
}
}
Metody toLowerCase() i toUpperCase() zmieniaj wycznie wielko liter, nie po-

woduj adnych zmian w pozostaych znakach.
Zadanie 3.3. Programowanie.java, Z03_3.java

Stosujc podstawienie dane[0] = Character.toUpperCase(dane[0]);, zmienimy pierw-
szy znak zapisany w tablicy dane. Podobnie mona postpi z pozostaymi znakami.
Indeksy znaków zapisanych w tablicy zmieniaj si w zakresie od 0 do wartoci o 1
mniejszej od rozmiaru tablicy. Dostp do wszystkich znaków w tablicy dane uzyska-
my, stosujc ptl typu for:
for(int i=0; i < dane.length; ++i) {
// Tu wykonaj przeksztacenie zwizane z elementem dane[i].
}
Ptla for bdzie dalej omówiona dokadniej; na razie zapamitaj, e zmienna i typu
cakowitego int bdzie w tym przypadku zmieniaa si od 0 (na pocztku inicjujemy
zmienn int i=0;) do wartoci dane.length–1. Instrukcja zawarta w ciele ptli wyko-
nuje si, gdy speniony jest warunek i < dane.length. Po kadym wykonaniu ptli
warto zmiennej i jest zwikszana o 1 (operator inkrementacji ++i7). Ptla wykona
si dokadnie tyle razy, ile elementów ma tablica dane, a zmienna i przyjmie kolejno
wartoci indeksów wszystkich elementów tablicy.
Sowo kluczowe int jest nazw typu do przechowywania liczb cakowitych w zakre-
sie od –231 do 231–1. Konstrukcja int a; jest deklaracj zmiennej a typu int, natomiast
int a = warto; deklaruje zmienn i inicjuje jej warto pocztkow (warto moe
by literaem lub wyraeniem).
7
Zapis ++i jest równowany podstawieniu i = i+1.

public class Programowanie {

char dane[] = {'p', 'r', 'o', 'g', 'r', 'a', 'm', 'o', 'w',
'a', 'n', 'i', 'e'};
System.out.print("Tablica znaków: ");
System.out.println(dane);
/* Zmiana pierwszej litery na wielk */
dane[0] = Character.toUpperCase(dane[0]);
System.out.print("Pierwsza litera wielka: ");
/* Zmiana wszystkich liter na wielkie */
for(int i=0; i < dane.length; ++i)
dane[i] = Character.toUpperCase(dane[i]);
System.out.print("Wszystkie litery wielkie: ");
}
}
Zadanie 3.4. Wspak1.java, Z03_4.java

Do przegldania tablicy zastosujemy ptl for, w której nastpuje odliczanie w dó
(od wartoci wikszych do mniejszych:
for(int i=dane.length–1; i >= 0; ––i) {
// Tu wykonamy przeksztacenie zwizane z elementem dane[i].
}
Na pocztku zmienn i inicjujemy wartoci równ indeksowi ostatniego elementu

(rozmiar tablicy zmniejszony o 1 — int i=dane.length–1). Instrukcje s wykonywa-
ne, gdy i >= 0 (i jest wiksze lub równe 0). Po kadym wykonaniu instrukcji warto
zmiennej i jest zmniejszana o 1 (dekrementacja ––i8).
public class Wspak1 {
char dane[] = {'p', 'r', 'o', 'g', 'r', 'a', 'm', 'o', 'w',
'a', 'n', 'i', 'e'};
System.out.print("Normalna kolejno znaków: ");
System.out.print("Odwrotna kolejno znaków: ");
for(int i = dane.length-1; i >= 0; --i)
System.out.print(dane[i]);
}
}
Zadanie 3.5. Wspak2.java, Z03_5.java

Do zamiany wartoci dwóch elementów uyjemy zmiennej pomocniczej wedug sche-
matu: p = a; a = b; b = p; — spowoduje to wymian wartoci pomidzy zmiennymi
a i b. Odwracanie tablicy znaków zrealizujemy, zamieniajc pierwszy znak z ostatnim,
drugi z przedostatnim — i tak do chwili, gdy dojdziemy do rodka tablicy. W tym celu
wykorzystamy nastpujce zmienne: i — indeks pierwszego znaku (indeks ten zwiksza
8
Zapis ––i jest równowany podstawieniu i = i–1.

si, przechodzc od pocztku (int i = 0) do rodka tablicy), j — indeks ostatniego

znaku (indeks ten zmniejsza si, przechodzc od koca (int j = dane.length-1) do
rodka tablicy), tmp — zmienna pomocnicza do zamiany wartoci dwóch elementów
tablicy. Czynnoci zamiany elementów s powtarzane, gdy i < j. Na koniec kadego
cyklu zwikszamy indeks i (++i) i zmniejszamy indeks j (--j), zbliajc si do rod-
ka tablicy.
public class Wspak2 {
char dane[] = {'p', 'r', 'o', 'g', 'r', 'a', 'm', 'o',
'w', 'a', 'n', 'i', 'e'};
for(int i = 0, j = dane.length-1; i < j ; ++i, --j) {
char tmp = dane[i];
dane[i] = dane[j];
dane[j] = tmp;
}
}
}
Zadanie 3.6. DemoCharacter.java, Z03_6.java

Pierwszy wiersz kodu import static java.lang.System.*; powoduje zaimportowa-
nie do naszej klasy wszystkich elementów statycznych z klasy java.lang.System
(w tym obiektu out). W dalszej czci kodu moemy posugiwa si tym obiektem bez
podawania nazwy klasy, z której pochodzi. Zamiast odwoania System.out.println(...);
wystarczy out.println(...);.
Na pocztku umieszczono kilka informacji o metodzie digit (ang. digit — cyfra):

out.println("Klasa: java.lang.Character"); — klasa Character znajduje
si w pakiecie java.lang.
out.println("Metoda statyczna: digit\n"); — omawiana metoda jest
metod statyczn, nie potrzebujemy tworzy obiektu klasy Character,
aby skorzysta z tej metody.
out.println("static int digit(int ch, int radix)"); — nagówek
metody digit zawiera: sowo kluczowe static (metoda jest statyczna),
typ zwracanej wartoci int i list parametrów wywoania metody (int ch,
int radix).
out.println("Returns the numeric value of the character ch in the
specified radix."); — pierwsze zdanie z dokumentacji metody, informujce
o dziaaniu metody. Metoda digit zwraca liczb bdc wartoci cyfry
reprezentowanej przez znak ch w ukadzie pozycyjnym o okrelonej
podstawie (radix).
Nastpnie zadeklarowano przykadow tablic znaków zawierajc znaki napisu Euro

2012 — char znak[] = {'E', 'u', 'r', 'o', ' ', '2', '0', '1', '2'};.

Dziaanie metody pokazano w dwóch przypadkach, obliczajc wartoci znaków w ta-

blicy jako cyfr ukadów dziesitkowego (radix = 10) oraz szesnastkowego (radix = 16).
W ptli for pobieramy kolejne znaki z tablicy, wywietlamy w konsoli ich posta znako-
w i warto jako cyfry w okrelonym ukadzie liczbowym. Sprawdzamy cyfry uka-
du dziesitkowego:
for(char z : znak)
Wynik -1 oznacza, e znak nie jest cyfr w tym ukadzie liczbowym.

Warto znaku jako cyfry w ukadzie dziesitkowym (radix = 10)
Znak: E Cyfra: -1
Znak: u Cyfra: -1
Znak: r Cyfra: -1
Znak: o Cyfra: -1
Znak: Cyfra: -1
Znak: 2 Cyfra: 2
Znak: 0 Cyfra: 0
Znak: 1 Cyfra: 1
Znak: 2 Cyfra: 2
Podobnie sprawdzimy cyfry w ukadzie szesnastkowym:

for(char z : znak)
Po wykonaniu kodu zauwaymy, e litera E jest cyfr w ukadzie szesnastkowym (war-

to dziesitna 14).
Warto znaku jako cyfry w ukadzie szesnastkowym (radix = 16)
Znak: E Cyfra: 14
Znak: u Cyfra: -1
Znak: r Cyfra: -1
Znak: o Cyfra: -1
Znak: Cyfra: -1
Znak: 2 Cyfra: 2
Znak: 0 Cyfra: 0
Znak: 1 Cyfra: 1
Znak: 2 Cyfra: 2
Zadanie 3.7. Cyfry.java, Z03_7.java

Zgodnie z podan wskazówk odrzucamy najprostsze rozwizanie: char[] cyfry =
{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};.
Wykorzystamy fakt, e kody cyfr dziesitnych (0123456789) s liczbami z zakresu

od 48 do 57. Aby zamieni kod znaku (liczb cakowit) na odpowiadajcy mu znak,
posuymy si rzutowaniem typów, np.: (char) 48 — liczb cakowit 48 rzutujemy
na typ char i otrzymujemy znak '0'.
public class Cyfry {
char[] cyfry = new char[10];

for(int i = 0; i < 10; ++i)

cyfry[i] = (char)(i+48);
System.out.print("Cyfry ukadu dziesitkowego: ");
System.out.println(cyfry);
}
}
Ptl wypeniajc tablic moemy równie zapisa w postaci:

for(int i = 48; i < 58; ++i)
cyfry[i] = (char)i;
Zadanie 3.8. Cyfry16.java, Z03_8.java

Zadanie to moemy rozwiza podobnie jak zadanie 3.7. Do zapisania liczby w uka-
dzie szesnastkowym potrzebujemy szesnastu cyfr — dziesi z nich to cyfry znane
z ukadu dziesitkowego (0123456789 — znaki o kodach od 48 do 57), jako sze po-
zostaych cyfr wykorzystamy litery ABCDEF (znaki o kodach od 65 do 70).
public class Cyfry16 {
for(int i = 0; i < 10; ++i)
for(int i = 10; i < 16; ++i)
System.out.print("Cyfry ukadu szesnastkowego: ");
}
}
Do rozwizania zadania moemy wykorzysta statyczn metod forDigit (z dwoma

parametrami int digit i int radix) z klasy Character, zamieniajc warto liczbo-
w (parametr digit) na odpowiadajc jej cyfr (znak) w ukadzie liczbowym o pod-
stawie radix.
public class Cyfry16 {
for(int i = 0; i < 16; ++i)
cyfry[i] = Character.forDigit(i, 16);
}
}
Metoda forDigit zwróci cyfry o wartoci wikszej od 9 jako mae litery (abcdef). Mo-
emy przyj takie rozwizanie lub dodatkowo zamieni te znaki na wielkie litery (sto-
sujc metod poznan w rozwizaniu zadania 3.2):
for(int i = 0; i < 16; ++i)
cyfry[i] = Character.toUpperCase(Character.forDigit(i, 16));

4. Klasa String — operacje na tekstach

Zadanie 4.1. TestString.java, Z04_1.java
"Zadania z programowania." — acuch znaków stanowicy punkt wyjcia do dalszych
przeksztace.
"Zadania z programowania.".charAt(0) — wyodrbnienie znaku o indeksie 0 (pierw-

szy znak acucha).
"Zadania z programowania.".length() — dugo acucha (liczba znaków, w tym

przypadku 24).
"Zadania z programowania.".charAt(23) — wyodrbnienie znaku o indeksie 23 (ostat-

ni znak acucha).
"Zadania z programowania.".toUpperCase() — zamiana liter w acuchu na wielkie

litery (oczywicie zwracana jest kopia acucha, na której dokonano zmian, orygina
pozostaje nienaruszony).
"Zadania z programowania.".toLowerCase() — zamiana liter w acuchu na mae li-

tery (jw.).
"Zadania z programowania.".indexOf('z') — indeks pozycji pierwszego wystpie-

nia znaku z. Jeli podany znak nie wystpuje w acuchu, to zwracana jest warto –1.
"Zadania z programowania.".indexOf("prog") — indeks pozycji pierwszego wyst-

pienia cigu "prog". Jeli podany cig nie wystpuje w acuchu, to zwracana jest
warto –1.
"Zadania z programowania.".replace('.', '?') — zwraca nowy cig, w którym

wszystkie znaki kropki (.) zostan zastpione znakiem pytajnika (?).
"Zadania z programowania.".replace("adania", "dania") — zastpienie wszystkich

wystpie cigu "adania" cigiem "dania".
"Zadania z programowania.".replaceAll("ania", "anka") — zastpienie wszystkich

wystpie cigu "ania" cigiem "anka".
"Zadania z programowania.".replaceFirst("ania", "anka") — zastpienie pierw-

szego wystpienia cigu "ania" cigiem "anka".
"Zadania z programowania.".substring(10) — wyodrbnienie cigu od znaku o in-

deksie 10 do koca acucha wyjciowego.
"Zadania z programowania.".substring(10, 17) — wyodrbnienie cigu od znaku

o indeksie 10 do znaku stojcego przed znakiem o indeksie 17. Dugo wyodrbnio-
nego acucha: 17–10 = 7 znaków.

"Zadania z programowania.".concat("\b z podpowiedziami.") — doczenie na

kocu acucha "Zadania z programowania." cigu znaków "\b z podpowiedziami.".
Pierwszy znak w doczanym cigu jest znakiem specjalnym \b (backspace) i spowo-
duje skasowanie ostatniego znaku (kropki) w acuchu wyjciowym.
"Zadania z programowania."+"\b"+" z odpowiedziami." — zczenie trzech acu-

chów znaków w jeden acuch (operator +).
Zadanie 4.2. DemoString.java, Z04_2.java

Tworzymy zmienn obiektow napis klasy String i inicjujemy j wartoci "Zadania
z programowania.".
W tej sytuacji przykad z listingu 4.1 wyglda tak:

public class DemoString {
System.out.println(napis);
System.out.println(napis.charAt(0));
System.out.println(napis.length());
System.out.println(napis.charAt(napis.length()-1));
System.out.println(napis.toUpperCase());
System.out.println(napis.toLowerCase());
System.out.println(napis.indexOf('z'));
System.out.println(napis.indexOf("prog"));
char kropka = '.', pytajnik = '?';
System.out.println(napis.replace(kropka, pytajnik));
System.out.println(napis.replace("adania", "dania"));
String str1 = "ania", str2 = "anka";
System.out.println(napis.replaceAll(str1, str2));
System.out.println(napis.replaceFirst(str1, str2));
System.out.println(napis.substring(10));
System.out.println(napis.substring(10, 17));
str1 = "\b z podpowiedziami.";
System.out.println(napis.concat(str1));
System.out.println(napis+str1.substring(0, 4)+str1.substring(5));
}
}
Dziaanie zastosowanych metod omówiono w rozwizaniu zadania 4.1.
Zadanie 4.3. WitajStr.java, Z04_3.java

Tworzymy obiekt witaj klasy String zainicjowany wartoci "Dzie dobry". Metoda
length zwraca rozmiar (dugo) acucha znaków. Znaki acucha s indeksowane
(podobnie jak tablice) indeksami o wartociach od 0 do wartoci o 1 mniejszej od du-
goci acucha. Znaki acucha o podanym indeksie udostpnia nam metoda charAt.
W ptli for(int i = 0; i < witaj.length(); ++i)... uzyskamy dostp (po kolei)

do wszystkich znaków acucha witaj.charAt(i). Znaki moemy w ten sposób wy-
cznie odczytywa. Tak wanie rozwiemy czci a) i b) naszego zadania.

public class WitajStr {

String witaj = "Dzie dobry";
/* Zadanie 4.3a */
for(int i = 0; i < witaj.length(); ++i)
System.out.println(witaj.charAt(i));
/* Zadanie 4.3b */
for(int i = 0; i < witaj.length(); ++i)
System.out.print(witaj.charAt(i)+" ");
/* Zadanie 4.3c */
System.out.print("Wielkie litery: "+witaj.toUpperCase());
/* Zadanie 4.3d */
System.out.print("Mae litery: "+witaj.toLowerCase());
}
}
W przypadku acucha znaków nie musimy zamienia odrbnie kadego znaku (mae
litery na wielkie lub odwrotnie, wielkie na mae). Do rozwizania czci zadania za-
wartych w podpunktach c) i d) moemy wykorzysta metody toUpperCase lub toLower-
Case zwracajce acuch (obiekt) zapisany odpowiednio wielkimi lub maymi literami.
Jeli zamienimy acuch na tablic znaków, to moemy skorzysta z ptli typu for
each (podajemy fragment kodu) i rozwiza zadanie w sposób znany z rozwizania
zadania 3.2:
/* Zadanie 4.3a */
for(char z : witaj.toCharArray())
System.out.println(z);
/* Zadanie 4.3b */
for(char z : witaj.toCharArray())
System.out.print(z+" ");
Zadanie 4.4. ProgramowanieStr.java, Z04_4.java, Z04_4a.java

Obiekt klasy String nie jest modyfikowalny, czyli nie jest moliwe zmienianie w nim
znaków, dodawanie do niego nowych znaków lub usuwanie z niego znaków istniej-
cych. Moemy natomiast zbudowa na jego podstawie nowy acuch speniajcy wa-
runki zadania i przypisa go do tej samej referencji (zmiennej nazwa). Zbdny acuch
zostanie usunity z pamici przez mechanizm garbage collection (ang. — czyszczenie
pamici, usuwanie niepotrzebnych obiektów).
Tworzymy acuch znaków String napis = "programowanie"; zawierajcy sowo pro-

gramowanie zapisane maymi literami.

a) Z acucha napis pobieramy pierwszy znak napis.charAt(0), czyli znak p,

i zamieniamy go na wielk liter Character.toUpperCase(napis.charAt(0)),
otrzymujc znak P. Do tego znaku dodajemy podacuch acucha napis,
od znaku o indeksie 1 do koca acucha napis.substring(1), czyli sowo
rogramowanie. Operator konkatenacji (+) zamieni znak 'P' na acuch
jednoelementowy "P" i poczy z acuchem "rogramowanie" w acuch
"Programowanie":
napis = Character.toUpperCase(napis.charAt(0))+napis.substring(1);
Mona to samo uzyska nieco inaczej:

napis = (""+napis.charAt(0)).toUpperCase()+napis.substring(1);
W wyniku dodawania ""+napis.charAt(0) (pusty acuch "" czymy

z pojedynczym znakiem 'p') otrzymujemy jednoelementowy acuch "p",
który metoda toUpperCase zamienia na acuch "P". Nastpnie mamy znan
ju operacj "P"+"rogramowanie", oczywicie zapisan w inny sposób.
I jeszcze raz to samo, ale w innym zapisie (komentarz naley do Czytelnika):
napis = napis.substring(0, 1).toUpperCase()+napis.substring(1);
b) Zamieniajc wszystkie litery na wielkie, wystarczy uy metody toUpperCase

dla obiektu napis — napis = napis.toUpperCase();.
public class ProgramowanieStr {
String napis = "programowanie";
System.out.print("a cuch znaków: ");
/* Zmiana pierwszej litery na wielk */
napis = Character.toUpperCase(napis.charAt(0))+
napis.substring(1);
System.out.print("Pierwsza litera wielka: ");
/* Zmiana wszystkich liter na wielkie */
napis = napis.toUpperCase();
System.out.print("Wszystkie litery wielkie: ");
}
}
Powracajc do podpunktu a) zadania, moemy zaproponowa takie rozwizanie:

char[] znaki = napis.toCharArray();
znaki[0] = Character.toUpperCase(znaki[0]);
napis = String.valueOf(znaki);
Analiz kodu zostawiamy Czytelnikowi.
Zadanie 4.5. WspakStr1.java, Z04_5.java

Podobnie jak w rozwizaniu zadania 3.4, wykorzystamy ptl for ze zmniejszaniem
wartoci zmiennej sterujcej.

public class WspakStr1 {

for(int i = napis.length()-1; i >= 0 ; --i)
System.out.print(napis.charAt(i));
}
}
Porównajmy fragment powyszego kodu z fragmentem rozwizania zadania 3.4:

for(int i = dane.length-1; i >= 0; --i)
System.out.print(dane[i]);
Obiekt napis klasy String ma metod length() zwracajc liczb znaków w a-
cuchu, natomiast obiekt dane typu tablicowego (char[]) ma pole length zawiera-
jce liczb elementów tablicy (w tym przypadku liczb znaków). Ponadto inny jest
sposób odczytywania znaków o podanym indeksie.
Zadanie 4.6. WspakStr2.java, Z04_6.java

Zadanie to moemy rozwiza w trzech krokach: zamieni acuch znaków na tablic
znaków, odwróci kolejno znaków w tablicy (zob. zadanie 3.5), zbudowa acuch
znaków na podstawie odwróconej tablicy.
public class WspakStr2 {
/* Zamiana acucha na tablic znaków */
char[] dane = napis.toCharArray();
/* Odwracanie tablicy znaków. */
for(int i = 0, j = dane.length-1; i < j ; i++, j--) {
char tmp = dane[i];
dane[i] = dane[j];
dane[j] = tmp;
}
/* Zamiana tablicy znaków na acuch */
napis = new String(dane);
}
}
Do utworzenia acucha znaków na podstawie odwróconej tablicy wykorzystalimy

konstruktor (napis = new String(dane)). Moemy zastosowa metod statyczn valueOf
z klasy String (napis = String.valueOf(dane)).

Zadanie 4.7. CyfryStr.java, Z04_7.java

Odrzucilimy proste rozwizanie String cyfry = "0123456789";. Moemy zbudowa
tablic znaków zawierajc cyfry (zob. rozwizanie zadania 3.7) i nastpnie zbudo-
wa na tej podstawie acuch znaków: String cyfry = new String(tablica). Ponie-
wa zadanie ma bardziej charakter poznawczy ni praktyczny, proponujemy modyfi-
kacj rozwizania zadania 3.7 w nastpujcy sposób:
public class CyfryStr {
String cyfry = "";
for(int i = 0; i < 10; ++i)
cyfry += (char)(i+48);
System.out.print("Cyfry ukadu dziesitkowego: ");
}
}
Zwrómy uwag na operator += (podstawianie z dodawaniem — w tym przypadku

dotyczce dodawania acuchów znaków), który skraca zapis wyraenia. Zamiast cy-
fry = cyfry+(char)(i+48) piszemy krócej: cyfry += (char)(i+48). Naley doda, e
w tym przykadzie do acucha znaków dodajemy jeden znak (konwersja znaku na
acuch nastpuje automatycznie w czasie wykonywania tej operacji).
Zastosowane tutaj dodawanie acuchów jest przemienne, wic poprawny bdzie zapis
wyraenia w postaci cyfry = (char)(i+48)+cyfry (nie mamy moliwoci skrócenia
wyraenia za pomoc operatora +=). Jaki bdzie efekt, Czytelnik moe sprawdzi sam.
Takiego zastosowania klasy String nie naley poleca . Kade dodawanie pojedyn-
czego znaku (lub innego acucha) powoduje tworzenie nowego acucha z wynikiem
(na szczcie nie musimy si troszczy o ich usuwanie). Póniej poznasz klasy
StringBuffer i StringBuilder lepiej nadajce si do rozwizywania podobnych zada.
Zadanie 4.8. CyfryStr16.java, Z04_8.java

Do zbudowania acucha cyfr szesnastkowych wykorzystamy statyczn metod for-
Digit z klasy Character.
public class CyfryStr16 {
String cyfry = "";
for(int i = 0; i < 16; ++i)
cyfry += Character.forDigit(i, 16);
cyfry = cyfry.toUpperCase();
}
}
Uwaga zamieszczona w rozwizaniu zadania 4.7 pozostaje aktualna. Zamian maych

liter na wielkie moemy wykona równie podczas tworzenia acucha cyfry (w ptli):
cyfry += Character.toUpperCase(Character.forDigit(i, 16));

Moemy równie skopiowa kod rozwizania zadania 3.8 i uzupeni go o jedn li-
nijk kodu String cyfryHex = String.valueOf(cyfry); lub String cyfryHex = new
String(cyfry);.
5. Tablica argumentów aplikacji

Zadanie 5.1. Argumenty.java, Z05_1.java
Po uruchomieniu aplikacji poleceniem java Argumenty parametr1 parametr2 ... pa-
rametrN system operacyjny przekazuje podane argumenty do aplikacji w postaci tabli-
cy. Deklaracj tej tablicy obowizkowo umieszczamy w nagówku metody main.
Do przegldania tablicy argumentów moemy zastosowa ptl typu for each.

public class Argumenty {
System.out.println("Liczba argumentów "+args.length);
/* Lista argumentów - ptla typu for each */
for(String argument: args)
System.out.println(argument);
}
}
W Javie kada tablica jest obiektem, którego waciwo length zawiera liczb ele-
mentów tablicy. Zatem pole args.length zawiera liczb przekazanych argumentów.
Argumenty w programie s dostpne przy uyciu indeksów od 0 do args.length–1:
args[0], args[1],…, args[N–1], gdzie N oznacza liczb argumentów. Do przegldania
listy argumentów moemy zastosowa ptl typu for.
/* Lista argumentów - ptla typu for */
for(int i = 0; i < args.length; ++i)
System.out.println(args[i]);
Zadanie 5.2. Osoba.java, Z05_2.java

Uruchamiamy w konsoli program poleceniem java Osoba Maria Kowalska. System
operacyjny przekae do tablicy argumentów dwa parametry (imi i nazwisko). W ta-
blicy argumentów mamy zatem args[0] = "Maria" i args[1] = "Kowalska". Zakada-
jc (zgodnie z treci zadania), e uytkownik moe niedokadnie wprowadzi wiel-
ko liter, musimy dokona odpowiednich korekt danych przed ich wywietlaniem.
Nazwisko: Kowalska — rozdzielamy args[1] na dwie czci: pierwszy znak i reszta

acucha; pierwszy znak zamienimy na wielk liter, a reszt acucha wywietlimy
maymi literami:
System.out.println(args[1].substring(0, 1).toUpperCase()
+args[1].substring(1).toLowerCase());
Imi: Maria — rozdzielamy args[0] na dwie czci: pierwszy znak i reszta acucha;
pierwszy znak zamienimy na wielk liter, a reszt acucha wywietlimy maymi
literami:

System.out.println(Character.toUpperCase(args[0].charAt(0))
+args[0].substring(1).toLowerCase());
Nazwisko i imi: KOWALSKA Maria — nazwisko wywietlamy wielkimi literami (args[1].

toUpperCase()), imi tak jak w poprzednim punkcie.
Inicjay: MK — wywietlamy pierwsze litery imienia i nazwiska:

System.out.print(Character.toUpperCase(args[0].charAt(0)));
System.out.println(Character.toUpperCase(args[1].charAt(0)));
Login: KOmar — login budujemy z dwóch pocztkowych liter nazwiska, zapisanych

wielkimi literami (args[1].substring(0, 2).toUpperCase()) i trzech pocztkowych
liter imienia zapisanych maymi literami (args[0].substring(0, 3).toLowerCase()).
import static java.lang.System.out;
public class Osoba {
out.print("Nazwisko: ");
out.println(args[1].substring(0, 1).toUpperCase()+
args[1].substring(1).toLowerCase());
out.print("Imi: ");
out.println(Character.toUpperCase(args[0].charAt(0))+
out.print("Nazwisko i imi: "+args[1].toUpperCase()+" ");
out.println(Character.toUpperCase(args[0].charAt(0))+
out.print("Inicjay: ");
out.print(Character.toUpperCase(args[0].charAt(0)));
out.println(Character.toUpperCase(args[1].charAt(0)));
out.print("Login: ");
out.print(args[1].substring(0, 2).toUpperCase());
out.println(args[0].substring(0, 3).toLowerCase());
}
}
Zwrómy uwag na skrócenie wierszy programu poprzez import statycznego obiektu

out z klasy System i pomijanie nazwy klasy w operacjach wyjcia.
W przykadzie pokazano równie dwa sposoby zamienienia pierwszego znaku acu-

cha na wielk liter: str.toUpperCase().charAt(0) — utworzono acuch zapisany
wielkimi literami i pobrano pierwszy znak, Character.toUpperCase(str.charAt(0))
— pobrano pierwszy znak acucha str i zamieniono na wielk liter.
W podanym rozwizaniu nie zastosowano adnych dodatkowych zmiennych acucho-

wych. Uycie pomocniczych zmiennych mogoby zmniejszy liczb wykonywanych
operacji na acuchach znaków. Pozostawimy to wiczenie do wykonania Czytelnikowi.
Zadanie 5.3. ArgsWspak.java, Z05_3.java

Wywietlanie tablicy argumentów w odwrotnej kolejnoci moemy zrealizowa w ptli
for z odliczaniem w dó, od ostatniego do pierwszego elementu.

public class ArgsWspak {

for(int i = args.length-1; i >= 0; --i)
System.out.print(args[i]+" ");
System.out.println("\b");
}
}
Do kadego argumentu dodawany jest znak odstpu. Za ostatnim argumentem ten znak
jest niepotrzebny (zreszt jest te niewidoczny, ale czasem mógby przeszkadza), wic
kasujemy ten odstp przy uyciu specjalnego znaku '\b' (ang. backspace).
Zadanie 5.4. ArgWspak.java, Z05_4.java

W ptli zewntrznej przegldamy zawarto tablicy argumentów, a w ptli wewntrz-
nej wywietlamy argument w odwrotnej kolejnoci (wspak).
public class ArgWspak {
/* Przegldanie tablicy argumentów - ptla zewntrzna. */
for(String argument : args) {
/* Wywietlanie argumentu wspak */
for(int i = argument.length()-1; i >= 0; --i)
System.out.print(argument.charAt(i));
/* Przejcie do nowego wiersza */
}
}
}
Zadanie 5.5. EtykietaArg.java, Z05_5.java

Podczas wywoania programu podajemy imi i nazwisko jako argumenty. Do trzecie-
go wiersza etykiety (String wiersz = "* *";) musimy
wstawi imi i nazwisko (String tekst = args[0]+" "+args[1];). Najpierw oblicza-
my rónic dugoci tych napisów int znaki = wiersz.length()-tekst.length();.
Z acucha wiersz bierzemy pocztek, poow wyliczonej liczby znaków (wiersz.
substring(0, znaki/2)). Do tego dodajemy imi i nazwisko (tekst) i na koniec dopi-
sujemy reszt znaków, z koca acucha wiersz (wiersz.substring(wiersz.length()
-znaki+znaki/2)).
public class EtykietaArg {
/* Wypiszemy pierwszy i drugi wiersz etykiety. */
System.out.println("******* Programowanie *******");
System.out.println("* obiektowe w jzyku Java *");
/* Budujemy trzeci wiersz etykiety. Do tego wiersza musimy

wstawi imi i nazwisko. */
String wiersz = "* *";
String tekst = args[0]+" "+args[1];
/* Obliczymy, ile znaków z oryginalnego wiersza naley
pozostawi . */
int znaki = wiersz.length()-tekst.length();

/* Poow pozostawionych znaków (pocztek wiersza) wstawimy

przed tekstem. */
String tmp = wiersz.substring(0, znaki/2)+tekst;
/* Reszt znaków (koniec wiersza) dopiszemy po tekcie. */
tmp += wiersz.substring(wiersz.length()-znaki+znaki/2);
/* Wypisujemy trzeci wiersz. */
System.out.println(tmp);
/* Pozosta do wypisania ostatni wiersz etykiety. */

System.out.println("*****************************");
}
}
Wystpujce w obliczeniach dzielenie jest dzieleniem cakowitym, co oznacza, e nie

zawsze wyraenie znaki–znaki/2 ma tak sam warto jak wyraenie znaki/2. Nie-
parzysta liczba znaków nie moe by rozdzielona równomiernie przed tekstem i za
tekstem. W takim przypadku na koniec zostawiamy o jeden znak wicej.
6. Prawda czy fasz

— logiczny typ danych
Zadanie 6.1. OperatoryLogiczne.java, Z06_1.java
Tworzymy tablic bool zawierajc dwa elementy false i true typu boolean.
W ptli for(boolean p: bool) {...} zmienna logiczna p bdzie przyjmowaa kolejno

wartoci false i true. Dziki temu bdziemy mogli utworzy tabelk negacji i testo-
wa prawa logiczne z jednym zdaniem p.
Zagniedajc ptle for(boolean p: bool) for(boolean q: bool) {...}, otrzymamy

par zmiennych logicznych p i q, przyjmujcych kolejno wartoci: (false, false), (false,
true), (true, false) i (true, true). Pozwoli nam to na utworzenie tabelek koniunkcji,
alternatywy i innych funktorów logicznych dwuargumentowych oraz testowanie praw
logicznych z dwoma zdaniami logicznymi p i q.
Powysze uwagi zostan wykorzystane w rozwizaniach zada 6.1, 6.2, 6.3, 6.4, 6.5
i 6.6 oraz innych podobnych.
Do sformatowania (w kolumnach) wyników operacji logicznych uyjemy znaku ta-

bulatora '\t' wewntrz acuchów tworzcych nagówki tabelek (aby uproci kod,
nie rysujemy linii, pozostawiajc to Czytelnikowi) i acucha "\t" zawierajcego znak
tabulatora, czonego z wartociami wywietlanych zmiennych, np. p+"\t"+!p. W za-
daniu wykorzystujemy operator negacji (!), alternatywy (|) i koniunkcji (&).
public class OperatoryLogiczne {
boolean[] bool = {false, true};
System.out.println("Operator negacji (NOT) - !");

System.out.println(" p\t !p");

for(boolean p: bool)
System.out.println(p+"\t"+!p);
System.out.println("Operator koniunkcji (AND) - & lub &&");

System.out.println(" p\t q\tp & q");
for(boolean q: bool)
System.out.println(p+"\t"+q+"\t"+(p & q));
System.out.println("Operator alternatywy (OR) - | lub ||");

System.out.println(" p\t q\tp | q");
System.out.println(p+"\t"+q+"\t"+(p | q));
}
}
Operatory & i | s wykorzystywane równie do przeprowadzania operacji bitowych

na binarnej reprezentacji danych. Poniewa true odpowiada liczbie 1, a false liczbie
0 (w reprezentacji wewntrznej), to obliczenia wykonane na wartociach logicznych
daj waciwy wynik.
Operatory && i || su wycznie do dziaa na wartociach logicznych. S nazy-
wane szybkimi. Od operatorów & i | róni si sposobem wyliczania wartoci. Aby
alternatywa dwóch wyrae bya prawdziwa, wystarczy, e jeden z operandów al-
ternatywy jest prawdziwy. Jeli pierwszy operand alternatywy ma warto true, to
wiadomo, e alternatywa jest prawdziwa (wartoci drugiego operandu nie musimy
oblicza ). W przypadku koniunkcji — jeli pierwszy operand ma warto false, to
cae wyraenie ma warto false.
Zadanie 6.2. PrawaLogiczne.java, Z06_2.java

Badane prawa s zdaniami logicznymi zbudowanymi ze zdania p i poznanych w zada-
niu 6.1 operatorów logicznych. Wartoci zdania p pobieramy z tablicy bool i budujemy
odpowiednie wyraenia logiczne: p || !p — prawo wyczonego rodka, !(p && !p)
— prawo niesprzecznoci, !(!p) == p) — prawo podwójnego przeczenia. W ostat-
nim przypadku jako operator równowanoci wykorzystano operator porównania ==,
który zwraca warto true dla pary zda równowanych (false == false, true ==
true) i warto false dla zda nierównowanych (false == true, true == false).
public class PrawaLogiczne {
System.out.println("Prawo wyczonego rodka - p || !p");

System.out.println(" p\t !p\tp || !p");
System.out.println(p+"\t"+!p+"\t"+(p || !p));

System.out.println("Prawo niesprzecznoci - !(p && !p)");

System.out.println(" p\t !p\tp && !p\t!(p && !p)");
System.out.println(p+"\t"+!p+"\t"+(p && !p)+"\t"+!(p && !p));
System.out.println("Prawo podwójnego przeczenia - !(!p) == p)");

System.out.println(" p\t !p\t!(!p)\t!(!p) == p)");
System.out.println(p+"\t"+!p+"\t"+!(!p)+"\t"+(!(!p) == p));
}
}
Zadanie 6.3. PrawaDeMorgana.java, Z06_3.java

Stosujc tablic bool i zagniedone ptle (zob. komentarz w rozwizaniu zadania 6.1),
moemy zbada prawa De Morgana. W dwóch pocztkowych kolumnach umiesz-
czamy wszystkie moliwe wartoci dla dwóch zda logicznych (p i q). W kolejnych
umieszczamy wartoci porednich wyników, a w ostatniej kolumnie warto caego
zdania (kompletne wyraenie). Uzyskane w ostatniej kolumnie wartoci true wiad-
cz, e to wyraenie jest prawem logicznym.
public class PrawaDeMorgana {
System.out.println("Zaprzeczenie koniunkcji jest równowane
alternatywie zaprzecze ");
System.out.println("p\tq\tp&&q\t!(p&&q)\t!p\t!q\t!p||!q\t!(p&&q)
<=>(!p||!q)");
for(boolean q: bool) {
System.out.print(p+"\t"+q+"\t"+(p&&q)+"\t"+!(p&&q));
System.out.print("\t"+!p+"\t"+!q+"\t"+(!p||!q));
System.out.println("\t"+(!(p&&q)==(!p||!q)));
}
System.out.println("\n");
System.out.println("Zaprzeczenie alternatywy jest równowane
koniunkcji zaprzecze ");
System.out.println("p\tq\tp||q\t!(p||q)\t!p\t!q\t!p&&!q\t!(p||q)
<=>(!p&&!q)");
for(boolean q: bool) {
System.out.print(p+"\t"+q+"\t"+(p||q)+"\t"+!(p||q));
System.out.print("\t"+!p+"\t"+!q+"\t"+(!p&&!q));
System.out.println("\t"+(!(p||q)==(!p&&!q)));
}
System.out.println("\n");
}
}
Zadanie 6.4. Implikacja.java, Z06_4.java, Z06_4a.java

Wykorzystujc rozwizanie zadania 6.2, uwagi z rozwizania zadania 6.1 oraz podan
wskazówk, utworzymy nastpujc aplikacj:

public class Implikacja {

System.out.println("Implikacja - jeeli p, to q");
System.out.println("p\tq\tp=>q");
System.out.println(p+"\t"+q+"\t"+
(Boolean.valueOf(p).compareTo(q) < 1));
}
}
Moemy zdefiniowa wasn metod statyczn realizujc zadania operatora im-

plikacji (proponujemy nazw impl). Wicej szczegóów o definiowaniu metod po-
znasz dalej.
static boolean impl(boolean p, boolean q) {
return (Boolean.valueOf(p).compareTo(q) < 1));
}
Po takiej zmianie otrzymamy nastpujcy kod:
public class Implikacja {
return (Boolean.valueOf(p).compareTo(q) < 1);
}
System.out.println("Implikacja - jeeli p, to q");
System.out.println("p\tq\tp=>q");
System.out.println(p+"\t"+q+"\t"+ impl(p, q));
}
}
Zadanie 6.5. Xor.java, Z06_5.java

Alternatywa wykluczajca (p albo q) realizowana jest przez operator XOR (^) — al-
ternatywa wykluczajca (ang. exclusive or). Moemy równie skorzysta z operatora
nie jest równe (!=), poniewa alternatywa wykluczajca jest prawdziwa, gdy jedno ze
zda jest prawdziwe, a drugie faszywe, czyli gdy ich wartoci logiczne nie s równe.
W rozwizaniu zadania pokaemy i porównamy dziaanie operatora XOR (^) oraz ope-
ratora nie jest równe (!=) dla wartoci logicznych.
public class Xor {
System.out.println("Operator alternatywy wykluczajcej (XOR)
- ^");
System.out.println(" p\t q\tp ^ q");

System.out.println(p+"\t"+q+"\t"+(p ^ q));
System.out.println("Operator nie jest równe - !=");
System.out.println(" p\t q\tp != q");
System.out.println(p+"\t"+q+"\t"+(p != q));
}
}
Zadanie 6.6. Z06_6a.java, Z06_6b.java, Z06_6b.java,

Z06_6d.java, Z06_6e.java
W prawach dowodzonych w podpunktach a), b) i c) mamy prawa logiczne z trzema
zdaniami logicznymi p, q i r. Uyjemy trzech zagniedonych ptli for i tablicy bool
do wygenerowania wszystkich moliwych trójek wartoci logicznych dla zda logicz-
nych p, q i r.
Prawa dowodzone w podpunktach d) i e) zawieraj tylko dwa zdania logiczne p i q.

W zadaniach a), d) i e) wystpuje implikacja. Skorzystamy z metody impl wprowadzo-
nej w rozwizaniu zadania 6.4.
W tabelach wprowadzono dodatkowe oznaczenia A, B, C i D, skracajce opis nagówka

tabeli.
a) Prawo przechodnioci implikacji > p q q r @ p r .
public class PrawoLogiczneA {
}
System.out.println("Prawo przechodnioci implikacji");
System.out.println("p\tq\tr\tp=>q\tq=>r\tA & B\tp=>r\tC=>D");
System.out.println("\t\t\t(A)\t(B)\t(C)\t(D)");
for(boolean p: bool) for(boolean q: bool) for(boolean r: bool) {
System.out.print(p+"\t"+q+"\t"+r);
System.out.print("\t"+impl(p, q)+"\t"+impl(q,r));
System.out.print("\t"+(impl(p, q)&impl(q, r)));
System.out.print("\t"+impl(p,r)+"\t");
System.out.println(impl(impl(p, q)&impl(q, r), impl(p,r)));
}
}
}
b) Prawo rozdzielnoci alternatywy wzgldem koniunkcji

> p q r @ > p q p r @ . W celu uproszczenia zapisu
wprowadzono dodatkowe zmienne a, b, c, d i e typu boolean.
public class PrawoLogiczneB {


System.out.println("Prawo rozdzielnoci alternatywy wzgldem
koniunkcji\n");
System.out.println("p\tq\tr\tq&r\tp|A\tp|q\tp|r\tC&D\tB<=>E ");
System.out.println("\t\t\t(A)\t(B)\t(C)\t(D)\t(E)");
boolean a = q&r;
boolean b = p|a;
boolean c = p|q;
boolean d = p|r;
boolean e = c&d;
System.out.print("\t"+a+"\t"+b+"\t"+c+"\t"+d+"\t"+e+"\t");
System.out.println(b == e);
}
}
}
c) Prawo rozdzielnoci koniunkcji wzgldem alternatywy

> p q r @ > p q p r @ . Podobnie jak w podpunkcie b),
w celu uproszczenia zapisu wprowadzono dodatkowe zmienne
a, b, c, d i e typu boolean.
public class PrawoLogiczneC {
System.out.println("Prawo rozdzielnoci koniunkcji wzgldem
alternatywy\n");
System.out.println("p\tq\tr\tq|r\tp&A\tp&q\tp&r\tC|D\tB<=>E");
System.out.println("\t\t\t(A)\t(B)\t(C)\t(D)\t(E)");
boolean a = q|r;
boolean b = p&a;
boolean c = p&q;
boolean d = p&r;
boolean e = c|d;
System.out.print("\t"+a+"\t"+b+"\t"+c+"\t"+d+"\t"+e+"\t");
System.out.println(b == e);
}
}
}
d) Prawo odrywania > p q q@ q .

Zbudujemy dodatkow klas Impl zawierajc definicj metody impl
zbudowanej w rozwizaniu zadania 6.4. W pliku Impl.java wpisujemy kod:
public class Impl {
}
}

Po skompilowaniu otrzymamy plik Impl.class. Jeli ten plik umiecimy

w biecym folderze, to metoda statyczna impl bdzie dostpna dla
wszystkich klas znajdujcych si w tym samym folderze, czyli w tzw.
pakiecie domylnym. Jest to w tym zbiorze zada pierwszy przykad klasy
niezawierajcej metody main(), czyli niebdcej aplikacj. Metod bdziemy
wywoywa z innych klas, np. Impl.impl(p, q).
public class PrawoLogiczneD {
System.out.println("Prawo odrywania [(p => q) & q] => q\n");
System.out.println("p\tq\tp=>q\tA & q\tB=>q");
System.out.println("\t\t(A)\t(B)");
for(boolean p: bool) for(boolean q: bool) {
boolean a = Impl.impl(p, q);
boolean b = a & q;
System.out.print(p+"\t"+q+"\t"+a+"\t"+b+"\t");
System.out.println(Impl.impl(b, q));
}
}
}
e) Prawo eliminacji implikacji p q p q . Podobnie jak w punkcie d),

skorzystamy z metody impl (zastpujcej operator implementacji)
zdefiniowanej w klasie Impl.
public class PrawoLogiczneE {
System.out.print("Prawo eliminacji implikacji ");
System.out.println("(p => q) <=> (!p|q)\n");
System.out.println("p\tq\tp=>q\t!p\t!p|q\tA<=>B");
System.out.println("\t\t(A)\t\t(B)");
for(boolean p: bool) for(boolean q: bool) {
boolean a = Impl.impl(p, q);
boolean b = !p | q;
System.out.print(p+"\t"+q+"\t"+a+"\t"+(!p)+"\t"+b+"\t");
System.out.println(a == b);
}
}
}
Zadanie 6.7. StringIsEmpty.java, Z06_7.java

Metoda isEmpty zwraca warto true, gdy acuch nie zawiera ani jednego znaku (jest
pusty), i warto false, gdy acuch zawiera co najmniej jeden znak.
public class StringIsEmpty {
String str1 = "";
System.out.println("String: "+str1);
System.out.println("Dugo a cucha: "+str1.length());
System.out.println("Czy string jest pusty? "+str1.isEmpty());
str1 = "Krótki tekst...";

System.out.println("String: "+str1);
System.out.println("Dugo a cucha: "+str1.length());
System.out.println("Czy string jest pusty? "+str1.isEmpty());
}
}
Zadanie 6.8. TestChar.java, Z06_8.java

a) Cig skada si z 7 znaków, s to: wielka litera A, tzw. spacja nierozdzielajca
(kod dziesitny 160, ósemkowy \240), maa litera b, cyfra 3, znak &, cyfra 4
i odstp (spacja — kod dziesitny 32, biay znak).
Program testujcy wywietla znaki wystpujce w acuchu, a nastpnie
tworzy tabel z wynikami testów z uyciem metod isDigit(), isLetter(),
isLetterOrDigit(), isLowerCase(), isSpaceChar(), isUpperCase()
i isWhiteSpace(). W kadej kolumnie znajduj si znak, kod znaku i wyniki
testu dla tego znaku.
public class TestChar {
String str = "A\240b3&4\040"; // podpunkt a)
System.out.println("Znaki: "+str);
char[] znaki = str.toCharArray();
System.out.print("Znak ");
for(char z : znaki)
System.out.print("\t"+z);
System.out.print("Kod znaku ");
for(char z : znaki)
System.out.print("\t"+(int)z);
System.out.print("isDigit() ");
for(char z : znaki)
System.out.print("\t"+Character.isDigit(z));
System.out.print("isLetter() ");
for(char z : znaki)
System.out.print("\t"+Character.isLetter(z));
System.out.print("isLetterOrDigit()");
for(char z : znaki)
System.out.print("\t"+Character.isLetterOrDigit(z));
System.out.print("isLowerCase() ");
for(char z : znaki)
System.out.print("\t"+Character.isLowerCase(z));
System.out.print("isSpaceChar() ");
for(char z : znaki)
System.out.print("\t"+Character.isSpaceChar(z));
System.out.print("isUpperCase() ");
for(char z : znaki)
System.out.print("\t"+Character.isUpperCase(z));
System.out.print("isWhitespace() ");

for(char z : znaki)
System.out.print("\t"+Character.isWhitespace(z));
}
}
Po uruchomieniu programu uzyskamy wynik:

Znaki: A b3&4
Znak A b 3 & 4
Kod znaku 65 160 98 51 38 52 32
isDigit() false false false true false true false
isLetter() true false true false false false false
isLetterOrDigit() true false true true false true false
isLowerCase() false false true false false false false
isSpaceChar() false true false false false false true
isUpperCase() true false false false false false false
isWhitespace() false false false false false false true
b) Cig skada si z 7 znaków, s to: wielka litera , maa litera o, maa litera ,
znak podkrelenia _, cyfra 0, znak + i znak tabulatora (\t — kod dziesitny 9).
W kodzie programu TestChar zmieniamy jeden wiersz: String str = "o_4
-\t";. Dla tego acucha otrzymamy:
Znaki: o_0+
Znak o _ 0 +
Kod znaku 321 111 347 95 48 43
isDigit() false false false false true false
isLetter() true true true false false false
isLetterOrDigit() true true true false true false
isLowerCase() false true true false false false
isSpaceChar() false false false false false false
isUpperCase() true false false false false false
isWhitespace() false false false false false false
Prezentowane znaki s znakami Unicode, co wyra nie wida w przypadku

polskich znaków
i (kody wiksze od 255, dwubajtowe).
c) Cig skada si z 7 znaków, s to: znak #, znak cudzysowu " (znak specjalny
\"), wielka litera Ä (kod ósemkowy \304), znak \ (znak specjalny \\), maa
litera ä (kod ósemkowy \344), znak backspace (znak specjalny \b, kod
dziesitny 8) i znak newline (znak specjalny \n, kod dziesitny 10).
W kodzie programu podstawimy wiersz String str = "#\"\304\\\344\b\n";
i uzyskamy wynik:
Znaki: #"Ä\ä
Znak # " Ä \ ä
Kod znaku 35 34 196 92 228 8 10

isDigit() false false false false false false false
isLetter() false false true false true false false
isLetterOrDigit() false false true false true false false
isLowerCase() false false false false true false false
isSpaceChar() false false false false false false false
isUpperCase() false false true false false false false
isWhitespace() false false false false false false true

7. Liczby cakowite typu int

i klasa Integer
Zadanie 7.1. StaticInteger.java, Z07_1.java
Objanienia staych i wybranych metod statycznych klasy Integer opakowujcej typ
prosty int zawarto w tekcie programu.
public class StaticInteger {
System.out.println("Wybrane stae i metody statyczne klasy
Integer\n");
System.out.println("Warto minimalna typu int: "+
Integer.MIN_VALUE);
System.out.println("Warto maksymalna typu int: "+
Integer.MAX_VALUE);
System.out.println("Rozmiar (w bitach) typu int: "+Integer.SIZE);
int a = 179;
System.out.println("Liczba cakowita a = "+a+
" - zapis (cig cyfr):");
System.out.println("w systemie binarnym: "+
Integer.toBinaryString(a));
System.out.println("w systemie ósemkowym: "+
Integer.toOctalString(a));
System.out.println("w systemie szesnastkowym: "+
Integer.toHexString(a));
System.out.println("w systemie dziesitkowym: "+
Integer.toString(a));
System.out.println("w systemie czwórkowym: "+
Integer.toString(a, 4));
int b = Integer.parseInt("-177");
int c = Integer.parseInt("-177", 8);
System.out.println("Metoda signum():");
System.out.println("Znak liczby a: "+Integer.signum(a));
System.out.println("Znak liczby b: "+Integer.signum(b));
System.out.println("Znak liczby 0: "+Integer.signum(0));
}
}
Zwrómy uwag na moliwo parsowania tego samego cigu znaków (np. "-177")
w ukadach pozycyjnych o rónej podstawie. Skompilujmy i uruchommy ten program
dla rónych wartoci zmiennej a. Porównajmy sposób zapisu liczby dodatniej i ujem-
nej (np. 179 i –179) w rónych systemach liczbowych.
Zadanie 7.2. ObjectInteger.java, Z07_2.java

Objanienia metod zawarto w kodzie lub komentarzach do kodu.
public class ObjectInteger {
System.out.println("Wybrane metody obiektów klasy Integer\n");

/* Konstruktor tworzcy nowy obiekt typu Integer reprezentujcy

podan liczb, w tym przypadku 1024. */
Integer a = new Integer(1024);
/* Konstruktor tworzcy nowy obiekt klasy Integer na podstawie
podanego acucha znaków (cigu cyfr). Zero nieznaczce
zostanie pominite. */
Integer b = new Integer("02000");
/* Statyczna metoda decode() zwraca obiekt reprezentujcy liczb
zakodowan w acuchu znaków - 0 na pocztku oznacza liczb
zapisan w systemie ósemkowym. */
Integer c = Integer.decode("02000");
/* Jw. - pocztek cigu w postaci 0x oznacza liczb zakodowan
w systemie szesnastkowym. */
Integer d = Integer.decode("0x2000");
/* Metoda equals() sprawdza, czy obiekt wywoujcy t metod jest
równy obiektowi podanemu jako parametr. Wynik porównania jest
wartoci logiczn (true albo false). */
System.out.println("Czy obiekt a jest równy obiektowi b? "+
a.equals(b));
System.out.println("Czy obiekt a jest równy obiektowi c? "+
a.equals(c));
/* Metoda compareTo() porównuje obiekt wywoujcy t metod
z obiektem stanowicym parametr. Wynik jest jedn z liczb: -1,
0 i 1. 0 oznacza równo obiektów, -1 oznacza, e pierwszy obiekt (wywoujcy
metod) jest mniejszy od drugiego obiektu (parametru),
a 1 oznacza, e pierwszy obiekt jest wikszy od drugiego). */
System.out.println("Porównanie obiektu a z obiektem c? "+
a.compareTo(c));
System.out.println("Porównanie obiektu c z obiektem d? "+
c.compareTo(d));
System.out.println("Porównanie obiektu d z obiektem c? "+
d.compareTo(c));
/* Metoda statyczna valueOf() zwraca obiekt klasy Integer
reprezentujcy warto okrelon jako parametr - liczba
cakowita lub acuch znaków (cyfr dziesitnych). */
a = Integer.valueOf(1000);
b = Integer.valueOf("1000");
/* Drugi parametr metody statycznej valueOf okrela podstaw
systemu liczbowego, w którym naley zinterpretowa cig cyfr
podany jako pierwszy parametr metody. */
c = Integer.valueOf("1000", 2); // 1000 w ukadzie binarnym
d = Integer.valueOf("1000", 16); // 1000 w ukadzie szesnastkowym
/* Tu wstaw ponownie kod do porównywania obiektów. */
}
}

Metoda obj1.equals(obj2) zwraca warto false, gdy obiekty maj róne warto-
ci, i true w przypadku równych wartoci wszystkich pól obiektów obj1 i obj2 (o ile
w implementacji metody equals() nie zdecydujemy inaczej). Uycie operatora po-
równania obj1 == obj2 zwróci nam wynik porównania referencji obiektów, a nie
ich wartoci.
Metoda obj1.compareTo(obj2) zwraca 0, gdy obiekty s równe; –1, gdy warto
obj1 jest mniejsza od wartoci obj2, albo 1, gdy warto obj1 jest wiksza od
wartoci obj2.
Zadanie 7.3. Dodawanie.java, Z03_3.java

Na listingu przedstawiono trzy warianty rozwizania zadania (w jednym pliku), ró-
nice si sposobem obliczenia i wywietlenia wyniku.
W pierwszym przypadku najpierw jest wywietlany tekst "a + b = " przy uyciu me-
tody print(), a potem obliczana jest warto wyraenia a+b. Wynik przekazany jest
jako parametr wywoania metody println().
W drugim przypadku nastpuje poczenie (dodawanie) tekstu z wynikiem dodawania

wartoci zmiennych. Poniewa dziaania dodawania wykonywane s od strony lewej
do prawej, to do tekstu dodana jest warto zmiennej a (skonwertowanej na tekst),
a nastpnie do wyniku (bdcego acuchem znaków) dodawana jest druga liczba b
(zamieniona na tekst). W efekcie zamiast sumy dwóch liczb otrzymujemy sum a-
cuchów cyfr reprezentujcych te liczby. Aby uzyska prawidowy rezultat, naley
zmieni kolejno wykonywania dziaa (uy nawiasów). Najpierw bdzie obliczona
suma wartoci zmiennych (a+b), a nastpnie wynik zostanie zamieniony na acuch
znaków i doczony z prawej strony tekstu "a + b =".
W trzecim przypadku uywamy dodatkowej zmiennej c do przechowania sumy a+b.

Wywietlenie wyniku nie sprawia nam adnych niespodzianek.
public class Dodawanie {
int a = 2451, b = 375;
System.out.println("a = "+a+", b = "+b);
/* wariant 1. */
System.out.print("a + b = ");
System.out.println(a+b);
/* wariant 2. */
System.out.println("a + b = "+a+b); // bd
System.out.println("a + b = "+(a+b));
/* wariant 3. */
int c = a+b;
System.out.println("a + b = "+c);
}
}

Zadanie 7.4. Z07_4a.java, Z07_4b.java, Z07_4c.java, Z07_4d.java

a) Odejmowanie.java — wzorujc si na rozwizaniu zadania 7.3, zbudujemy
program:
public class Odejmowanie {
int a = 2451, b = 375;
/* Wariant 1. - osobne wywietlanie tekstu i liczby. */
System.out.print("a - b = ");
System.out.println(a-b);
/* Wariant 2. - bdny wynik. */
// System.out.println("a - b = "+a-b); // le
System.out.println("a - b = "+(a-b)); // dobrze
/* Wariant 3. - wprowadzamy dodatkow zmienn c. */
int c = a-b;
System.out.println("a - b = "+c);
}
}
Zauwamy, e w rozwizaniu zadania 7.3 instrukcja System.out.println("a

+ b = "+a+b); dawaa bdny wynik (w stosunku do treci zadania), natomiast
w przypadku odejmowania instrukcja o postaci System.out.println("a — b =
"+a–b); si nie skompiluje. Nie ma odejmowania acuchów znaków! Poniewa
operatory + i – maj ten sam priorytet, naley uy nawiasów w celu zmiany
kolejnoci wykonywania dziaa System.out.println("a — b = "+(a-b));.
b) Mnoenie.java — program ten budujemy w podobny sposób jak program
7.3 i 7.4a.
public class Mnoenie {
int a = 2451, b = 375;
System.out.println("a * b = "+a*b);
}
}
Na powyszym listingu przedstawiono tylko jeden z moliwych wariantów

rozwizania zadania (zob. rozwizania zada 7.3 i 7.4a). Uwaga przedstawiona
w rozwizaniu zadania 7.4a nie jest ju aktualna — operator mnoenia * ma
wyszy priorytet ni operator +, wic uycie nawiasu nie jest konieczne. Kod
w tej postaci skompiluje si i obliczenia zostan wykonane poprawnie.
c) Dzielenie.java — kod jest zupenie podobny do tego z rozwizania zadania
7.4b (operator * zastpiono operatorem /).
public class Dzielenie {
int a = 2451, b = 375;
System.out.println("a / b = "+a/b);
}
}

Operator dzielenia ma wyszy priorytet od operatora dodawania, wic uycie

nawiasów nie jest konieczne (zob. uwagi do rozwiza zada 7.3, 7.4a i 7.4b).
d) Reszta.java — wyraenie a%b oblicza reszt z dzielenia liczby cakowitej
a przez liczb cakowit b. Operator % ma wyszy priorytet od operatora (+).
public class Reszta {
int a = 2451, b = 375;
System.out.println("a % b = "+a%b);
System.out.println("b % a = "+b%a);
}
}
Zadanie 7.5. Dzielenie2.java, Z07_5.java

Dzielenie z reszt wykonujemy dla wybranej pary liczb. Zmieniamy znaki tych liczb
tak, aby uzyska wszystkie moliwe pary znaków dzielnej i dzielnika.
public class Dzielenie2 {
int a = 153, b = 15;
System.out.println("a : b = "+a/b+" r. "+a%b+"\n");
b = -15;
a = -153;
b = 15;
}
}
Zauwamy, e reszta z dzielenia przyjmuje znak dzielnej, natomiast znak ilorazu za-
ley od znaków dzielnej i dzielnika (iloraz jest dodatni, gdy dzielna i dzielnik maj
ten sam znak — ujemny, gdy operandy maj róne znaki).
Zadanie 7.6. Suma.java, Z07_6.java

Z tablicy argumentów odczytujemy dwa argumenty: args[0] i args[1]. Zamieniamy
acuchy znaków na liczby cakowite (stosujemy statyczn metod parseInt z klasy
Integer) i obliczamy ich sum.
public class Suma {
int suma = Integer.parseInt(args[0])+Integer.parseInt(args[1]);
System.out.println("Suma S = "+suma);
}
}

Aplikacj uruchamiamy z dwoma parametrami, np. java Suma 231 -347. Jeli podczas
uruchomienia nie podamy dwóch argumentów lub argumenty nie bd poprawnie za-
pisanymi liczbami, to aplikacja przerwie prac i pojawi si odpowiedni komunikat.
Zadanie 7.7. Sumuj.java

Aplikacj uruchamiamy z kilkoma parametrami, np. java Sumuj 127 -242 391. De-
klarujemy i inicjujemy zmienn cakowit int suma = 0;. Odczytujemy kolejne ar-
gumenty z tablicy args w ptli for, zamieniamy je na liczby cakowite i dodajemy do
zmiennej suma.
public class Sumuj {
int suma = 0;
for(String argument: args)
suma += Integer.parseInt(argument);
System.out.println("Suma S = "+suma);
}
}
W obliczeniach moemy równie posuy si metodami z klasy Integer:

suma += Integer.valueOf(argument).intValue();
Najpierw tworzymy obiekt Integer.valueOf(argument), a nastpnie przy wykorzysta-

niu metody intValue() zwracamy warto jedynego pola obiektu (typ int).
Taki sam efekt uzyskamy z uyciem metody decode():

suma += Integer.decode(argument).intValue();
W tym przypadku argumenty mona podawa równie w postaci szesnastkowej (np.

0xAF, 0XAF lub #1AF0) albo ósemkowej (0742).
Moemy w wyraeniu sumujcym uy polecenia new i konstruktora:

suma += new Integer(argument).intValue();
Gdy pominiemy metod intValue() w powyszych wariantach rozwizania, nie spo-

woduje to bdu (w Javie od wersji 5. wprowadzono autoboxing). Podczas kompilacji
wyraenia obiekt klasy Integer jest automatycznie zamieniany na warto typu int.
Jeli uruchomimy aplikacj bez argumentów, to otrzymamy sum 0. Jeli natomiast który
z parametrów nie bdzie liczb cakowit, to dziaanie programu zostanie przerwane.
Zadanie 7.8. Zamiana.java, Z07_8.java

Aplikacj uruchamiamy z dwoma parametrami — pierwszy parametr interpretujemy
jako podstaw systemu (int radix = Integer.parseInt(args[0])), a drugi bdzie za-
mienian liczb (int n = Integer.parseInt(args[1])). Stosujc metod toString
z klasy Integer, zamieniamy liczb cakowit n na acuch znaków str reprezentuj-
cy t liczb w systemie pozycyjnym o podstawie radix. Podstawa radix powinna by
liczb z zakresu od 2 do 36; wyjcie poza ten zakres nie spowoduje bdów — zosta-
nie przyjta domylna warto podstawy (radix = 10).

public class Zamiana {

int radix = Integer.parseInt(args[0]);
int n = Integer.parseInt(args[1]);
String str = Integer.toString(n, radix);
System.out.println(args[1]+"[10] = "+str+"["+radix+"]");
}
}
Uruchamiajc aplikacj, np. java Zamiana 2 255, otrzymamy wynik 255[10] = 1111
1111[2].
Zadanie 7.9. Zamiana2.java, Z07_9.java

Pierwszy parametr interpretujemy jako podstaw systemu (int radix = Integer.parse
Int(args[0])), a drugi bdzie cigiem cyfr w systemie pozycyjnym o podstawie ra-
dix. Stosujc metod parseInt z klasy Integer, zamieniamy acuch znaków args[1]
reprezentujcy liczb w systemie o podstawie radix na liczb w systemie dziesitko-
wym (int n = Integer.parseInt(args[1], radix)).
public class Zamiana2 {
int radix = Integer.parseInt(args[0]);
int n = Integer.parseInt(args[1], radix);
System.out.println(args[1]+"["+radix+"] = "+n+"[10]");
}
}
Wywoujc aplikacj, np. java Zamiana2 2 11111111, otrzymamy wynik 11111111[2]

= 255[10]. Podanie podstawy wykraczajcej poza dopuszczalny zakres lub cigów
znaków niebdcych liczbami w wybranym systemie spowoduje przerwanie programu.
8. Inne typy liczb cakowitych w Javie

Zadanie 8.1. LongNumber.java, Z08_1.java, Z08_1a.java
Po skompilowaniu i uruchomieniu aplikacji (z listingu 8.1) otrzymamy w konsoli taki
wynik:
n = 9223372036854775807
BIN: 111111111111111111111111111111111111111111111111111111111111111
HEX: 7fffffffffffffff
m = -9223372036854775808
BIN: 1000000000000000000000000000000000000000000000000000000000000000
HEX: 8000000000000000
Zamiana na typ int, m = -1
BIN: 11111111111111111111111111111111
HEX: ffffffff
Zamiana na typ int, m = 0
BIN: 0
HEX: 0

Przeanalizujmy fragmenty kodu ródowego:

long n = Long.MAX_VALUE;
System.out.println("n = "+n);
System.out.println("BIN: "+Long.toBinaryString(n));
System.out.println("HEX: "+Long.toHexString(n));
Najwiksz liczb cakowit dodatni 64-bitow ze znakiem (typu long) jest 263–1
(n = 9223372036854775807). W klasie opakowujcej Long reprezentuje t liczb staa
MAX_VALUE. Stosujc statyczn metod toBinaryString dla tej liczby, zobaczymy jej
posta binarn — cig 63 cyfr 1; szedziesity czwarty (najstarszy) bit ma warto 0
i nie jest wywietlany (pominicie tzw. zer nieznaczcych). W postaci szesnastkowej,
uzyskanej metod statyczn toHexString, otrzymujemy szesnacie cyfr — cyfr 7 (bi-
narnie 0111) i pitnacie cyfr f (binarnie 1111, dziesitnie 15).
long m = n+1;
System.out.println("m = "+m);
System.out.println("BIN: "+Long.toBinaryString(m));
System.out.println("HEX: "+Long.toHexString(m));
Po dodaniu liczby 1 otrzymamy (zgodnie z reguami dziaa na liczbach binarnych)

cig bitów zoony z jedynki i 63 zer. Odpowiada to liczbie dziesitnej –263 (–9223
372036854775808). Najstarszy bit (1) jest w tym przypadku bitem znaku i oznacza
liczb ujemn (w kodzie uzupenie do dwóch). W postaci szesnastkowej mamy cyfr
8 (binarnie 1000) i pitnacie cyfr 0 (binarnie 0000).
Long max = new Long(n);
System.out.println("Zamiana na typ int, m = "+max.intValue());
System.out.println("BIN: "+Integer.toBinaryString(max.intValue()));
System.out.println("HEX: "+Integer.toHexString(max.intValue()));
Tworzymy obiekt max (reprezentujcy liczb n) klasy opakowujcej Long. Stosujc me-
tod intValue, otrzymamy liczb typu int równ –1 (w postaci binarnej 11111111111
111111111111111111111 — 32 bity 1). Z liczby omiobajtowej (long) obcito cztery
starsze bajty i zostawiono reszt (cztery modsze bajty) — liczb 32-bitow typu int.
Podobny efekt mona uzyska, wykonujc rzutowanie liczby typu long na typ int.
System.out.println("Zamiana na typ int, m = "+(int)m);
System.out.println("BIN: "+Integer.toBinaryString((int)m));
System.out.println("HEX: "+Integer.toHexString((int)m));
Przy wywietlaniu liczb zostay pominite zera nieznaczce.
Zmieniajc warto zmiennej n na minimaln oraz biorc liczb m o jeden mniejsz

(Long n = new Long(Long.MIN_VALUE); Long),
otrzymamy taki rezultat:

n = -9223372036854775808
BIN: 1000000000000000000000000000000000000000000000000000000000000000
HEX: 8000000000000000
m = 9223372036854775807
BIN: 111111111111111111111111111111111111111111111111111111111111111

HEX: 7fffffffffffffff
Zamiana na typ int, m = 0
BIN: 0
HEX: 0
Zamiana na typ int, m = -1
BIN: 11111111111111111111111111111111
HEX: ffffffff
Analiz wyniku pozostawiamy Czytelnikowi.
Zadanie 8.2. MinMax.java, Z08_2.java

Liczba cakowita n-bitowa ze znakiem ma najmniejsz warto –2n–1 (bit 1 i n–1 bi-
tów 0) i najwiksz warto 2n–1–1 (n bitów 1). W Javie typy proste byte, short, int
i long s typami liczb cakowitych ze znakiem, o dugoci (odpowiednio do kolejno-
ci podanych nazw) 8, 16, 32 i 64 bitów. Nie musimy oblicza wartoci granicznych
wedug podanej wyej zasady, gdy klasy opakowujce Byte, Short, Integer i Long
zawieraj odpowiednie stae MIN_VALUE i MAX_VALUE.
public class MinMax {
System.out.println("byte <"+
Byte.MIN_VALUE+", "+Byte.MAX_VALUE+">");
System.out.println("short <"+Short.MIN_VALUE+", "+
Short.MAX_VALUE+">");
System.out.println("int <"+Integer.MIN_VALUE+
", "+Integer.MAX_VALUE+">");
System.out.println("long <"+Long.MIN_VALUE+
", "+Long.MAX_VALUE+">");
}
}
Po wykonaniu programu otrzymamy wynik:

byte <-128, 127>
short <-32768, 32767>
int <-2147483648, 2147483647>
long <-9223372036854775808, 9223372036854775807>
Zadanie 8.3. MaxPositive.java, Z08_3.java

W rozwizaniu zadania wykorzystamy stae z klas opakowujcych proste typy liczbowe:
Byte.MAX_VALUE, Short.MAX_VALUE, Integer.MAX_VALUE i Long.MAX_VALUE, a take me-
tody toBinaryString i toHexString — z klasy Integer dla typów byte, short i int oraz
z klasy Long dla typu long (lub wszystkich wymienionych typów).
public class MaxPositive {
System.out.print("byte "+
Integer.toBinaryString(Byte.MAX_VALUE));
System.out.println("\t"+Integer.toHexString(Byte.MAX_VALUE));
System.out.print("short "+
Integer.toBinaryString(Short.MAX_VALUE));
System.out.println("\t"+Integer.toHexString(Short.MAX_VALUE));
System.out.print("int "+
Integer.toBinaryString(Integer.MAX_VALUE));

System.out.println("\t"+Integer.toHexString(Integer.MAX_VALUE));
System.out.print("long "+Long.toBinaryString(Long.MAX_VALUE));
System.out.println("\t"+Long.toHexString(Long.MAX_VALUE));
}
}
Zadanie 8.4. Kodowanie.java, Z08_4.java, Z08_4a.java

Po uruchomieniu aplikacji:
public class Kodowanie {
String napis = "kodowanie";
System.out.println("Tekst: "+napis);
System.out.print("Cig bajtów:");
byte[] kod = napis.getBytes();
for(byte n : kod)
System.out.print(" "+n+",");
System.out.println("\b.");
}
}
uzyskamy nastpujcy wynik:

Tekst: kodowanie
Cig bajtów: 107, 111, 100, 111, 119, 97, 110, 105, 101.
Zwrómy uwag na sposób wywietlania poszczególnych elementów tablicy (w p-

tli): odstp, liczba i przecinek. Przecinek po ostatniej liczbie kasujemy, wpisujc znak
\b (ang. backspace), a nastpnie stawiamy kropk.
Jeli skorzystamy z klasy Arrays (potrzebny bdzie import klasy java.util.Arrays)

opakowujcej typy tablicowe, to moemy tablic bajtów kod zamieni na acuch zna-
ków w postaci [107, 111, 100, 111, 119, 97, 110, 105, 101] i wywietli go w kon-
soli. Uyjemy do tego celu statycznej metody Arrays.toString(), np.:
System.out.print("Cig bajtów: ");
System.out.println(Arrays.toString(napis.getBytes()));
Zadanie 8.5. Dekodowanie.java, Z08_5.java

Na podstawie cigu bajtów tworzymy tablic bajtów byte[] kod = {115, 122, 121,
102, 114}, wywietlamy zawarto tablicy w konsoli (zob. drugi wariant rozwizania
zadania 8.4). Na podstawie tablicy bajtów (kod) tworzymy acuch znaków — klasa
String posiada odpowiedni konstruktor (String wynik = new String(kod)).
import java.util.Arrays;
public class Dekodowanie {
byte[] kod = {115, 122, 121, 102, 114};
System.out.println("Cig bajtów: "+Arrays.toString(kod));
String wynik = new String(kod);
System.out.println("Tekst: "+wynik);
}
}

Zadanie 8.6. DodajCyfry.java, Z08_6a.java, Z08_6b.java

a) Liczba podana w postaci acucha znaków (cyfr) nie ma waciwie
ograniczenia liczby cyfr powodowanego zakresem cakowitych typów
liczbowych w Javie. Cig cyfr zamieniamy na cig (tablic) odpowiadajcych
im bajtów. Podczas sumowania od kolejnych bajtów odejmujemy 48 (kod 0)
i uzyskujemy warto liczbow odpowiedniej cyfry.
public class DodajCyfry {
String liczba = "3784596320";
byte[] kod = liczba.getBytes();
int suma = 0;
for(byte c: kod)
suma += c-48;
System.out.println("Liczba naturalna: "+liczba);
System.out.println("Suma cyfr: "+suma);
}
}
b) Jeli liczba zapisana jest w pamici w postaci numerycznej (proponujemy

uy typu o najwikszym zakresie, czyli long), to zamieniamy j na acuch
znaków:
long n = 3784596320L;
String liczba = Long.toString(n);
i kontynuujemy obliczenia wedug podpunktu a). Naley zwróci uwag na

sposób zainicjowania zmiennej n — liczby cakowite wiksze od Integer.
MAX_VALUE (2147483647) s liczbami typu long i reprezentujce je literay
musz by zakoczone liter L (mona równie uy maej litery l, ale ten
znak moemy pomyli z cyfr 1). Najwiksz liczb, dla której moemy to
zadanie wykona, jest Long.MAX_VALUE, czyli 9223372036854775807.
Zadanie 8.7. Txt2Hex.java, Z08_7.java

Podobnie jak w rozwizaniu zadania 8.4, zamienimy acuch znaków (String napis
= "szyfr") na cig bajtów zapisany w tablicy kod (byte[] kod = napis.getBytes()).
Wywietlajc zawarto tablicy, zamienimy liczby (n typu byte) na ich reprezentacj
szesnastkow (Integer.toHexString(n).toUpperCase()).
public class Txt2Hex {
String napis = "szyfr";
System.out.print(napis+" -> ");
byte[] kod = napis.getBytes();
for(byte n : kod)
System.out.print(Integer.toHexString(n).toUpperCase());
}
}
Zadanie 8.8. Hex2Txt.java, Z08_8.java

acuch hex zawiera zakodowany cig znaków (String hex = "737A796672"). Kade
dwie cyfry szesnastkowe (bajt) odpowiadaj jednemu znakowi. Tworzymy tablic

bajtów o rozmiarze dwa razy mniejszym od rozmiaru acucha hex (byte[] tmp = new
byte[hex.length()/2]). W ptli for z acucha hex pobieramy po dwie cyfry szesnast-
kowe (hex.substring(2*i,2*i+2)), zamieniamy je na liczby i przechowujemy w tablicy
tmp. Na koniec zamieniamy tablic bajtów na acuch znaków (new String(tmp)).
public class Hex2Txt {
String hex = "737A796672";
System.out.print(hex+" -> ");
byte[] tmp = new byte[hex.length()/2];
for(int i = 0; i < tmp.length; ++i)
tmp[i] = Byte.parseByte(hex.substring(2*i,2*i+2), 16);
System.out.println(new String(tmp));
}
}
9. Typy liczb zmiennoprzecinkowych

Zadanie 9.1. DemoDouble.java, Z09_1.java
Zobaczmy wyniki pracy programu:
Minimalna warto dodatnia: 4.9E-324
BIN: 1
HEX: 0x0.0000000000001p-1022
Liczba przeciwna: -4.9E-324
BIN: 1000000000000000000000000000000000000000000000000000000000000001
HEX: -0x0.0000000000001p-1022
Staa Double.MIN_VALUE ma warto najmniejszej liczby dodatniej moliwej do przed-

stawienia w postaci liczby zmiennoprzecinkowej podwójnej precyzji (typu double),
czyli warto 4.9E-324 (4,9·10–324). Jej reprezentacja binarna ma posta (64 bity, w kon-
soli zera nieznaczce zostay pominite):
0000000000000000000000000000000000000000000000000000000000000001
W skad tej reprezentacji wchodz: 0 (0 oznacza liczb dodatni), 11 bitów cechy 000
00000000 i 52 bity mantysy 0000000000000000000000000000000000000000000000000001.
Poniewa wszystkie bity cechy s zerami, wic mantysa jest zdenormalizowana (bez
bitu cakowitego 1) i ma posta binarn 0,00000000000000000000000000000000000000
00000000000001 (cyfra 1 na pidziesitej drugiej pozycji po przecinku), a to odpo-
wiada liczbie dziesitnej 2–52. Mnoc mantys przez liczb 21–1023, uzyskamy warto
2-52·21–1023 = 2–1074 = 4,9·10–324.
Zapis binarny liczby przeciwnej róni si jedynie bitem znaku: 1 oznacza liczb ujemn.
W programie zastosowano nastpujce elementy statyczne z klas Double i Long:

Double.MIN_VALUE — staa o wartoci najmniejszej liczby dodatniej typu
double,

long Double.doubleToLongBits(double) — metoda zamieniajca liczb

zmiennoprzecinkow typu double na liczb cakowit typu long o identycznej
reprezentacji binarnej,
String Long.toBinaryString(long) — metoda zamieniajca liczb
cakowit typu long na acuch zawierajcy reprezentacj binarn tej liczby
(z pominiciem zer nieznaczcych),
String Double.toHexString(double) — metoda zamieniajca liczb
zmiennoprzecinkow typu double na acuch znaków heksadecymalnych
reprezentujcych t liczb; np. w cigu znaków 0x0.0000000000001p-1022
kolejne elementy oznaczaj:
0x — liczba jest zapisana w kodzie szesnastkowym;
0.0000000000001 — zdenormalizowana mantysa — cyfra jednoci 0,
13 cyfr szesnastkowych po przecinku (13·4 = 52 bity mantysy);
p–1022 — wykadnik (–1022) zapisany w kodzie dziesitkowym
(podstaw potgi jest 2).
Zapis ten reprezentuje liczb zmiennoprzecinkow o wartoci mantysa·21022.
Zadanie 9.2. DoubleBin.java, Z09_2.java

acuch zero zawierajcy 63 znaki 0 przyda si do uzupeniania zer nieznaczcych do
64 bitów w liczbach dodatnich, dla których metoda toBinaryString zera nieznaczce
pomija. Liczby lub symbole, których posta binarn chcemy pozna, umieszczamy
w tablicy double[] a = {...}. W ptli pobieramy elementy (for(double x : a)...)
tej tablicy, wywietlamy ich posta zmiennoprzecinkow w konsoli (System.out.println
("x = "+x)), zamieniamy liczb x typu double na liczb typu long, majc identyczn
reprezentacj binarn (Double.doubleToLongBits(x)), a t liczb typu long przedsta-
wiamy w postaci binarnej (String tmp = Long.toBinaryString(...)) — acuch tmp.
Z acucha tmp tworzymy acuch bin o dugoci 64 znaków (sowo 64-bitowe), do-
dajc zera (nieznaczce) na pocztku acucha.
Z acucha bin wybieramy bit znaku (bin.charAt(0)), cech (bin.substring(1, 12))

i mantys (bin.substring(12)), przedstawiajc w ten sposób binarn posta liczby
lub symbolu zmiennoprzecinkowego.
public class DoubleBin {
static String zero =
"0000000000000000000000000000000000000000000000000000000000000000";
double[] a = {0.25, 0.5, 1.0, 2.0, 512.0}; /* podpunkt a) */
for(double x : a) {
System.out.println("x = "+x);
String tmp = Long.toBinaryString(Double.doubleToLongBits(x));
String bin = zero.substring(0, 64-tmp.length())+tmp;
System.out.println("BIN: "+bin);
System.out.println("Bit znaku: "+bin.charAt(0));
System.out.println("Cecha: "+bin.substring(1, 12));
System.out.println("Mantysa: "+bin.substring(12));

}
}
}
a) Wybrane potgi liczby: 0,25; 0,5; 1,0; 2,0; 512,0.

x = 0.25
BIN: 0011111111010000000000000000000000000000000000000000000000000000
Bit znaku: 0
Cecha: 01111111101
Mantysa: 0000000000000000000000000000000000000000000000000000
x = 0.5
BIN: 0011111111100000000000000000000000000000000000000000000000000000
Bit znaku: 0
Cecha: 01111111110
Mantysa: 0000000000000000000000000000000000000000000000000000
x = 1.0
BIN: 0011111111110000000000000000000000000000000000000000000000000000
Bit znaku: 0
Cecha: 01111111111
Mantysa: 0000000000000000000000000000000000000000000000000000
x = 2.0
BIN: 0100000000000000000000000000000000000000000000000000000000000000
Bit znaku: 0
Cecha: 10000000000
Mantysa: 0000000000000000000000000000000000000000000000000000
x = 512.0
BIN: 0100000010000000000000000000000000000000000000000000000000000000
Bit znaku: 0
Cecha: 10000001000
Mantysa: 0000000000000000000000000000000000000000000000000000
Wszystkie liczby s dodatnie (bit znaku 0). Ich cechy s róne od zera, wic
mantysy s znormalizowane i równe (binarnie 1,0000…) 1. Cechy kolejnych
liczb s równe binarnie 01111111101, 01111111110, 01111111111,
10000000000 i 10000001000, co odpowiada liczbom dziesitnym 1021,
1022, 1023, 1024 i 1032. Po uwzgldnieniu przesunicia –1023 otrzymamy
wykadniki –2, –1, 0, 1 i 9. Poniewa mantysa jest równa 1 dla wszystkich
liczb z podanego zestawu, to wartoci tych liczb s równe 2–2 = 0,25; 2–1 = 0,5;
20 = 1; 21 = 2 i 29 = 512.
b) Podane liczby s potgami liczby 10.
double[] a = {0.01, 0.1, 1.0, 10.0, 100.0};
W postaci binarnej nie dostrzeemy adnego zwizku pomidzy tymi

liczbami.
c) Podane liczby s liczbami dziesitnymi zapisanymi przy uyciu tych
samych cyfr i róni si pooeniem przecinka dziesitnego.
double[] a = {1.367, 1367, 1.367e-12, 1.367e12, 13.67, -13.67};

W postaci binarnej nie dostrzeemy adnych podobiestw, z wyjtkiem

ostatnich dwu liczb, które s liczbami przeciwnymi (róni si bitem znaku).
d) Symbole specjalne (NaN i rf ).
double[] a = {Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY};
Wszystkie symbole specjalne maj cech zoon z samych bitów 1. Mantysa

znaku NaN (ang. Not a Number) skada si z bitu 1 i 51 bitów 0.
x = NaN
BIN: 0111111111111000000000000000000000000000000000000000000000000000
Bit znaku: 0
Cecha: 11111111111
Mantysa: 1000000000000000000000000000000000000000000000000000
Symbole nieskoczonoci maj mantysy zoone z bitów 0, a bit znaku

decyduje o znaku wartoci.
x = -Infinity
BIN: 1111111111110000000000000000000000000000000000000000000000000000
Bit znaku: 1
Cecha: 11111111111
Mantysa: 0000000000000000000000000000000000000000000000000000
x = Infinity
BIN: 0111111111110000000000000000000000000000000000000000000000000000
Bit znaku: 0
Cecha: 11111111111
Mantysa: 0000000000000000000000000000000000000000000000000000
e) Dwie reprezentacje zera (dodatnia i ujemna) oraz dodatnie wartoci

ekstremalne.
double[] a = {0.0, -0.0, Double.MIN_VALUE, Double.MAX_VALUE,
2.2250738585072014e-308};
Cecha i mantysa skadaj si z samych bitów 0. To reprezentacja liczby 0.0.

Jedynie bit znaku moe przyjmowa warto 0 lub 1. Mamy zatem dwie
reprezentacje binarne zera w liczbach zmiennoprzecinkowych — w informatyce
uywamy czasem wyrae „zero dodatnie” i „zero ujemne”.
x = 0.0
BIN: 0000000000000000000000000000000000000000000000000000000000000000
Bit znaku: 0
Cecha: 00000000000
Mantysa: 0000000000000000000000000000000000000000000000000000
x = -0.0
BIN: 1000000000000000000000000000000000000000000000000000000000000000
Bit znaku: 1
Cecha: 00000000000
Mantysa: 0000000000000000000000000000000000000000000000000000
T warto (najmniejsz moliw do zapisania liczb dodatni — sta

Double.MIN_VALUE) omówiono dokadnie w rozwizaniu zadania 9.1
(mantysa tej liczby nie jest znormalizowana).

x = 4.9E-324
BIN: 0000000000000000000000000000000000000000000000000000000000000001
Bit znaku: 0
Cecha: 00000000000
Mantysa: 0000000000000000000000000000000000000000000000000001
Najwiksza moliwa do zapisania liczba zmiennoprzecinkowa (staa Double.

MAX_VALUE) ma cech 11111111110 (najwiksz, jak mona zapisa na 11
bitach, bo cecha 11111111111 jest zarezerwowana dla symboli specjalnych)
i mantys (znormalizowan) zoon z samych bitów 1.
x = 1.7976931348623157E308
BIN: 0111111111101111111111111111111111111111111111111111111111111111
Bit znaku: 0
Cecha: 11111111110
Mantysa: 1111111111111111111111111111111111111111111111111111
Binarna mantysa 1,1111111111111111111111111111111111111111111111111111

po przeliczeniu na ukad dziesitkowy ma warto 2–2–52, cecha 11111111110
ma warto 2046, wic warto dziesitna tej liczby wynosi (2–2–52)·22046–1023
= (2–2–52)·21023 = 1,7976931348623157·10308.
Kolejna liczba jest najmniejsz liczb dodatni o znormalizowanej mantysie
1,0·21–1023 = 2–1022 = 2,2250738585072014·10-308.
x = 2.2250738585072014E-308
BIN: 0000000000010000000000000000000000000000000000000000000000000000
Bit znaku: 0
Cecha: 00000000001
Mantysa: 0000000000000000000000000000000000000000000000000000
Zadanie 9.3. Bin2Float.java, Z09_3.java

Cig bitów o dugoci nieprzekraczajcej 32 znaków zapisujemy w acuchu bin.
Obliczmy warto cakowit n odpowiadajc podanemu acuchowi cyfr binarnych
(int n = Integer.parseInt(bin, 2)). Liczb cakowit typu int zamieniamy na licz-
b zmiennoprzecinkow typu float o identycznej reprezentacji binarnej (float x =
Float.intBitsToFloat(n)).
public class Bin2Float {
String bin ="111110000011110000111000110010";
int n = Integer.parseInt(bin, 2);
float x = Float.intBitsToFloat(n);
System.out.println("bin: "+bin);
System.out.println("int: "+n);
System.out.println("float: "+x);
}
}
Cig bitów 111110000011110000111000110010 reprezentuje liczb zmiennoprzecin-

kow (float) 0,13970259.

Zadanie 9.4. Bin2Double.java, Z09_4.java

Cig bitów o dugoci nieprzekraczajcej 64 znaków zapisujemy w acuchu bin. Ob-
liczmy warto cakowit n (64-bitow, typu long) odpowiadajc podanemu acu-
chowi cyfr binarnych (long n = Integer.parseLong(bin, 2)). Liczb cakowit typu
long zamieniamy na liczb zmiennoprzecinkow typu double o identycznej reprezen-
tacji binarnej (double x = Double.longBitsToDouble(n)).
public class Bin2Double {
String bin ="111110000011110000111000110010";
long n = Long.parseLong(bin, 2);
double x = Double.longBitsToDouble(n);
System.out.println("bin: "+bin);
System.out.println("long: "+n);
System.out.println("double: "+x);
}
}
Cig bitów 111110000011110000111000110010 reprezentuje liczb zmiennoprze-

cinkow (double) 5,144083374E-315 (porównaj ten wynik z wynikiem uzyskanym
w zadaniu 9.3).
Zadanie 9.5. Bin2Double.java, Z09_5.java

W symbolach specjalnych cecha ma wszystkie bity równe 1 (w cigach bitów sym-
bole te zostay wyrónione przez pogrubienie). Oto reprezentacje binarne trzech sym-
boli specjalnych):
nieskoczono ujemna ( f ) 11111111100000000000000000000000,
nieskoczono dodatnia ( f ) 01111111100000000000000000000000,
nie liczba (NaN) 01111111111111111111111111111111 (co najmniej najstarszy
bit mantysy musi by równy 1).
public class TestBinFloat {
float x = Float.intBitsToFloat(Integer.parseInt(args[0], 2));
System.out.println(args[0]+" -> "+x);
}
}
Kod wyglda na poprawny, ale niestety kopoty sprawia metoda Integer.parseInt

(String, int), która nie akceptuje (zgodnie z dokumentacj) cigów cyfr binarnych
32-bitowych, majcych najstarszy bit 1 (liczby cakowite ujemne w kodzie uzupenie
do 2), natomiast dopuszcza zastosowanie znaku – (minus) przed cigiem cyfr binar-
nych, nie duszym ni 31 bitów.
Aby wyznaczy liczb typu float majc reprezentacj binarn 111111111000000000

00000000000000, powinnimy zanegowa w tym cigu wszystkie bity 0000000001111
1111111111111111111, a nastpnie doda 1 (dodawanie zgodnie z reguami dodawania
liczb w systemie binarnym). Otrzymamy w ten sposób cig cyfr 000000001000000000
00000000000000, przed którym stawiamy znak minus (–00000000100000000000000000

000000). Zera nieznaczce mona pomin — ich obecno jednak nie wpywa na wy-
nik (w tym przypadku –Infinity, czyli nieskoczono ujemna).
Rozwaana sytuacja nie obejmuje najmniejszej liczby typu int (binarnie 1000000000
0000000000000000000000), której w typie float odpowiada warto –0.0 (zero ujem-
ne!). Moemy o tym si przekona, wykorzystujc nastpujcy wiersz kodu:
System.out.println(Float.intBitsToFloat(Integer.MIN_VALUE));

Rozdzia 6.
Rozwizania zada
10. Wywietlanie sformatowanych
wyników w konsoli. Stae i metody
z klasy Math
Zadanie 10.1. Z10_1.java
Najprostszym rozwizaniem jest uycie metody printf() wprowadzonej w J2SE ver.
5.0 (1.5). Umieszczony w acuchu formatujcym "4/7 = %.5f\n" cig znaków %.5f
jest specyfikatorem okrelajcym, e parametr x podstawiony w miejsce specyfikatora
ma by zinterpretowany jako liczba zmiennoprzecinkowa (f) i wywietlona z precyzj
5 miejsc po przecinku (.5). Symbol % sygnalizuje, e wystpujce po nim znaki two-
rz specyfikator.
double x = (double)4/7;
System.out.printf("4/7 = %.5f\n", x);
}
}
Poznane wczeniej metody print() i println() równie pozwalaj wywietli liczby

z okrelon precyzj, pod warunkiem e odpowiednio zaokrglimy wynik. Pomnómy
warto zmiennej x przez 100000 (przesunicie przecinka o 5 miejsc w prawo), dodaj-
my 0.5 i obetnijmy cz uamkow liczby (konwersja liczby zmiennoprzecinkowej
na liczb cakowit przez rzutowanie), a nastpnie podzielmy wynik przez 100000.0
(dzielimy liczb cakowit przez liczb zmiennoprzecinkow, aby uzyska wynik
zmiennoprzecinkowy). Otrzymany rezultat jest poprawnym zaokrgleniem wartoci
x do 5 miejsc po przecinku.
double y = (int)(100000*x+0.5)/100000.0;
System.out.println("4/7 = "+y);

Moemy zastosowa zaokrglenie przy uyciu metody round().

y = Math.round(100000*x+0.5)/100000.0;
Podobne obliczenia moemy zrealizowa z zastosowaniem obiektu klasy Double.

y = new Double(100000*x+0.5).intValue()/100000.0;
Inn moliwo stwarza metoda format() klasy String:

System.out.println(String.format("4/7 = %.5f", x));
Zauwamy podobiestwo pomidzy pierwszym i ostatnim przypadkiem (sposób

tworzenia acucha znaków). Uzyskany wynik jest zgodny z ustawieniami lokalnymi
komputera: 0,57143 (przecinek dziesitny). W pozostaych przypadkach metoda
println() wywietla liczby dziesitne z kropk.

W pakiecie java.lang zdefiniowano klas Math zawierajc wartoci przyblione sta-
ych e i S oraz róne funkcje matematyczne. Dostp do staych lub funkcji otrzymu-
jemy, podajc nazw klasy, kropk i nazw staej lub funkcji, np. Math.E, Math.PI
(nazwy staych piszemy zwyczajowo wielkimi literami1) lub Math.sqrt(x) — x jest
argumentem funkcji sqrt (ang. square root — pierwiastek kwadratowy).
System.out.printf("Liczba e = %15.10f\n", Math.E);
System.out.printf("Liczba pi = %15.10f\n", Math.PI);
System.out.printf("Liczba fi = %15.10f\n", (1+Math.sqrt(5))/2);
}
}
Moemy statycznie importowa klas Math i w zapisie wzorów pomin nazw klasy.
import static java.lang.Math.*;
public class Z10_2a {
System.out.printf("Liczba e = %15.10f\n", E);
System.out.printf("Liczba pi = %15.10f\n", PI);
System.out.printf("Liczba fi = %15.10f\n", (1+sqrt(5))/2);
}
}

W klasie Math oprócz funkcji sqrt() obliczajcej pierwiastek kwadratowy zdefiniowano
funkcj cbrt() obliczajc pierwiastek trzeciego stopnia (ang. cube root — pierwiastek
szecienny). W ptli typu for each zmienna n przyjmuje kolejno wartoci zapisane
w tablicy dane. Dla kadej wartoci zmiennej n metoda printf() wywietla w konsoli
zgodnie z acuchem formatujcym:
1
Standard kodowania zaleca pisanie nazw staych wielkimi literami; ostateczna decyzja w tej sprawie
naley do programujcego.

%3d — na polu o szerokoci 3 znaków liczb cakowit n;

%15.8f — na polu o szerokoci 15 znaków liczb zmiennoprzecinkow
(warto wyraenia sqrt(n)) z dokadnoci do 8 miejsc po przecinku;
%15.8f — na polu o szerokoci 15 znaków liczb zmiennoprzecinkow
(warto wyraenia cbrt(n)) z dokadnoci do 8 miejsc po przecinku;
\n — znak koca linii; kursor przechodzi na pocztek nowego wiersza.
import static java.lang.Math.*;
int[] dane = {2, 3, 5, 7, 9, 11, 13, 17};
for(int n : dane)
System.out.printf("%3d%15.8f%15.8f\n", n, sqrt(n), cbrt(n));
}
}

Funkcja pow (ang. power — potga) z klasy Math posiada dwa parametry. Pierwszy jest
1
n
podstaw, a drugi wykadnikiem obliczanej potgi. Wzór x 5 5 n moemy zapi-
sa w postaci x = Math.pow(5, 1.0/n).
int[] dane = {2, 3, 4, 5, 6, 7, 8, 9, 10};
for(int n : dane) {
double x = Math.pow(5, 1.0/n);
System.out.printf("Pierwiastek %2d stopnia z 5: %f\n", n, x);
}
}
}
Precyzja 6 miejsc po przecinku jest domylnie ustawiana dla metody printf(), wic
w tym zadaniu uyto specyfikatora %f zamiast %.6f. Zwrómy równie uwag na spo-
sób obliczania wykadnika — wyraenie 1.0/n daje nam zmiennoprzecinkow warto
uamka (1/n — dzielenie cakowite daoby wykadnik równy 0).

Najpierw wywietlamy wiersz nagówka, rezerwujc na pierwsz kolumn 4 znaki
(rozmiar sowa Znak) i na pozostae po 10 znaków (specyfikator %10s — pole o szero-
koci 10 znaków dla acucha znaków, s — string).

acuch znaków "ABCDEFGHIJKLMNOPQRSTUVWXYZ" zamieniamy, stosujc metod toChar
Array(), na tablic znaków znaki. W ptli for each przegldamy zawarto tablicy
znaków i wywietlamy w konsoli znak z oraz kod tego znaku (int)z (rzutowanie war-
toci typu char na typ int). W specyfikatorach wystpuj symbole %1$ i %2$. W miej-
sce %1$ wstawiana jest warto pierwszego parametru (znak z), a w miejsce %2$ —
warto drugiego parametru (kod znaku (int)z).


System.out.printf("Znak%10s%10s%10s\n", "OCT", "DEC", "HEX");
char[] znaki = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
for(char z : znaki) {
System.out.printf("%1$3c %2$10o%2$10d%2$10X\n", z, (int)z);
}
}
}
Przeanalizujmy specyfikatory w acuchu formatujcym:

%1$3c — zmienna typu char (pierwszy parametr) jest wywietlana na polu
szerokoci 3 znaków;
%2$10o — liczba cakowita (drugi parametr) wywietlana jest w systemie
ósemkowym (oktalnym) na polu o szerokoci 10 znaków;
%2$10d — liczba cakowita (drugi parametr) wywietlana jest w systemie
dziesitnym (decymalnym) na polu o szerokoci 10 znaków;
%2$10X — liczba cakowita (drugi parametr) wywietlana jest w systemie
szesnastkowym (heksadecymalnym) na polu o szerokoci 10 znaków.
Cyfry szesnastkowe (ABCDEF) wywietlane s wielkimi literami.

Metoda (funkcja) toDegrees() z klasy Math zamienia miar kta podan w radianach
na miar wyraon w stopniach. Symbol stopnia w tekcie uzyskujemy, wpisujc znak
'\u00B0'.
double alfa = Math.toDegrees(1); // 1 radian w stopniach
System.out.println("1 rad = "+alfa+"\u00B0");
int st, min, sek;
st = (int)alfa;
min = (int)((alfa-st)*60+0.5);
System.out.printf("1 rad = %d\u00B0%02d\'\n", st, min);
min = (int)((alfa-st)*60);
sek = (int)((alfa-st-min/60.0)*3600+0.5);
System.out.printf("1 rad = %d\u00B0%02d\'%02d\"\n", st, min, sek);
}
}
Aby zrozumie algorytm zamiany miary stopniowej kta wyraonej uamkiem dzie-
sitnym na stopnie (wyraone liczb cakowit), minuty i sekundy ktowe, przeled my
rachunek dla kta o mierze 1 radiana:
1 rad = 57.29577951308232° — wynik dziaania metody Math.toDegrees(1);.
1 rad = 57°18' — liczba stopni jest czci cakowit liczby
57.29577951308232 (st = (int)alfa;), a liczba minut jest czci cakowit
iloczynu 0,29577951308232·60 = 17,7467707849392, po zaokrgleniu
(min = (int)((alfa-st)*60+0.5);).

1 rad = 57°17'45" — tym razem nie zaokrglamy liczby minut, ale bierzemy
tylko cz cakowit (min = (int)((alfa-st)*60);). Liczba sekund jest
równa iloczynowi 0,7467707849392·60 = 44,806247096352 zaokrglonemu
do czci cakowitej (sek = (int)((alfa-st-min/60.0)*3600+0.5);).

Metoda (funkcja) toRadians() z klasy Math zamienia miar kta podan w stopniach
1 1
na miar w radianach. Obliczenia wykonamy dla liczb 1 (1°), (1') i (1").
60 3600
double rad = Math.toRadians(1.0);
System.out.printf("1\u00B0 = %.15f rad\n", rad);
rad = Math.toRadians(1.0/60);
System.out.printf("1\' = %.15f rad\n", rad);
rad = Math.toRadians(1.0/3600);
System.out.printf("1\" = %.15f rad\n", rad);
}
}

a 3
W trójkcie egipskim o bokach a = 3, b = 4 i c = 5 iloraz jest jednoczenie si-
c 5
nusem jednego kta ostrego i cosinusem drugiego kta. Stosujc funkcje odwrotne (do-
stpne w klasie Math), moemy wyznaczy miary któw ostrych wyraone w radianach:
alfa = Math.asin(a/c) i beta = Math.acos(a/c). Wedug algorytmu opisanego w roz-
wizaniu zadania 10.7 moemy zamieni miary w radianach na miar w stopniach, stop-
niach i minutach oraz stopniach, minutach i sekundach i sformuowa odpowiedzi.
double a = 3.0, b = 4.0, c = 5.0;
double alfa, beta;
int st, min; // do podpunktu c) i d)
int sek; // do podpunktu c)
alfa = Math.asin(a/c);
beta = Math.acos(a/c);
/* odpowied a) */
System.out.printf("alfa = %.4f rad\nbeta = %.4f rad", alfa,
beta);
/* odpowied b) */
alfa = Math.toDegrees(alfa);
beta = Math.toDegrees(beta);
System.out.printf("alfa = %.1f\u00B0\nbeta = %.1f\u00B0", alfa,
beta);
/* odpowied c) */
st = (int)alfa;
min = (int)((alfa-st)*60+0.5);
System.out.printf("alfa = %d\u00B0%02d\'\n", st, min);

st = (int)beta;
min = (int)((beta-st)*60+0.5);
System.out.printf("beta = %d\u00B0%02d\'\n", st, min);
/* odpowied d) */
st = (int)alfa;
min = (int)((alfa-st)*60);
sek = (int)((alfa-st-min/60.0)*3600+0.5);
System.out.printf("alfa = %d\u00B0%02d\'%02d\"\n", st, min, sek);
st = (int)beta;
min = (int)((beta-st)*60);
sek = (int)((beta-st-min/60.0)*3600+0.5);
System.out.printf("beta = %d\u00B0%02d\'%02d\"\n", st, min, sek);
}
}
11. Wczytywanie danych

— klasa Scanner
Zaczynamy od utworzenia obiektu input klasy Scanner odczytujcego dane ze stan-
dardowego wejcia System.in. Zgodnie z treci zadania dane wejciowe mog by
uamkami dziesitnymi, wic uyjemy zmiennej typu float (liczby zmiennoprzecin-
kowej pojedynczej precyzji) lub double (liczby zmiennoprzecinkowej podwójnej pre-
cyzji). Dla kadego typu danych mamy odrbn metod wczytujc dane ze strumienia:
float t = input.nextFloat();
lub:
double t = input.nextDouble();
Dane wprowadzamy w postaci liczby cakowitej lub uamka dziesitnego (z przecin-

kiem). Dopuszczalny jest równie format naukowy, np. 2,35e2 (2,35·102).
import java.util.Scanner;
System.out.print("Podaj temperatur w \u00B0C, t = ");
double t = input.nextDouble();
System.out.printf("%.1f\u00B0C = %.1f\u00B0F\n", t, t*1.8+32);
input.close();
}
}
Dane wejciowe i wynik s wywietlane z dokadnoci do jednego miejsca po prze-

cinku (specyfikator w acuchu formatujcym %.1f). Symbol ° (stopnia) wprowadza-
ny jest jako znak \u00B0 (Unicode). Na koniec nie zapomnijmy o zamkniciu skanera
input.close().

Ze strumienia danych moemy pobra kolejny token (acuch znaków do najblisze-

go znaku biaego — odstpu, tabulatora lub koca wiersza):
String s = input.next();
i zamieni go na liczb zmiennoprzecinkow, stosujc odpowiedni metod sta-

tyczn klasy Float lub Double:
float t = Float.parseFloat(s);
lub:
float t = Float.valueOf(s);
lub:
double t = Double.parseDouble(s);
lub:
double t = Double.valueOf(s);
Nie jest to rozwizanie korzystne — dane liczbowe bdziemy musieli wprowadza

z kropk dziesitn (konwencja angielska), a wyniki bd wywietlane z przecin-
kiem. Lepiej uywa zlokalizowanych metod nextFloat() lub nextDouble().
Nie jest konieczne tworzenie obiektu s klasy String, moemy po prostu zapisa w jed-
nym wierszu float t = Float.parseFloat(input.next()).

Wzór °F = °C·1,8+32 przeksztacamy na posta °C = (°F-32)/1,8. Temperatura wej-
ciowa wyraona jest liczb cakowit (zgodnie z treci zadania), wic warto po-
bieramy ze strumienia, stosujc metod input.nextInt().
System.out.print("Podaj temperatur w \u00B0F, t = ");
int t = input.nextInt();
System.out.printf("%d\u00B0F = %.1f\u00B0C\n", t, (t-32)/1.8);
input.close();
}
}
Ze strumienia danych moemy pobra kolejny token:

i zamieni go na liczb cakowit, stosujc wybran metod statyczn klasy Integer:

int t = Integer.parseInt(s);
lub:
int t = Integer.decode(s);

lub:
int t = Integer.valueOf(s);
Moemy ten zapis skróci, eliminujc obiekt s, np.:

int t = Integer.valueOf(input.next());
Zadanie 11.3a. Z11_3a.java

Dugo przeciwprostoktnej w trójkcie prostoktnym obliczymy ze wzoru c a 2 b2
wynikajcego z twierdzenia Pitagorasa. Do dyspozycji w klasie Math mamy metod
sqrt() (pierwiastek kwadratowy) i metod pow() (potgowanie):
double c = Math.sqrt(Math.pow(a, 2)+Math.pow(b, 2));
Dwukrotne wywoanie metody pow() w tej sytuacji jest nieekonomiczne. Obliczanie

kwadratu liczby wykonamy szybciej, stosujc mnoenie:
double c = Math.sqrt(a*a+b*b);
Wprowadzanie danych z klawiatury i wywietlanie wyniku nie sprawi problemu —

naley jednak zauway, e program nie kontroluje poprawnoci danych.
System.out.print("Podaj dugo przyprostoktnej, a = ");
double a = input.nextDouble();
System.out.print("Podaj dugo przyprostoktnej, b = ");
double b = input.nextDouble();
double c = Math.sqrt(a*a+b*b);
System.out.printf("Dugo przeciwprostoktnej c = %.3f\n", c);
input.close();
}
}
Zadanie 11.3b. Z11_3b.java

Zadanie to jest typowym przykadem zastosowania funkcji trygonometrycznych (kta
ostrego) do obliczania elementów trójkta prostoktnego (tzw. rozwizywania trójktów).
a a
Przyjmujc standardowe oznaczenia, obliczymy: sin D , c sin D a, c .
c sin D
Naley pamita, e funkcje trygonometryczne dostpne w klasie Math (sin, cos i tan
— tangens) wymagaj podania argumentu (miary kta) w radianach. Do konwersji
miary kta moemy uy metody toRadians() z klasy Math.
public class Z11_3b {
System.out.print("Podaj dugo przyprostoktnej, a = ");
System.out.print("Podaj miar kta ostrego (°), alfa = ");

double alfa = input.nextDouble();

double c = a/Math.sin(Math.toRadians(alfa));
System.out.printf("Dugo przeciwprostoktnej c = %.3f\n", c);
input.close();
}
}

Liczba bitów zostaa ograniczona do 31 ze wzgldu na zastosowanie typu zmiennych
int i klasy Integer. Mona liczb bitów zwikszy do 63, stosujc zmienne typu long
i klas opakowujc Long. Wykorzystujc metod next(), odczytujemy ze skanera ko-
lejny token i nastpnie zamieniamy go na liczb cakowit. Metoda parseInt() z kla-
sy Integer umoliwia okrelenie podstawy systemu liczbowego (drugi parametr). Po
odkodowaniu (z systemu binarnego) dwóch liczb a i b moemy obliczy ich sum a+b,
któr nastpnie zamieniamy na cig znaków reprezentujcy jej posta binarn Integer.
toBinaryString(a+b).
System.out.println("Podaj dwie liczby w systemie binarnym (do 31 bitów)");
System.out.print("a = ");
String str = input.next();
int a = Integer.parseInt(str, 2);
System.out.print("b = ");
str = input.next();
int b = Integer.parseInt(str, 2);
str = Integer.toBinaryString(a+b);
System.out.println("a+b = "+str);
input.close();
}
}
Moemy zmieni podstaw systemu liczbowego w skanerze, uywajc metody useRadix(),

a nastpnie odczytywa liczby cakowite zapisane w systemie liczbowym o tej pod-
stawie.
input.useRadix(2);
int a = input.nextInt();
int b = input.nextInt();

Uamek zwyky wprowadzamy z klawiatury jako acuch znaków (np. 23/45), w któ-
rym licznik i mianownik (liczby cakowite) oddzielone s symbolem / (bez odstpów).
Zakadamy, e uytkownik poprawnie wprowadzi dane. Wczytujemy token ze skane-
ra input i zamieniamy na liczby cakowite a i b czci acucha przed znakiem / i po
nim. Aby obliczy warto dziesitn uamka, podzielimy licznik przez mianownik
a/b. Takie dzielenie daoby jednak wynik cakowity, wic naleaoby co najmniej
jedn z tych liczb skonwertowa (rzutowa) na typ zmiennoprzecinkowy double (lub

float) i uzyska wynik zmiennoprzecinkowy, np. (double)a/b lub a/(double)b. Po-

niewa dodatkowo potrzebujemy zamieni ten uamek na procent, to mnoymy wynik
przez 100. Stosujc sta w postaci zmiennoprzecinkowej 100.0 (double) lub 100.0f
(float) i odpowiedni kolejno dziaa, uzyskamy waciwy rezultat (bez potrzeby
jawnego rzutowania a lub b na typ zmiennoprzecinkowy): 100.0*a/b lub 100.0f*a/b.
Mnoenie i dzielenie maj ten sam priorytet, ale dziaania w tym przypadku wykony-
wane s od strony lewej do prawej — mnoenie da wynik zmiennoprzecinkowy, wic
wynik pó niejszego dzielenia równie bdzie liczb zmiennoprzecinkow.
System.out.print("Podaj uamek zwyky (np. 23/45): ");
String u = input.next();
int a = Integer.parseInt(u.substring(0, u.indexOf("/")));
int b = Integer.parseInt(u.substring(u.indexOf("/")+1));
System.out.printf("%d/%d = %.1f%%%n", a, b, 100.0*a/b);
input.close();
}
}

acuch s zawiera dane tekstowe — cztery tokeny oddzielone odstpami (dwa sowa,
liczb cakowit i liczb dziesitn).
String s = "Jan Nowak 150 25,3";
Scanner input = new Scanner(s);
Podajc acuch s jako parametr konstruktora, otrzymamy obiekt input umoliwiaj-

cy odczytanie danych z acucha znaków. Stosujc metod next(), odczytamy sowa
(Jan i Nowak), potem odczytamy liczb cakowit 150 (metod nextInt()) i liczb dzie-
sitn (zmiennoprzecinkow) 25,3 (metod nextDouble()). Majc dane, wykonamy
obliczenia i sformuujemy odpowied . Na koniec zamykamy skaner (input.close()).
String s = "Jan Nowak 150 25,3";
Scanner input = new Scanner(s);
String s1 = input.next();
System.out.printf("%s %s %.2f\n", s2, s1, a*b);
input.close();
}
}

Rozwizanie tego zadania jest podobne do rozwizania zadania 11.6. Istotn rónic
jest ródo danych — tym razem dane odczytamy z pliku. Dodatkowo importujemy
dwie klasy z pakietu java.io, klas IOException (wyjtki operacji wejcia-wyjcia,

które poznasz dokadniej w dalszych rozdziaach) i klas File. W nagówku metody

main dopisujemy informacj o licie wyjtków (throws IOException), które mog zo-
sta wygenerowane podczas operacji z plikami. Obsug tych wyjtków zajmie si
wirtualna maszyna Javy, wywoujca metod main. Sytuacja ta zostanie omówiona
dokadniej na dalszych stronach.
Teraz skoncentrujmy uwag na wykorzystaniu klasy Scanner do odczytywania da-

nych z pliku. Tworzymy obiekt f klasy File skojarzony z plikiem dane.txt (File f =
new File("dane.txt")) i obiekt input klasy Scanner do odczytywania danych z pliku
(Scanner input = new Scanner(f)). Reszta kodu pozostaje bez zmian.
import java.io.File;
import java.io.IOException;
public static void main(String[] args) throws IOException {
File f = new File("dane.txt");
Scanner input = new Scanner(f);
System.out.printf("%s %s %.2f\n", s2, s1, a*b);
input.close();
}
}
12. Operacje na tekstach — klasy

StringBuffer i StringBuilder
To zadanie i dwa zadania nastpne (12.2 i 12.3) traktujemy jako pretekst do przedsta-
wienia wybranych metod klasy StringBuilder (lub StringBuffer).
Wykresem równania y ax 2 bx c, a z 0 jest parabola o wierzchoku §¨ b , ' ·¸ ,

© 2a 4 a ¹
gdzie ' b 4ac . Pobieramy dane (wspóczynniki trójmianu) z konsoli, zakadajc,
2
e uytkownik poda poprawne liczby (a róne od zera), i obliczamy wyrónik trójmia-

nu (delta). Pozostae obliczenia wykonamy podczas budowania odpowiedzi.
Tworzymy obiekt point klasy StringBuilder zawierajcy acuch znaków "Wierzcho-

ek paraboli (", czyli pocztek odpowiedzi.
StringBuilder point = new StringBuilder("Wierzchoek paraboli (");
Stosujc metod append(), dodamy na kocu acucha znaków (obiektu point) kolej-
no: warto pierwszej wspórzdnej wierzchoka paraboli (–b/(2*a)), przecinek i od-
stp (", "), warto drugiej wspórzdnej wierzchoka paraboli (–delta/(4*a)) i nawias

zamykajcy par wspórzdnych punktu (")"). Zwrómy uwag na uycie nawiasów

w mianownikach wyrae, wyznaczajcych waciw kolejno wykonywania dzia-
a (mnoenia i dzielenia).
System.out.println("Obliczanie wspórzdnych wierzchoka
paraboli");
System.out.print("Podaj wspóczynniki trójmianu kwadratowego
oddzielone odstpami: ");
double a, b, c;
/* Wczytywanie danych z konsoli */
a = input.nextDouble();
b = input.nextDouble();
c = input.nextDouble();
input.close();
/* Obliczenia i budowanie odpowiedzi */
double delta = b*b-4*a*c;
StringBuilder point =
new StringBuilder("Wierzchoek paraboli (");
point.append(-b/(2*a)).append(", ").
append(-delta/(4*a)).append(")");
System.out.println(point);
}
}
Do sformuowania odpowiedzi moemy uy operatora konkatenacji (czenia tekstów

+). Kompilator w tym przypadku równie wykorzysta metody klasy StringBuilder.
String s = "Wierzchoek paraboli ("+(-b/(2*a))+", "+(-delta/(4*a))+")";
System.out.println(s);
1. Zadanie moemy rozwiza w taki sam sposób, zastpujc klas StringBuil-

der klas StringBuffer. Klasy maj identyczne metody, jednak klasa String
Builder jest nowsza. Po klas StringBuffer signiemy wtedy, gdy niezbdne
bdzie buforowanie operacji na acuchu znaków.
2. Odpowied moemy sformuowa i sformatowa , stosujc metod printf()
lub format() do wywietlania wyniku:
System.out.printf("Wierzchoek paraboli(%.2f, %.2f)", -b/(2*a),
-delta/(4*a));
lub metod format() do budowania acucha:

String s = String.format(("Wierzchoek paraboli(%.2f, %.2f)", -b/(2*a),
-delta/(4*a));

Ponownie rozwizujemy zadanie 12.1, stosujc inny sposób budowania odpowiedzi.
Zaczynamy od acucha (obiekt point klasy StringBuilder) zoonego z pary nawiasów
okrgych, przecinka i odstpu "(, )" — cznie cztery znaki o indeksach 0, 1, 2 i 3.

Przed znakiem o indeksie 3 (midzy odstpem i nawiasem zamykajcym) wstawiamy

warto drugiej wspórzdnej wierzchoka paraboli point.insert(3, (-delta/(4*a))).
Konwersja zmiennoprzecinkowego typu wartoci wyraenia na acuch znaków wy-
konywana jest przez metod insert. Nastpnie przed znakiem o indeksie 1 (midzy
nawiasem otwierajcym i przecinkiem) wstawiamy warto pierwszej wspórzdnej
wierzchoka paraboli point.insert(1, -b/(2*a)). Obie te czynnoci moemy zapisa
cznie, w jednym wierszu:
point.insert(3, (-delta/(4*a))).insert(1, -b/(2*a));
Bardzo wana jest kolejno wstawiania tych liczb do acucha pocztkowego "(, )".
StringBuilder point = new StringBuilder("(, )");
point.insert(3, (-delta/(4*a))).insert(1, -b/(2*a));
System.out.println("Wierzchoek paraboli: "+point);
Pozostaa cz kodu jest podobna jak w zadaniu 12.1.

Jeszcze raz rozwizujemy zadanie 12.1, stosujc tym razem metod replace() (zastp)
z klasy StringBuilder. Na pocztek budujemy acuch (obiekt point klasy String
Builder) o postaci "(#1, #2)". Wystpujce w acuchu symbole #1 i #2 wskazuj
miejsca, w których umiecimy wyniki oblicze. Metoda replace() ma trzy parametry,
dwa indeksy okrelajce zakres zastpowanych znaków i podstawiany w to miejsce
acuch znaków (dugo tego acucha nie jest ograniczona przez zakres zastpowa-
nych znaków). Liczby przed wstawieniem musimy zamieni na acuchy znaków.
Najpierw znajdujemy pooenie (indeks pierwszego znaku) symbolu "#1" w obiekcie

point (start = point.indexOf("#1")), a nastpnie zamieniamy dwa znaki (od indek-
su start do indeksu start+1) acuchem znaków utworzonym z wartoci pierwszej
wspórzdnej wierzchoka paraboli (String.valueOf(-b/(2*a))). Podobnie zamieniamy
symbol "#2" na odpowiedni warto.
StringBuilder point = new StringBuilder("(#1, #2)");
int start = point.indexOf("#1");
point.replace(start, start+1, String.valueOf(-b/(2*a)));
start = point.indexOf("#2");
point.replace(start, start+1, String.valueOf(-delta/(4*a)));
W drugim wariancie rozwizania proponujemy inny sposób zamiany liczby zmienno-

przecinkowej na acuch znaków (new Double(-b/(2*a)).toString()).
StringBuilder point = new StringBuilder("(#1, #2)");
int start = point.indexOf("#1");
point.replace(start, start+1, new Double(-b/(2*a)).toString());
start = point.indexOf("#2");

point.replace(start, start+1, new Double(-delta/(4*a)).toString());

Kolejny wariant moe wykorzysta waciwoci operatora konkatenacji (+):

point.replace(start, start+1, ""+(-b/(2*a)));

Z konsoli odczytujemy liczb cakowit dodatni n (nie sprawdzamy poprawnoci da-
nych wprowadzonych przez uytkownika) i tworzymy obiekt liczba klasy String
Builder, reprezentujcy pusty acuch znaków.
Po wywoaniu metod liczba.append(n).reverse() obiekt liczba zawiera cyfry liczby

n, zapisane w odwrotnej kolejnoci. W odpowiednim momencie zamienimy zawarto
obiektu na liczb cakowit Integer.parseInt(liczba.toString()).
Drugi obiekt wynik klasy StringBuilder i metod append() wykorzystamy do skon-

struowania odpowiedzi.
System.out.print("Podaj liczb cakowit dodatni: ");
int n = input.nextInt();
input.close();
StringBuilder liczba = new StringBuilder();
liczba.append(n).reverse();
StringBuilder wynik = new StringBuilder();
wynik.append(n).append("-").append(liczba).append(" = ");
wynik.append(n - Integer.parseInt(liczba.toString()));
System.out.println(wynik);
}
}

Wspórzdne wektora wprowadzamy w postaci pary liczb oddzielonych przecinkiem
i zawartych w nawiasie prostoktnym, np. [2.5, –3].
Z konsoli wczytujemy wiersz tekstu i usuwamy (metoda trim()) zbdne biae znaki
z pocztku i koca acucha String wekt = input.nextLine().trim(). Zakadamy,
e otrzymany acuch zawiera poprawn posta wspórzdnych wektora, i tworzymy
nowy obiekt, na którym wykonamy dalsze przeksztacenia (StringBuilder tmp = new
StringBuilder(wekt)).
Z acucha usuwamy nawiasy prostoktne, czyli pierwszy (tmp.deleteCharAt(0))

i ostatni znak (tmp.deleteCharAt(tmp.length()-1)). Nastpnie odszukujemy pooe-
nie przecinka oddzielajcego wspórzdne wektora (int poz = tmp.indexOf(","))
i rozdzielamy acuch na dwa podacuchy, które konwertujemy na zmiennoprzecin-
kowe wartoci wspórzdnych wektora (liczby zapisane s z kropk dziesitn lub
w postaci cakowitej):

double a = Double.parseDouble(tmp.substring(0, poz));

double b = Double.parseDouble(tmp.substring(poz+1));
Na koniec pozostaje obliczenie dugoci wektora ze wzoru u a 2 b 2 (Math.sqrt

(a*a+b*b)) i sformuowanie odpowiedzi.
System.out.print("Podaj wspórzdne wektora
(w postaci [a, b]): ");
String wekt = input.nextLine().trim();
input.close();
StringBuilder tmp = new StringBuilder(wekt);
/* Usuwamy pierwszy i ostatni znak, czyli nawiasy prostoktne. */
tmp.deleteCharAt(0).deleteCharAt(tmp.length()-1);
/* Znajdujemy pozycj przecinka midzy liczbami. */
int poz = tmp.indexOf(",");
/* Odczytujemy wartoci liczb. */
double a = Double.parseDouble(tmp.substring(0, poz));
double b = Double.parseDouble(tmp.substring(poz+1));
/* Obliczamy i wywietlamy dugo wektora. */
System.out.println("Dugo wektora "+wekt+" jest równa "+
Math.sqrt(a*a+b*b));
}
}
Do pobrania wspórzdnych wektora z acucha znaków moemy wykorzysta meto-

d split() z klasy String. W tym celu tworzymy tablic acuchów temp[], konwer-
tujemy obiekt tmp na acuch znaków i wywoujemy metod split(), podajc przeci-
nek jako separator — ",":
String temp[] = tmp.toString().split(",");
Nastpnie odczytujemy (z tablicy) wartoci wspórzdnych wektora:

double a = Double.parseDouble(temp[0]);
double b = Double.parseDouble(temp[1]);
Pozostaa cz kodu pozostaje bez zmian.
Stosujc metody substring() i split(), moemy zrezygnowa z uycia obiektu tmp

klasy StringBuilder:
String temp[] = wekt.substring(1, wekt.length()-1).split(",");
Oczywicie dane musz by wprowadzane zgodnie z przyjt umow.

Zadanie to rozwizujemy podobnie jak zadanie 12.5. Istotna rónica polega na tym,
e mamy trzy wspórzdne oddzielone dwoma przecinkami. Pooenie tych przecin-
ków (pierwszego i ostatniego) ustalimy, uywajc metod indexOf() i lastIndexOf().


System.out.print("Podaj wspórzdne wektora
(w postaci [a, b, c]): ");
String wekt = input.nextLine().trim();
input.close();
StringBuilder tmp = new StringBuilder(wekt);
/* Usuwamy pierwszy i ostatni znak, czyli nawiasy prostoktne. */
tmp.deleteCharAt(0).deleteCharAt(tmp.length()-1);
/* Znajdujemy pozycje przecinków midzy liczbami. */
int poz1 = tmp.indexOf(",");
int poz2 = tmp.lastIndexOf(",");
/* Odczytujemy wartoci liczb. */
double a = Double.parseDouble(tmp.substring(0, poz1));
double b = Double.parseDouble(tmp.substring(poz1+1, poz2));
double c = Double.parseDouble(tmp.substring(poz2+1));
/* Obliczamy i wywietlamy dugo wektora. */
System.out.println("Dugo wektora "+wekt+" jest równa "+
Math.sqrt(a*a+b*b+c*c));
}
}
Podobnie jak w rozwizaniu zadania 12.5, do wyznaczenia wspórzdnych wektora

moemy zastosowa metod split() z klasy String:
/* Pomijamy pierwszy i ostatni znak, czyli nawiasy prostoktne, i dzielimy acuch znaków
na czci rozdzielone przecinkiem. */
String temp[] = wekt.substring(1, wekt.length()-1).split(",");
/* Odczytujemy wartoci liczb - wspórzdnych wektora. */
double a = Double.parseDouble(temp[0]);
double b = Double.parseDouble(temp[1]);
double c = Double.parseDouble(temp[2]);
13. Instrukcje warunkowe

i instrukcja selekcji
Wprowadzone imi jest przechowywane w obiekcie str klasy String. Odpowied
skonstruujemy jako obiekt name klasy StringBuilder — StringBuilder name = new
StringBuilder(str);. W zmiennej z przechowujemy ostatni znak imienia — char z =
name.charAt(name.length()-1);. Do imienia (name) dodajemy sowo " jest " wraz
z odstpami przed sowem i za sowem — name.append(" jest ");. Na koniec uzu-
peniamy odpowied sowem okrelajcym pe osoby, w zalenoci od tego, jak
warto ma wyraenie logiczne z == 'a'. Jeli wyraenie ma warto true (ostatni
liter imienia jest a), to do odpowiedzi dodajemy tekst "kobiet.", w przeciwnym ra-
zie dodajemy tekst "mczyzn.".


System.out.print("Podaj imi: ");
input.close();
StringBuilder name = new StringBuilder(str);
char z = name.charAt(name.length()-1);
name.append(" jest ");
if (z == 'a')
name.append("kobiet.");
else
name.append("mczyzn.");
System.out.println(name);
}
}

Jeeli wczytana warto zmiennej a (dugo boku kwadratu) jest dodatnia, to wyko-
nujemy obliczenia i wywietlamy wynik. W kolejnej instrukcji warunkowej badamy,
czy podana dugo boku jest mniejsza lub równa 0 — jeli tak jest, to wywietlamy
komunikat o bdnych danych.

System.out.println("Obliczanie pola powierzchni i obwodu kwadratu");
System.out.print("Podaj dugo boku, a = ");
input.close();
if (a > 0) {
double pole = a*a;
double obwod = 4*a;
System.out.println("Pole powierzchni P = "+pole);
System.out.println("Obwód kwadratu L = "+obwod);
}
if (a <= 0)
System.out.println("Bd! Dugo boku ma by liczb dodatni.");
}
}
Poniewa warunki a > 0 i a <= 0 nawzajem wykluczaj si, to bardzo czsto uywa-
my w takiej sytuacji konstrukcji if-else:
if (a > 0) {
double pole = a*a;
double obwod = 4*a;
System.out.println("Pole powierzchni P = "+pole);
System.out.println("Obwód kwadratu L = "+obwod);
} else
System.out.println("Bd! Dugo boku ma by liczb dodatni.");


Po wprowadzeniu danych tworzymy obiekt wynik klasy StringBuilder. Stanowicy
odpowied acuch znaków skada si z nawiasów < i > dla przedziau domknitego
lub { i } w przypadku zbioru jednoelementowego (przypadek a jest równe b). Warto-
ci zmiennych a i b w przypadku przedziau powinny by wprowadzone do wyniku
w porzdku rosncym. Mamy zatem trzy przypadki:
Przypadek Budowanie odpowiedzi

a < b wynik.append("<").append(a).append(", ").append(b).append(">");
b < a wynik.append("<").append(b).append(", ").append(a).append(">");.
a == b wynik.append("{").append(a).append("}");
Przedstawiona sytuacja wymaga zbudowania trzech instrukcji warunkowych lub za-

stosowania tzw. zagniedenia instrukcji warunkowej.

System.out.println("Podaj dwie liczby a i b:");
input.close();
if (a < b)
wynik.append("<").append(a).append(", ").append(b).append(">");
else if (b < a)
wynik.append("<").append(b).append(", ").append(a).append(">");
else
wynik.append("{").append(a).append("}");
wynik.insert(0, "Zbiór wszystkich liczb zawartych pomidzy a i b, X = ");
}
}

Po wprowadzeniu wartoci wspóczynnika a trójmianu ax 2 bx c sprawdzamy po-
dan warto. Jeli a jest zerem, to wywietlamy komunikat skierowany do standar-
dowego strumienia bdów System.err.println(...) i zamykamy aplikacj System.
exit(0). Gdy a jest róne od zera, wczytujemy pozostae wspóczynniki trójmianu
(b i c) i obliczamy q '
b 2 4ac 4ac b 2
. Zbiór wartoci funkcji zaley od
4a 4a 4a
znaku wspóczynnika a i wartoci q:

Znak a Zbiór wartoci Budowanie odpowiedzi

a > 0 q, f ) wynik.append("<, +oo)").insert(1, q);
a < 0 (f, q wynik.append("(-oo, >").insert(6, q);
System.out.println("Podaj wspóczynniki funkcji kwadratowej:");
if (a == 0) {
System.err.println("a = 0, to nie jest funkcja kwadratowa.");
System.exit(0);
}
System.out.print("c = ");
double c = input.nextDouble();
input.close();
double q = (4*a*c-b*b)/(4*a);
if (a > 0)
wynik.append("<, +oo)").insert(1, q);
else
wynik.append("(-oo, >").insert(6, q);
System.out.println("Zbiór wartoci: "+wynik);
}
}

Wczytywanie danych (wspóczynników trójmianu) zorganizujemy tak, jak w rozwi-
zaniu zadania 13.4. Nastpnie obliczymy wspórzdne p i q wierzchoka paraboli b-
dcej wykresem tej funkcji kwadratowej.
double p = -b/(2*a);
double q = (4*a*c-b*b)/(4*a);
W budowanej odpowiedzi umiecimy symbole #1 i #2. W miejsce tych symboli pod-

stawimy pó niej odpowiednie sowa "rosnca" i "malejca", w zalenoci od znaku
wspóczynnika a.
wynik.append("Funkcja jest #1 w przedziale (-oo, ").append(p);
wynik.append("> i #2 w przedziale <").append(p).append(", +oo).");
int p1 = wynik.indexOf("#1");
int p2 = wynik.indexOf("#2");
if (a > 0)
wynik.replace(p2, p2+2, "rosnca").replace(p1, p1+2, "malejca");

else
wynik.replace(p2, p2+2, "malejca").replace(p1, p1+2, "rosnca");
Usuwamy wszystkie znaki z obiektu wynik i budujemy drug odpowied .

wynik.delete(0, wynik.length());
wynik.append("Funkcja osiga warto ");
if (a > 0)
wynik.append("minimaln");
else
wynik.append("maksymaln");
wynik.append(" y = ").append(q).append(" w punkcie x = ").append(p).append(".");

Równanie liniowe o postaci ax b 0 jest równowane równaniu ax b . Jeeli
b
a z 0 , to rozwizaniem równania jest liczba x , w przeciwnym razie otrzymuje-
a
my równanie 0 x b . Dla b z 0 równanie jest sprzeczne (0x=1 — adna liczba nie
spenia równania), a dla b=0 równanie jest spenione przez dowoln liczb x (0x=0
— równanie tosamociowe). Zalenoci te przedstawimy przy uyciu instrukcji wa-
runkowej:
if (a != 0) {
double x = -b/a;
} else if (b != 0)
System.out.println("Równanie sprzeczne (0x = 1).");
else
System.out.println("Równanie tosamociowe (0x = 0).");
Wczytywanie wspóczynników równania z konsoli zrealizujemy, stosujc obiekty i me-

tody klasy Scanner.
System.out.println("Podaj wspóczynniki równania ax+b = 0");
input.close();
if (a != 0) {
double x = -b/a;
} else if (b != 0)
System.out.println("Równanie sprzeczne (0x = 1).");
else
System.out.println("Równanie tosamociowe (0x = 0).");
}
}


Najpierw porównujemy pierwsz i drug liczb (a i b), a nastpnie mniejsz z nich
porównujemy z liczb c. Te dwa porównania wystarcz, aby wskaza najmniejsz
z trzech liczb.

System.out.println("Wybór najmniejszej z trzech liczb.");
System.out.println("Podaj liczby:");
input.close();
System.out.print("Najmniejsz liczb jest ");
if (a < b)
if (a < c)
System.out.println(a);
else
System.out.println(c);
else
if (b < c)
System.out.println(b);
else
System.out.println(c);
}
}
Uyte instrukcje warunkowe moemy zastpi wyraeniem warunkowym. Wyraenie

(a < b)?a:b zwraca mniejsz sporód liczb a i b. Ta warto jest porównywana w taki
sam sposób z liczb c: (((a < b)?a:b) < c)?((a < b)?a:b):c).
System.out.print("Najmniejsz liczb jest: ");
System.out.println((((a < b)?a:b) < c)?((a < b)?a:b):c);
Zamieniajc znak < na znak > w powyszym kodzie, otrzymamy program wyznacza-
jcy najwiksz z trzech liczb.

Dane moemy wprowadzi w sposób przedstawiony w rozwizaniu zadania 13.7. Ze
zbioru trzech liczb par liczb moemy wyznaczy na trzy sposoby, czyli co najwyej
po trzech porównaniach poznamy kolejno (uporzdkowanie) tych liczb.
System.out.print("Liczby uporzdkowane w kolejnoci niemalejcej: ");
if (a <= b)
if (a <= c)
if (b <= c)
System.out.printf("%f, %f, %f.\n", a, b, c);

else
System.out.printf("%f, %f, %f.\n", a, c, b);
else
System.out.printf("%f, %f, %f.\n", c, a, b);
else
if (b <= c)
if (a <= c)
System.out.printf("%f, %f, %f.\n", b, a, c);
else
System.out.printf("%f, %f, %f.\n", b, c, a);
else
System.out.printf("%f, %f, %f.\n", c, b, a);
Zastosowan w rozwizaniu metod wywietlania wyników System.out.printf("%f,

%f, %f.\n", a, b, c); moemy równie zrealizowa, wykorzystujc metod println()
— System.out.println(a+", "+b+", "+c+".");.
Zamieniajc znak <= na znak => w powyszym kodzie, otrzymamy program porzd-
kujcy trzy liczby w kolejnoci nierosncej.

Mamy dziesi liczb jednocyfrowych (0, 1, …, 9) i kadej z nich naley przyporzdko-
wa jedno sowo (zero, jeden, …, dziewi ). Moemy to zrobi metod „kopiuj, wklej
i popraw”, tworzc cig dziesiciu instrukcji warunkowych:
String wynik = "";
if (n == 0) wynik = "zero";
if (n == 1) wynik = "jeden";
// itd.
if (n == 9) wynik = "dziewi";
System.out.println("Sownie: "+wynik);
Niezalenie od wartoci liczby n porównanie wykonujemy dziesi razy. Efektywniej-

sze bdzie zastosowanie instrukcji warunkowych zagniedonych:
String wynik = "";
if (n == 0) wynik = "zero";
else if (n == 1) wynik = "jeden";
// itd.
else if (n == 8) wynik = "dziewi";
else wynik = "dziewi"; // pozostaa ostatnia moliwo
System.out.println("Sownie: "+wynik);
W tym przypadku liczba porówna bdzie zaleaa od wartoci n i zmienia si w za-
kresie od 1 do 9 (zakadamy, e otrzymalimy do zamiany liczb jednocyfrow i ostat-
nie porównanie n == 9 jest zbdne).
Do wykonywania takich porówna moemy uy instrukcji wyboru switch():


System.out.println("Sowny zapis liczby jednocyfrowej");


System.out.print("Podaj liczb naturaln jednocyfrow, n = ");
StringBuilder wynik = new StringBuilder("Sownie: ");
if (n >=0 && n < 10) {
switch (n) {
case 0: wynik.append("zero"); break;
case 1: wynik.append("jeden"); break;
case 2: wynik.append("dwa"); break;
case 3: wynik.append("trzy"); break;
case 4: wynik.append("cztery"); break;
case 5: wynik.append("pi"); break;
case 6: wynik.append("sze"); break;
case 7: wynik.append("siedem"); break;
case 8: wynik.append("osiem"); break;
case 9: wynik.append("dziewi"); break;
}
System.out.println(wynik.append("."));
} else
System.out.println("Bdna warto liczby!");
}
}
Zwrómy uwag na uycie instrukcji warunkowej if (n >=0 && n < 10) {...} w celu
sprawdzenia, czy liczba n jest jednocyfrowa (wiksza lub równa 0 i mniejsza od 10).
Moemy zamiast instrukcji wyboru zastosowa tablic acuchów (moemy zdefinio-

wa t tablic w kodzie klasy jako prywatn statyczn sta private static final):
String[] str = {"zero", "jeden", "dwa", "trzy", "cztery", "pi", "sze",
"siedem", "osiem", "dziewi"};
i jako wynik wybiera odpowiedni warto z tej tablicy str[n] (dla n = 0, 1, …, 9).
if (n >=0 && n < 10)
System.out.println(wynik.append(str[n]).append("."));
else
Mona pomin obiekt wynik klasy StringBuilder i bezporednio sformuowa od-

powied :
if (n >=0 && n < 10)
System.out.println("Sownie: "+str[n]+".");
else
Nie zalecamy jednak tej oszczdnoci ze wzgldu na kolejne zadania wykorzystujce

omówione fragmenty kodu.

Przeanalizujmy zapis sowny liczby dwucyfrowej (tj. jednej z dziewidziesiciu liczb
od 10 do 99). Moemy mie do zapisania sownie pene dziesitki (10, 20, …, 90),
pene dziesitki od 20 w gór i jednoci (zob. rozwizanie zadania 13.9) oraz liczby

z drugiej dziesitki (11, 12, …, 19), wymagajce odrbnego potraktowania. Do tej

ostatniej grupy doczymy liczb 10.
Z liczby dwucyfrowej n moemy obliczy jej cyfr jednoci j = n%10 (reszta z dziele-
nia przez 10) oraz cyfr dziesitek d = n/10 (wynik dzielenia cakowitego n przez 10,
d równe zero, wiadczy o tym, e liczba n jest jednocyfrowa).
Stosujc instrukcje warunkowe, wyodrbnimy wszystkie istotne przypadki. Zacznie-

my od wyeliminowania liczb o wikszej liczbie cyfr i liczb ujemnych:
if (n >= 100 || n < 0) {
/* Bd. To nie jest liczba naturalna dwucyfrowa. */
} else if (n >= 20) {
/* Liczba dwucyfrowa wiksza lub równa 20 */
} else if(n >= 10) {
/* 10 lub liczba z drugiej dziesitki: 11, 12, ..., 19 */
} else {
/* Pozostay liczby jednocyfrowe. */
}
Wyraone sowami wartoci liczb moemy uzyska, stosujc instrukcje selekcji lub
tablice zawierajce poszczególne nazwy (zob. rozwizanie zadania 13.9).
System.out.println("Sowny zapis liczby naturalnej mniejszej od 100");
System.out.print("Podaj liczb naturaln mniejsz od 100, n = ");
if (n >= 100 || n < 0) {
/* Bd. To nie jest liczba naturalna dwucyfrowa. */
} else if (n >= 20) {
/* Liczba dwucyfrowa wiksza lub równa 20 */
switch (n/10) { // Cyfra dziesitek
case 2: wynik.append("dwadziecia"); break;
case 3: wynik.append("trzydzieci"); break;
case 4: wynik.append("czterdzieci"); break;
case 5: wynik.append("pidziesit"); break;
case 6: wynik.append("szedziesit"); break;
case 7: wynik.append("siedemdziesit"); break;
case 8: wynik.append("osiemdziesit"); break;
case 9: wynik.append("dziewidziesit"); break;
}
int d = n%10; // Cyfra jednoci
if (d > 0) {
wynik.append(" ");
switch (d) {


}
}
} else if(n >= 10) {
/* 10 lub liczba z drugiej dziesitki: 11, 12, ..., 19 */
switch (n) {
case 10: wynik.append("dziesi"); break;
case 11: wynik.append("jedenacie"); break;
case 12: wynik.append("dwanacie"); break;
case 13: wynik.append("trzynacie"); break;
case 14: wynik.append("czternacie"); break;
case 15: wynik.append("pitnacie"); break;
case 16: wynik.append("szesnacie"); break;
case 17: wynik.append("siedemnacie"); break;
case 18: wynik.append("osiemnacie"); break;
case 19: wynik.append("dziewitnacie"); break;
}
} else {
/* Pozostay liczby jednocyfrowe. */
switch (n) {
case 0: wynik.append("zero"); break;
}
}
wynik.append(".");
}
}
Zdecydowanie krótszy kod uzyskamy, deklarujc dwie tablice zawierajce potrzebne

liczebniki.
private static final String[] str1 = {"zero", "jeden", "dwa", "trzy",
"cztery", "pi", "sze", "siedem", "osiem", "dziewi", "dziesi",
"jedenacie", "dwanacie", "trzynacie", "czternacie", "pitnacie",
"szesnacie", "siedemnacie", "osiemnacie", "dziewitnacie"};
private static final String[] str2 = {"", "", "dwadziecia",

"trzydzieci", "czterdzieci", "pidziesit", "szedziesit",
"siedemdziesit", "osiemdziesit", "dziewidziesit"};

System.out.println("Sowny zapis liczby naturalnej mniejszej od 100");

System.out.print("Podaj liczb naturaln mniejsz od 100, n = ");

if (n >= 100 || n < 0) { /* Bdne dane */
} else if (n >= 20) { /* Liczba wiksza lub równa 20 */
wynik.append(str2[n/10]);
int d = n%10; /* Cyfra jednoci */
if (d > 0)
wynik.append(" ").append(str1[d]);
} else if(n >= 10) /* 10, 11, 12, ..., 19 */
wynik.append(str1[n]);
else /* Liczby jednocyfrowe */
wynik.append(str1[n]);
wynik.append(".");
}
}
W pierwszej tablicy zawarto liczby od 0 do 19, a w drugiej pene dziesitki od 20 do

90. Aby unikn oblicze indeksów, dwie pocztkowe wartoci (w drugiej tablicy) s
acuchami pustymi.

Wystarczy uzupeni rozwizanie zadania 13.10 o kod odpowiedzialny za prawidowe
odczytywanie (sownie) cyfry setek w liczbie trzycyfrowej i doczy do tego sowny
zapis dwucyfrowej reszty.
if (n >= 1000 || n < 0) {
/* Bd. To nie jest liczba naturalna mniejsza od 1000. */
} else if (n == 0) {
/* Zero */
} else {
int s = n/100; // Cyfra setek
if (s != 0)
switch (s) {
case 1: wynik.append("sto"); break;
case 2: wynik.append("dwiecie"); break;
case 3: wynik.append("trzysta"); break;
case 4: wynik.append("czterysta"); break;
case 5: wynik.append("piset"); break;
case 6: wynik.append("szeset"); break;
case 7: wynik.append("siedemset"); break;
case 8: wynik.append("osiemset"); break;
case 9: wynik.append("dziewiset"); break;
}
n = n%100;
if (n != 0) {
/* Dalej zajmiemy si dwucyfrow reszt. */
int d = n/10; // Cyfra dziesitek
int j = n%10; // Cyfra jednoci
if (d == 1) {

/* Liczba od 10 do 19 */
} else {
if (d != 0) {
wynik.append(" ");
/* Dopisujemy pene dziesitki: 20, 30, ..., 90. */
}
if (j != 0) {
wynik.append(" ");
/* Dopisujemy jednoci: 1, 2, ..., 9. */
}
}
}
}
wynik.append(".");
W wariancie rozwizania z zastosowaniem tablic (zob. rozwizanie zadania 13.10)

dodajemy tablic str3 zawierajc liczebniki okrelajce pene setki:
private static final String[] str3 = {"", "sto", "dwiecie", "trzysta",
"czterysta", "piset", "szeset", "siedemset", "osiemset",
"dziewiset"};
i wykorzystujemy liczebniki zapisane w tablicach do sownego zapisywania liczby:

if (n >= 1000 || n < 0) /* Bd - niewaciwa liczba */
else if (n == 0) /* Zero */
wynik.append(str1[0]);
else {
int s = n/100; // Cyfra setek
if (s != 0)
wynik.append(str3[s]);
n = n%100;
if (n != 0) {
/* Dalej zajmiemy si dwucyfrow reszt. */
int d = n/10; // Cyfra dziesitek
int j = n%10; // Cyfra jednoci
if (d == 1) /* Dopisujemy liczby od 10 do 19. */
wynik.append(" ").append(str2[n]);
else {
if (d != 0) /* Dopisujemy pene dziesitki: 20, 30,..., 90. */
wynik.append(" ").append(str2[d]);
if (j != 0) /* Dopisujemy jednoci: 1, 2, ..., 9. */
wynik.append(" ").append(str1[j]);
}
}
}
wynik.append(".");
Zwrómy uwag, e odrbne potraktowanie wartoci 0 (w porównaniu z rozwizaniem

zadania 13.10) pozwolio na uproszczenie algorytmu sownego zapisywania liczb mniej-
szych od 100.


Sprawdzanie daty (acucha znaków) wykonujemy w kilku etapach. Efekt kontroli
przechowujemy w zmiennej logicznej isDate typu boolean (warto true oznacza po-
prawn dat, false — bdn). Do kolejnego etapu testu przechodzimy pod warun-
kiem, e poprzedni etap zakoczy si sukcesem. Kolejno sprawdzania przedstawia
si nastpujco:
dugo acucha znaków (10);
obecno cyfr dziesitnych i kropek na odpowiednich pozycjach;
sprawdzenie zakresu dla liczby wyraajcej rok oraz numer miesica i dnia.
Na koniec zalenie od wartoci zmiennej isDate wywietlamy odpowiedni komunikat.

System.out.println("Zmiana formatu daty");
System.out.print("Podaj dat w formacie dd.mm.rrrr: ");
/* Sprawdzamy, czy podany acuch znaków ma waciw dugo
(10 znaków). */
boolean isDate = str.length() == 10;
/* Jeli acuch ma waciw dugo , to sprawdzamy,
czy skada si z waciwych znaków. Znaki o indeksie 2 i 5
powinny by kropkami, a pozostae znaki cyframi. */
if (isDate)
isDate = Character.isDigit(str.charAt(0))
&& Character.isDigit(str.charAt(1))
&& str.charAt(2) == '.'
&& str.charAt(5) == '.'
&& Character.isDigit(str.charAt(9));
/* Jeli acuch znaków jest poprawnie zbudowany, to wyznaczamy
wartoci zmiennych dz (dzie), mc (miesic) i rok. Nastpnie
sprawdzamy poprawno tych danych. */
if (isDate) {
int dz = Integer.parseInt(str.substring(0, 2));
int mc = Integer.parseInt(str.substring(3, 5));
int rok = Integer.parseInt(str.substring(6, 10));
/* Sprawdzamy, czy rok naley do danego stulecia (wieku),
czy numer miesica naley do zakresu od 1 do 12 oraz czy
numer dnia nie przekracza 31. */
isDate = rok >= 2000 && rok < 2100
&& isDate && mc >= 1 && mc <= 12
&& dz > 0 && dz <= 31;
/* Dla kwietnia, czerwca, wrzenia i padziernika sprawdzamy,
czy numer dnia nie przekracza 30. */
if (mc == 4 || mc == 6 || mc == 9 || mc == 11)

isDate = isDate && dz <= 30;

/* Dla lutego w roku przestpnym sprawdzamy, czy numer dnia
nie przekracza 29. */
if (mc == 2 && rok%4 == 0)
/* Dla lutego w roku zwykym sprawdzamy, czy numer dnia nie
przekracza 28. */
if (mc == 2 && rok%4 != 0)
}
/* W zalenoci od wartoci zmiennej logicznej isDate wywietlamy
stosown odpowied. */
if (isDate)
System.out.println(str+" - poprawna data");
else
System.out.println(str+" - bdna data");
}
}
Kod moemy skróci, rezygnujc ze sprawdzania, czy w zapisie daty zastosowano cy-
fry. Podczas parsowania cigów bdny acuch dd, mm lub rrrr spowoduje przerwa-
nie pracy programu — zostanie zgoszony odpowiedni wyjtek. Do sprawdzania po-
prawnoci liczb moemy uy instrukcji wyboru. Oto zmieniony fragment kodu:
/* Sprawdzamy, czy podany acuch znaków ma waciw dugo (10 znaków)
oraz czy znaki o indeksie 2 i 5 s kropkami. */
boolean isDate = str.length() == 10 && str.charAt(2) == '.'
&& str.charAt(5) == '.';
/* Jeli acuch znaków ma posta dd.mm.rrrr, to próbujemy zamieni cigi
znaków dd, mm i rrrr na liczby cakowite, a nastpnie sprawdzimy
wartoci tych liczb. */
if (isDate) {
/* Sprawdzamy, czy rok naley do danego stulecia (wieku), czy numer
miesica naley do zakresu od 1 do 12 oraz czy numer dnia jest
wikszy od 0. */
isDate = rok >= 2000 && rok < 2100 && mc >= 1 && mc <= 12 && dz > 0;
/* Sprawdzamy, czy numer dnia nie przekracza liczby dni w miesicu. */
switch (mc) {
case 2: // luty
if (rok%4 == 0)
isDate = isDate && dz <= 29; // w roku przestpnym
else
isDate = isDate && dz <= 28; // w pozostaych latach
break;
case 4: case 6: case 9: case 11: // kwiecie, czerwiec
isDate = isDate && dz <= 30; // wrzesie, listopad
break;
default:
isDate = isDate && dz <= 31; // pozostae miesice
break;
}
}

Jeli jednak nie chcemy, aby bdnie podana data (np. 12.o6,2013 — litera o zamiast
cyfry 0) powodowaa przerwanie programu, to musimy sprawdza poprawno zna-
ków lub przechwyci i obsuy wyjtek.
if (isDate) {
try {
/* Sprawdzenie pozostawiamy bez zmian; bdzie wykonywane tylko
wtedy, gdy powysze instrukcje wykonaj si poprawnie. */
} catch (NumberFormatException e) {
isDate = false;
}
}

W wejciowym acuchu znaków o postaci dd.mm.rrrr (zakadamy jego poprawno)
musimy zastpi kropki pauzami (dd-mm-rrrr) oraz przestawi (zmieni miejscami) pod-
cigi dd i rrrr (maj róne dugoci!). Efektem bdzie cig znaków o postaci rrrr-mm-dd.

/* Zakadamy poprawno formatu i wartoci wprowadzonej daty. */
StringBuilder data = new StringBuilder(str);
data.replace(2, 3, "-").replace(5, 6, "-");
data.append(data.substring(0,2)).delete(0, 2);
data.insert(0, data.substring(4, 8)).delete(8, 12);
System.out.println(data);
}
}
Przeled my dziaanie programu na przykadzie.
Obiekt data
Wykonywana operacja 111111 (index)
0123456789012345
StringBuilder data = new StringBuilder(str) 21.01.2012
data.replace(2, 3, "-") 21-01.2012
data.replace(5, 6, "-") 21-01-2012
data.append(data.substring(0,2)) 21-01-201221
data.delete(0, 2) -01-201221
data.insert(0, data.substring(4, 8)) 2012-01-201221
data.delete(8, 12) 2012-01-21

Metoda substring() zwraca odpowiedni podacuch znaków z obiektu data, ale

nie modyfikuje wartoci obiektu. Pozostae zastosowane metody (append(), dele-
te(), insert() i replace()) zmieniaj warto obiektu data.
W metodach replace() i delete() pierwszy parametr okrela indeks znaku, od
którego zaczynamy operacj, a drugi parametr jest indeksem znaku, przed którym
koczymy wykonywanie operacji, np. replace(2, 3, "-") zamienia wycznie znak
o indeksie 2 na wskazany acuch, a delete(8, 12) usuwa znaki o indeksach 8,
9, 10 i 11. Metoda insert() wstawia acuch znaków przed znakiem o wskazanym
indeksie.

a) Zakadamy, e uytkownik wprowadzi poprawn dat w postaci cigu
znaków str (dd.mm.rrrr). Wyznaczamy numer miesica:
i tworzymy obiekt data klasy StringBuilder zawierajcy wprowadzon dat.

W obiekcie data zamieniamy kropki (znaki o indeksie 2 i 5, oddzielajce
elementy daty) na odstpy oraz zastpujemy znaki o indeksach 3 i 4 (rr) na
sown nazw miesica. Naley pamita, e w zapisie sownym daty miesic
podajemy w dopeniaczu.
/* Zakadamy poprawno formatu i wartoci wprowadzonej daty. */
data.replace(2, 3, " ").replace(5, 6, " ");
switch (mc) {
case 1: data.replace(3, 5, "stycznia"); break;
case 2: data.replace(3, 5, "lutego"); break;
case 3: data.replace(3, 5, "marca"); break;
case 4: data.replace(3, 5, "kwietnia"); break;
case 5: data.replace(3, 5, "maja"); break;
case 6: data.replace(3, 5, "czerwca"); break;
case 7: data.replace(3, 5, "lipca"); break;
case 8: data.replace(3, 5, "sierpnia"); break;
case 9: data.replace(3, 5, "wrzenia"); break;
case 10: data.replace(3, 5, "pa
dziernika"); break;
case 11: data.replace(3, 5, "listopada"); break;
case 12: data.replace(3, 5, "grudnia"); break;
}
}
}

Podobnie jak w rozwizaniu zada 13.10 i 13.11, moemy zamiast instrukcji

wyboru zastosowa tablic z nazwami miesicy (w dopeniaczu).
private static final String[] mies = {"", "stycznia", "lutego", "marca",
"kwietnia", "maja", "czerwca", "lipca", "sierpnia", "wrzenia",
"pa
dziernika", "listopada", "grudnia"};
Otrzymamy krótszy kod.

data.replace(2, 3, " ").replace(5, 6, " ").replace(3, 5, mies[mc]);
b) Drug cz zadania rozwizujemy w taki sam sposób. Wystarczy zamiast

nazw miesicy (w instrukcji wyboru lub tablicy) wpisa odpowiednie liczby
rzymskie: I, II, III, …, XII.

Algorytm wyznaczania dnia tygodnia na podstawie daty, podany przez Christiana
Zellera, uproci matematyk Mike Keith. Niezbdne obliczenia moemy zrealizowa,
korzystajc ze wzoru:
§ « 23m » «z» « z » « z » ·
dt ¨¨ « » d 4 y« »« » « » c ¸¸ mod 7
©¬ 9 ¼ ¬ 4 ¼ ¬100 ¼ ¬ 400 ¼ ¹
W podanym wzorze wystpuj nastpujce dane:

d — numer dnia w miesicu (ang. day);
m — numer miesica (ang. month): 1 — stycze, 2 — luty, …,
12 — grudzie;
y — liczba wyraajca rok (ang. year).
Wykorzystujemy dwie zmienne pomocnicze:

z — liczba wyraajca rok z poprawk: z = y–1, gdy m < 3 (stycze lub luty);
z = y, gdy m >= 3 (od marca do grudnia);
c — warto korygujca wynik oblicze (ang. correction): c = 0, gdy m < 3
(stycze lub luty);
c = 2, gdy m >= 3 (od marca do grudnia).
Wartoci tych zmiennych wyznaczymy, uywajc instrukcji warunkowych lub wyra-

e warunkowych.
W obliczeniach wykorzystujemy dwie funkcje:

¬ ¼ — oznacza cz cakowit liczby (ang. floor — zaokrglenie w dó,
podoga) — odpowiedni wynik otrzymamy, wykonujc dzielenie cakowite;
mod — operator modulo (reszta z dzielenia) — w Javie jest to operator %.

Wyliczon warto dt (dzie tygodnia) zinterpretujemy nastpujco: 0 — niedziela,

1 — poniedziaek, 2 — wtorek, 3 — roda, 4 — czwartek, 5 — pitek, 6 — sobota.
public static final String[] days = {"niedziela", "poniedziaek",
"wtorek", "roda", "czwartek", "pitek", "sobota"};

System.out.println("Jaki to dzie tygodnia?");
/* Zakadamy, e podana data jest poprawna. Odczytujemy dane. */
int y = Integer.parseInt(str.substring(6, 10));
int m = Integer.parseInt(str.substring(3, 5));
int d = Integer.parseInt(str.substring(0, 2));
/* Wykonujemy obliczenia wedug wzoru Zellera z poprawkami Keitha. */
int z = (m < 3)?y-1:y;
int c = (m < 3)?0:2;
int dt = (23*m/9+d+4+y+z/4-z/100+z/400-c)%7;
/* Budujemy odpowied i zamieniamy warto dt na nazw dnia. */
data.append(" - ").append(days[dt]);
}
}
Fragment wzoru z/4-z/100+z/400 musi pozosta w tej postaci. W kadym z dzie-

le (cakowitych) „gubiona” jest cz uamkowa, czyli wynik obcinamy do czci
cakowitej (w dó). Potraktowanie tego wyraenia jako dziaania na uamkach i spro-
wadzenie do wspólnego mianownika jest bdem!
14. Instrukcja ptli typu do-while

Tworzymy obiekt input klasy Scanner do wczytywania danych z klawiatury. Dekla-
rujemy dwie zmienne typu double: suma — do obliczania i przechowywania sumy liczb,
liczba — do przechowywania wartoci aktualnie wprowadzonej liczby. Zmienna suma
jest zainicjowana wartoci pocztkow sumy (zerem). Pobieranie danych i dodawa-
nie ich do sumy umieszczone jest w ciele ptli typu do-while (ze sprawdzaniem wa-
runku na kocu). Jeli wprowadzona warto jest róna od zera, to powtarzamy instruk-
cje wewntrz ptli, czyli wczytujemy kolejn liczb z klawiatury, dodajemy j do sumy
oraz ponownie sprawdzamy warunek. Cykl si powtarza. Jeli wprowadzona liczba
jest zerem, to jej dodanie do sumy nie zmieni wyniku (liczba 0 jest elementem neu-
tralnym dodawania), natomiast ptla zostanie zakoczona. Na koniec zamkniemy obiekt
input i wywietlimy wynik.

System.out.println("Sumowanie serii liczb zako czonej zerem");
double suma = 0;
double liczba;
do {
System.out.print("x = ");
liczba = input.nextDouble();
suma += liczba;
} while (liczba != 0);
input.close();
System.out.printf("Suma liczb %f\n", suma);
}
}

Metod pobierajc dane ze strumienia wejciowego umiecimy wewntrz ptli typu
do-while. W warunku kocowym porównujemy wprowadzon liczb z zerem. Jeli ta
liczba jest równa zeru lub mniejsza (nie spenia warunków treci zadania, ale spenia
warunek liczba <= 0 na kocu ptli), to powtarzamy cykl, wczytujc kolejn war-
to. Podanie poprawnej wartoci (w tym przypadku liczby dodatniej) powoduje za-
koczenie ptli.
System.out.println("Wczytywanie wycznie liczby dodatniej");
double liczba;
do {
System.out.print("Podaj liczb dodatni, x = ");
liczba = input.nextDouble();
} while (liczba <= 0);
input.close();
System.out.printf("Wprowadzona liczba %f jest dodatnia.\n", liczba);
}
}
Ten kod moemy stosowa wszdzie tam, gdzie potrzebujemy danych speniajcych
okrelone warunki pocztkowe.

Zaczynamy od liczby n = 7 (jednokrotno liczby 7). W ptli wywietlamy warto
liczby, przecinek i odstp oddzielajcy t liczb od wartoci nastpnej oraz zwikszamy
liczb o 7 (kolejna wielokrotno liczby 7). Jeli nastpna wielokrotno jest mniejsza
od 7, to cykl powtarzamy — gdy wielokrotno przekroczy warto 100, koczymy
program.
System.out.println("Wielokrotnoci liczby 7 mniejsze od 100: ");

int n = 7;
do {
System.out.print(n+", ");
n += 7;
} while (n < 100);
}
}
Moemy oddziela liczby innymi znakami, np. odstpem, lub zapisywa kad w in-
nym wierszu. Jeli nie podoba nam si przecinek (i niewidoczny odstp) na kocu cigu
liczb, to moemy nieco zmodyfikowa kod i wewntrz ptli zbada, jaki znak posta-
wi — przecinek czy kropk.
int n = 7;
do {
System.out.print(n);
n += 7;
if (n < 100)
System.out.print(", ");
else
System.out.print(".");
} while (n < 100);
W kolejnym wariancie przecinek i odstp stawiamy przed liczb, z wyjtkiem pierw-

szej wartoci, a po ostatniej wielokrotnoci stawiamy kropk.
int n = 7;
do {
System.out.print(", ");
n += 7;
} while (n < 100);
System.out.println(".");

Pomys przedstawiony w rozwizaniu zadania 14.2 zastosujemy do wprowadzenia do-
datniej wartoci promienia koa.

System.out.println("Obliczanie pola powierzchni koa");
double r;
do {
System.out.print("Podaj promie koa, r = ");
r = input.nextDouble();
if (r <= 0)
System.out.println("Promie koa powinien by liczb
dodatni!");
} while (r <= 0);

input.close();
System.out.printf("Pole koa P = %f\n", Math.PI*r*r);
}
}
Warto wyraenia logicznego r <= 0 jest obliczana dwukrotnie. Raz w instrukcji

warunkowej, po to aby wywietli komunikat o bdnie podanej wartoci, a drugi raz
podczas badania warunku zakoczenia ptli.
Nieskoczon ptl do {...} while(true) (warunek zawsze speniony — true) mo-

emy przerwa poleceniem break; gdy r <= 0, wywietlamy komunikat o bdzie,
w przeciwnym razie przerywamy ptl (promie jest dodatni).
do {
System.out.print("Podaj promie koa, r = ");
if (r <= 0)
System.out.println("Promie koa powinien by liczb dodatni!");
else
break;
} while (true);

Pole piercienia koowego obliczymy ze wzoru
P SR 2 Sr 2 S R 2 r 2 S R r R r ,
gdzie 0 r R , r — promie wewntrzny (w kodzie r1), R — promie zewntrzny
(r2). Majc do wyboru trzy wzory, wybierzemy ten, który wymaga najmniejszej liczby
dziaa do wykonania — liczc od lewej strony: 4 mnoenia i odejmowanie (5 dzia-
a); 3 mnoenia i odejmowanie (4 dziaania); 2 mnoenia, odejmowanie i dodawanie
(4 dziaania) — w tym najmniej mnoe, które zabieraj wicej czasu ni odejmowa-
nie lub dodawanie.
System.out.println("Obliczanie pola piercienia koowego");
double r1, r2;
do {
System.out.print("Podaj promie zewntrzny, R = ");
r2 = input.nextDouble();
if (r2 <= 0)
System.out.println("Promie powinien by dodatni!");
} while (r2 <= 0);
do {
System.out.print("Podaj promie wewntrzny, r = ");
r1 = input.nextDouble();
if (r1 <= 0)
System.out.println("Promie powinien by dodatni!");
if (r1 >= r2)
System.out.println("Promie wewntrzny powinien by mniejszy
od zewntrznego!");

} while (r1 <= 0 || r1 >= r2);

input.close();
System.out.printf("Pole piercienia P = %f\n", Math.PI*(r2-r1)*(r2+r1));
}
}
Zwrómy uwag na oddzielne badanie warunków wewntrz drugiej ptli (wskazanie

przyczyny bdu) i alternatyw warunków powodujcych powtórne wczytywanie du-
goci promienia wewntrznego.

Tworzymy trzy zmienne a, b i c typu int do przechowywania trzech kolejnych warto-
ci cigu Fibonacciego. Zaczynamy (od pocztku cigu), podstawiajc a = 1, b = 1
i obliczajc trzeci wyraz c = a+b (warto pocztkowa 2). Wywietlamy dwa poczt-
kowe wyrazy a i b. Nastpnie wchodzimy do ptli:
wywietlamy wyraz c,
przesuwamy dwie wartoci a = b; b = c;,
obliczamy kolejny wyraz cigu c = a+b.
Gdy warto c jest mniejsza ni 1000, powtarzamy cykl.

System.out.println("Liczby Fibonacciego mniejsze od 1000:");
int a = 1, b = 1; // Dwa pierwsze wyrazy cigu
System.out.print(a+", "+b);
int c = a+b; // Kolejny wyraz cigu
do {
System.out.print(", "+c);
a = b;
b = c;
c = a+b;
} while (c < 1000);
System.out.println(".");
}
}
Zwrómy uwag na wywietlanie przecinka i odstpu midzy liczbami oraz postaw-

my kropk na kocu odpowiedzi (po wyjciu z ptli).

Tym razem nie wywietlamy liczb Fibonacciego, ale obliczamy, ile jest w cigu liczb
mniejszych od zadanej liczby cakowitej n. Poniewa najmniejsz liczb w tym cigu
jest 1, to dla n d 1 poprawn odpowiedzi bdzie 0 i tak warto pocztkow nada-
jemy zmiennej licznik. W trakcie oblicze ta warto moe si zmieni. Dla n 2
mamy w cigu dwie wartoci mniejsze, zmiennej licznik nadamy warto 2. Jeli n > 2,
to obliczamy w ptli kolejne wyrazy cigu (wedug algorytmu z zadania 14.6) i inkre-
mentujemy zmienn licznik. Ptla koczy si, gdy kolejny obliczony wyraz c osi-
gnie lub przekroczy warto n (dla c < n cykl jest kontynuowany).

System.out.println("Ilo liczb Fibonacciego mniejszych od n");
System.out.print("Podaj liczb cakowit, n = ");
input.close();
int licznik = 0;
if (n == 2)
licznik = 2;
else if (n > 2) {
int a = 1, b = 1;
int c = a+b;
licznik += 2; // dwa pocztkowe wyrazy
do {
++licznik; // kolejny wyraz cigu
a = b;
b = c;
c = b+a;
} while (c < n);
}
System.out.println(licznik);
}
}

Obliczenia powtarzamy w ptli, której wykonywanie zaley od wartoci zmiennej a:
double a;
do {
/* Wprowadzanie danych, badanie poprawnoci i obliczenia */
} while(a > 0);
Ptla wykona si co najmniej raz, a jej dalsze dziaanie zaley od pobranej (w instruk-
cji wewntrz ptli) wartoci zmiennej a. Dodatnia warto zmiennej (decyduje wynik
porównania a > 0) spowoduje powtórzenie cyklu, ujemna lub zero — zakoczenie ptli.
Druga, wewntrzna ptla ma za zadanie testowanie poprawnoci danych i zmusza uyt-

kownika do wprowadzenia liczby dodatniej (prawidowa dugo boku) lub 0 — przy-
jty umownie sygna zakoczenia oblicze. Obliczenia s wykonywane wycznie, gdy
a > 0, natomiast po podaniu wartoci 0 pojawi si komunikat Koniec oblicze i pro-
gram zakoczy dziaanie.
double a;
do {
System.out.println("Pole trójkta równobocznego");
do {
System.out.print("Dugo boku (0 - koniec), a = ");

} while (a < 0);

if (a > 0) {
double pole = a*a*Math.sqrt(3)/4;
System.out.println("P = "+pole);
} else
System.out.println("Koniec oblicze .");
} while (a > 0);
input.close();
}
}
Wprowad my kilka poprawek. Zamiast wielokrotnego wywoywania funkcji sqrt dla

staego argumentu 3 i dzielenia wyniku przez 4 wprowadzimy dodatkow zmienn
(wspóczynnik wystpujcy we wzorze na pole trójkta równobocznego) double wsp
3
= Math.sqrt(3)/4 przechowujc przyblienie liczby . Podanie ujemnej wartoci
4
dla zmiennej a zasygnalizujemy komunikatem Dugo powinna by dodatnia! Gówn
ptl programu przerwiemy po wprowadzeniu dugoci boku równej 0, stosujc in-
strukcj break, wic kocowy warunek moemy zastpi wartoci sta true (ptla
bdzie nieskoczona).
double a;
double wsp = Math.sqrt(3)/4;
do {
System.out.println("Pole trójkta równobocznego");
do {
System.out.print("Dugo boku (0 - koniec), a = ");
if (a < 0)
System.out.println("Dugo powinna by dodatnia!");
} while (a < 0);
if (a > 0) {
double pole = a*a*wsp;
System.out.printf("P = %.2f\n", pole);
} else {
System.out.println("Koniec oblicze .");
break;
}
} while (true);

Zmienna odp typu char przechowuje informacj potrzebn do podjcia decyzji o po-
wtórzeniu oblicze. Na pocztku nadajemy jej dowoln warto rón od 't' i 'n'.
Gówna ptla zawiera obliczenia (zgodnie z treci zadania) i pytanie o powtarzanie

oblicze, modyfikujce warto zmiennej odp stosownie do podjtej decyzji.
char odp = "?";
do {
/* instrukcje - obliczenia, zapytanie o powtórzenie oblicze */
} while(odp == 't');

Przed gówn ptl tworzymy obiekt input klasy Scanner, a po jej zakoczeniu zamy-
kamy go. Stosujc metody obiektu input, odczytamy dane potrzebne do oblicze oraz
odpowied na pytanie, czy kontynuujemy obliczenia.
Pytanie o kontynuacj oblicze zawrzemy w kolejnej ptli. Przed wejciem do ptli

odczytujemy cay wiersz, usuwajc w ten sposób reszt znaków ze strumienia (aby
nie miay wpywu na podejmowanie decyzji). W ptli zadajemy uytkownikowi pyta-
nie Czy obliczamy dalej (t/n)? z sugerowan odpowiedzi t — tak lub n — nie.
Kada inna odpowied bdzie ignorowana i spowoduje powtórzenie pytania (równie
nacinicie klawisza Enter — pusty acuch). Jeli podan odpowiedzi (zmienna s)
nie jest pusty acuch, to pobieramy pierwszy znak do zmiennej odp, a reszt znaków
pomijamy.
String s = input.nextLine();
do {
System.out.print("Czy obliczamy dalej (t/n)? ");
s = input.nextLine();
if (!s.isEmpty())
odp = s.charAt(0);
} while(s.isEmpty() || odp != 't' && odp != 'n');
Po wyjciu z ptli zmienna odp moe mie wycznie warto 't' lub 'n'. Ta odpo-
wied zadecyduje o dalszym dziaaniu programu. Warunek s.isEmpty() || odp != 't'
&& odp != 'n' moemy zastpi równowanym warunkiem s.isEmpty() || !(odp
== 't' || odp == 'n').
Oto kompletny listing programu:

char odp = '?';
do {
/* Obliczenia */
System.out.println("Obliczanie dugoci okrgu");
double r;
do {
System.out.print("Podaj promie okrgu, r = ");
} while (r <= 0);
System.out.printf("Dugo okrgu L = %.4f\n", 2*Math.PI*r);
/* Koniec oblicze * Pytanie o kontynuacj oblicze */
String s = input.nextLine();
do {
System.out.print("Czy obliczamy dalej (t/n)? ");
if (!s.isEmpty())
odp = s.charAt(0);
} while(s.isEmpty() || odp != 't' && odp != 'n');
} while (odp == 't');
input.close();
}
}

15. Instrukcja ptli typu while

Dane wejciowe s sprawdzane podczas ich wprowadzania (nie dopuszczamy liczb
cakowitych ujemnych) i proces dodawania przeprowadzimy dla liczb naturalnych (ca-
kowitych nieujemnych). Algorytm oblicze jest nastpujcy: dopóki liczba n jest do-
datnia, zmniejszamy n o 1 (--n) i jednoczenie zwikszamy m o 1 (++m):
while (n > 0) {
--n; // Zmniejszamy n o 1.
++m; // Zwikszamy m o 1.
}
Po wyjciu z ptli zmienna n ma warto 0, a m zawiera obliczon sum. Obrazowo

ten algorytm moemy przedstawi jako przekadanie patyczków z jednego stosu na
drugi, oczywicie dopóki stos, z którego zabieramy patyczki, nie jest pusty.
/* Wprowadzanie danych */
System.out.println("Podaj dwie liczby naturalne:");
int m, n;
do {
System.out.print("m = ");
m = input.nextInt();
} while (m < 0);
do {
System.out.print("n = ");
n = input.nextInt();
} while (n < 0);
input.close();
/* Obliczenia i wynik */
while (n > 0) {
++m; // Zwikszamy m o 1.
}
System.out.printf("Suma liczb %d\n", m);
}
}
Ptl realizujc obliczenia moemy zapisa równie tak: while (n-- > 0) ++m;. Za-
stosowana postdekrementacja (n--) w wyraeniu n-- > 0 powoduje skrócenie zapisu.
Dziaa to w taki sposób: tworzona jest kopia wartoci zmiennej n, warto zmiennej n
jest zmniejszana o 1, do porównywania z zerem brana jest przechowana kopia. Nie
wpywa to na liczb powtórze ptli, wic program dziaa tak samo. Pozostaje jednak
pewna rónica w wartoci kocowej zmiennej n. W tym programie nie ma to jednak
znaczenia.


Jeli liczba n jest dodatnia, to realizujemy algorytm omówiony w rozwizaniu zadania
15.1. Dla ujemnych wartoci n musimy postpi odwrotnie — bdziemy zwiksza n
o 1 i jednoczenie zmniejsza m o 1. Gdy n osignie warto 0, to m bdzie równe sumie
pocztkowych wartoci m i n.
W zalenoci od znaku zmiennej n wykona si albo pierwsza ptla (n > 0), albo druga
(n < 0), albo adna z nich (n = 0). Za kadym razem kocowa warto m bdzie szu-
kan sum.
System.out.println("Podaj dwie liczby cakowite:");
int m = input.nextInt();
input.close();
while (n > 0) {
--n;
++m;
}
while (n < 0) {
++n;
--m;
}
System.out.printf("Suma liczb %d\n", m);
}
}
Upraszczajc zapis obu ptli, nie uzyskamy oczekiwanego rezultatu. Wynik bdzie
zawsze o 1 mniejszy od sumy liczb. Jest to efekt zmiany wartoci zmiennej n podczas
badania warunku, na co zwracano uwag w rozwizaniu zadania 15.1.
while (n-- > 0) ++m;
while (n++ < 0) --m;
Moemy to skorygowa, zwikszajc kocow warto m o 1 (++m) lub stosujc dodat-

kow instrukcj warunkow:
if (n > 0)
while (n-- > 0) ++m;
else
while (n++ < 0) --m;
Jeli zmienimy kolejno ptli, to wynik bdzie o 1 wikszy od sumy.

while (n++ < 0) --m;
while (n-- > 0) ++m;

Naley wystrzega si tego typu uproszcze, a jeli ju si na nie zdecydujemy, to mu-
simy dokadnie analizowa dziaanie kodu. Upraszczajc zapis, czynimy kod mniej
czytelnym.
Zadanie 15.3a. Z15_3a.java

Dane wprowadzimy podobnie jak w rozwizaniu zadania 15.1. Skorzystamy z faktu,
e mnoenie jest skróconym sposobem zapisu wielokrotnego dodawania tej samej licz-
by. Ustalimy pocztkow warto iloczynu równ 0. Do tej wartoci dodamy n-krotnie
liczb m, czyli zmienna n odegra rol licznika dodawa.
int iloczyn = 0;
while (n > 0) {
--n; // Zmniejszamy (licznik dodawa) n o 1.
iloczyn = iloczyn+m; // Zwikszamy iloczyn o m.
}
System.out.printf("Iloczyn liczb %d\n", iloczyn);
Zadanie 15.3b. Z15_3b.java

Dane wprowadzimy podobnie jak w rozwizaniu zadania 15.2. Najpierw zgodnie
z zasadami arytmetyki ustalimy znak iloczynu, a nastpnie wykonamy obliczenia dla
liczb dodatnich — bezwzgldnych wartoci z danych wejciowych. Gdy co najmniej
jeden z czynników jest zerem, iloczyn bdzie równy 0 (warto pocztkowa zmiennej
iloczyn).
int iloczyn = 0;
int znak;
if (n != 0 && m != 0) {
if (n > 0)
znak = 1;
else {
znak = -1;
n = -n;
}
if (m < 0) {
znak = -znak;
m = -m;
}
while (n > 0) {
iloczyn = iloczyn+m; // Zwikszamy iloczyn o m.
}
if (znak == -1)
iloczyn = -iloczyn;
}
System.out.printf("Iloczyn liczb %d\n", iloczyn);

Dane wprowadzimy podobnie jak w rozwizaniu zadania 15.2. Dla liczb dodatnich
obliczenie ilorazu cakowitego polega na wielokrotnym odejmowaniu dzielnika (do-
póki dzielna nie jest mniejsza od dzielnika) i zliczaniu liczby odejmowa. Rol licz-
nika odgrywa zmienna iloraz.

int iloraz = 0;
while (m >= n) {
++iloraz;
m = m-n;
}
Jeli dzielna lub dzielnik s liczbami ujemnymi, ustalimy znak ilorazu (podobnie jak
znak iloczynu w zadaniu 15.3b), a obliczenia wykonamy dla bezwzgldnych wartoci
dzielnej i dzielnika. Pozostaje jeszcze problem dzielenia przez 0 — w takiej sytuacji
zgosimy wyjtek throw new ArithmeticException("dzielenie przez zero").
if (n == 0) {
throw new ArithmeticException("dzielenie przez zero");
} else {
int iloraz = 0;
int znak = 1;
if (m < 0) {
znak = -1;
m = -m;
}
if (n < 0) {
znak = -znak;
n = -n;
}
while (m >= n) {
++iloraz;
m = m-n;
}
if (znak == -1)
iloraz = -iloraz;
System.out.printf("Iloraz cakowity %d\n", iloraz);
}

Dla dodatnich liczb cakowitych m i n reszt z dzielenia m przez n wyznaczymy, stosujc
ptl while (m >= n) m = m-n; — po wyjciu z ptli zmienna m ma warto szukanej
reszty. W ogólnym przypadku wyznaczamy znak reszty, który jest taki sam jak znak
dzielnej, i wykonujemy obliczenia dla bezwzgldnych wartoci dzielnej i dzielnika.
if (n == 0) {
throw new ArithmeticException("dzielenie przez zero");
} else {
int znak = 1;
if (m < 0) {
znak = -1;
m = -m;
}
if (n < 0)
n = -n;
while (m >= n)
m = m-n;

if (znak == -1)
m = -m;
System.out.printf("Reszta z dzielenia %d\n", m);
}

Zaczynamy obliczenia od wartoci p = 0. Dopóki kwadrat zmiennej p nie przekroczy
wartoci n (p*p <= n), zwikszamy warto p o 1 (++p). Po wyjciu z ptli zmienna p
jest o 1 wiksza od pierwiastka cakowitego z n, wic korygujemy wynik (--p).
System.out.println("Cakowity pierwiastek kwadratowy");
int n;
do {
System.out.print("Podaj liczb naturaln, n = ");
} while (n < 0);
int p = 0;
while (p*p <= n) ++p;
--p; // Korekta wyniku
System.out.printf("Pierwiastek cakowity z %d jest równy %d.\n", n, p);
}
}

Wczytywanie danych zorganizujemy tak, jak w rozwizaniu zadania 15.1. Zmiennej
nww (najmniejsza wspólna wielokrotno ) nadamy warto pocztkow równ warto-
ci zmiennej m (pierwsza liczba). Dopóki nww nie jest podzielne przez drug liczb n
(reszta nww%n jest róna od 0), obliczamy kolejn wielokrotno liczby m (nww += m).
Po wyjciu z ptli zmienna nww zawiera poszukiwan warto.
int nww = m;
while (nww%n != 0)
nww += m;
System.out.printf("NWW(m, n) = %d.\n", nww);
Algorytm jest skuteczny, ale nie zawsze najszybszy. Np. dla pary liczb m = 1000 i n = 2
ptla nie wykona si ani razu, a wynikiem bdzie liczba 1000. Natomiast dla pary m = 2
i n = 1000 ptla wykona si 499 razy (1000:2–1), zanim zmienna nww osignie prawi-
dow warto. Wniosek nasuwa si sam — jako pocztkow warto nww wybierzmy
wiksz z liczb.
int nww;
if (m > n) {
nww = m;
while (nww%n != 0)
nww += m;
} else if (n > m) {
nww = n;

while (nww%m != 0)
nww += m;
} else
nww = m; // m i n s równe
System.out.printf("NWW(m, n) = %d.\n", nww);
Liczba powtórze ptli w najgorszym przypadku osignie warto mniejszej z tych

liczb, pomniejszon o 1. W tym przypadku NWW(m, n) = mn (liczby m i n s wzgld-
nie pierwsze).

Algorytm Euklidesa opiera si na spostrzeeniu, e dla dowolnych dwóch liczb natu-
ralnych mniejsza sporód nich i ich rónica maj taki sam najwikszy wspólny dziel-
nik (NWD) jak te liczby. Tworzymy zatem cig kolejnych par liczb — mniejsza liczba
i rónica liczb (od wikszej odejmujemy mniejsz). Jeli w wyniku kolejnego odej-
mowania otrzymamy par równych liczb, to wanie ona bdzie poszukiwanym NWD.
while (m != n)
if (m > n)
m = m-n;
else
n = n-m;
System.out.printf("NWD(m, n) = %d.\n", m);
Istnieje druga wersja (szybsza) tego algorytmu. Zauwamy, e wielokrotne odejmo-

wanie tej samej liczby prowadzi do wyznaczenia reszty z dzielenia (zob. rozwizanie
zadania 15.5). Ponadto jeli uzyskamy reszt równ 0, to dzielnik jest podzielnikiem
dzielnej i bdzie to wanie szukany NWD. Zobaczmy to na przykadzie:
1. Wersja algorytmu z odejmowaniem — NWD(32, 10) = NWD(22, 10) =
NWD(12, 10) = NWD(2, 10) = NWD(2, 8) = NWD(2, 6) = NWD(2, 4) =
NWD(2, 2) = 2.
2. Wersja z dzieleniem z reszt — NWD(32, 10) = NWD(10, 2) = 2, bo 32:10 =
3 r. 2, 10:2 = 5 r. 0.
Wprowadzamy pomocnicz zmienn p, która jest wykorzystywana do zamiany miej-

scami wartoci przechowywanych w zmiennych m i n.
int p;
while (n != 0) {
p = m%n;
m = n;
n = p;
}
System.out.printf("NWD(m, n) = %d.\n", m);

Zgodnie z opisem tworzymy dwie zmienne wm i wn typu int, w których bdziemy prze-
chowywali wielokrotnoci liczb m i n. Na pocztku bd to jednokrotnoci danych
wejciowych. Dopóki wielokrotnoci wm i wn s róne, obliczmy kolejne krotnoci tej
liczby, której aktualna wielokrotno jest mniejsza od drugiej wielokrotnoci. Gdy

wielokrotnoci zrównaj si, wychodzimy z ptli — najmniejsza wspólna wielokrot-

no m i n zostaa obliczona.
int wm = m; // wielokrotno liczby m
int wn = n; // wielokrotno liczby n
while (wm != wn)
if (wm > wn)
wn += n; // kolejna wielokrotno liczby n
else
wm += m; // kolejna wielokrotno liczby m
System.out.printf("NWW(m, n) = %d.\n", wm);
16. Instrukcja ptli typu for

W rozwizaniu zadania wykorzystamy wzór 1 3 ... (2n 1) n 2 . Sumowanie prze-
prowadzimy w ptli for dla i = 0, 1, 2, … n-1 — czyli w ptli dodamy n pocztkowych
liczb nieparzystych, uzyskujc sum n2.
int kw = 0; // kwadrat liczby 0, pocztkowa warto sumy
int lnp = 1; // pierwsza liczba nieparzysta
for(int i = 0; i < n; ++i) {
kw += lnp; // kolejny kwadrat (dodana kolejna liczba nieparzysta)
lnp += 2; // kolejna liczba nieparzysta
}
System.out.printf("Kwadrat liczby %d jest równy %d.\n", n, kw);
Przeanalizujmy, jak dziaa ptla for(int i = 0; i < n; ++i) { instrukcja }. Po

sowie kluczowym for w nawiasach okrgych mamy trzy wane elementy, oddzielo-
ne rednikami (;). Pierwszy element to instrukcja inicjujca. Przed wejciem do ptli
deklarowana i inicjowana jest zmienna i (int i = 0), która bdzie odgrywaa rol
licznika powtórze ptli. Przed kadym wykonaniem instrukcji zawartej w ciele ptli
({ instrukcja }) sprawdzany jest warunek (i < n) — jeli warunek jest speniony
(warto true), to instrukcja jest wykonywana, w przeciwnym wypadku (warto fal-
se) nastpuje zakoczenie ptli. Po wykonaniu instrukcji z ciaa ptli wykonywana
jest instrukcja modyfikujca — w naszym przykadzie inkrementujca licznik powtó-
rze ptli (++i).
Uywajc operatora przecinkowego (,) do grupowania wyrae, moemy przenie

deklaracj i zainicjowanie zmiennej lnp do instrukcji inicjujcej ptl for. Podobnie
zwikszanie tej zmiennej o 2 umiecimy w instrukcji modyfikujcej. W ciele ptli po-
zostanie instrukcja podstawiania (kw += lnp) sumujca liczby nieparzyste.
int kw = 0;
for(int i = 0, lnp = 1; i < n; ++i, lnp += 2)
kw += lnp;
Poniewa zmienne zainicjowane w ptli for maj zasig lokalny, ograniczony do ciaa
tej ptli, to deklaracja i inicjalizacja zmiennej kw musz nastpi przed ptl. Nic nie

stoi na przeszkodzie, aby instrukcj kw += lnp; umieci w instrukcji modyfikujcej

ptli for.
int kw = 0;
for(int i = 0, lnp = 1; i < n; ++i, kw += lnp, lnp += 2);
Instrukcja w ciele ptli jest instrukcj pust (nie zapomnijmy o redniku), natomiast
instrukcje tworzce instrukcj modyfikujc musz by ustawione w odpowiedniej
kolejnoci. Takich „uproszcze” jednak nie polecamy.

Ze standardowego strumienia wejciowego wczytujemy jedno sowo (acuch s). Prze-
gldajc w ptli for (znak po znaku) acuch s, budujemy obiekt str (klasy String
Builder) ze znaków acucha s. Poniewa kolejne znaki wstawiamy na pocztek a-
cucha, to w efekcie otrzymamy odwrócony cig znaków. Obiekt str zamienimy na
acuch znaków (obiekt klasy String), zapisany maymi literami (str.toString().
toLowerCase()) i porównamy z acuchem wejciowym s zapisanym maymi literami
(s.toLowerCase()). Porównanie to zrealizujemy, uywajc metody equals() dla jed-
nego z tych acuchów, natomiast drugi acuch bdzie parametrem. T sam warto
otrzymamy dla porównania s.toLowerCase().equals(str.toString().toLowerCase())
oraz str.toString().toLowerCase().equals(s.toLowerCase()). W zalenoci od wy-
niku porównania formuujemy odpowied .
System.out.println("Czy to jest palindrom?");
/* Wczytywanie danych */
System.out.print("Podaj sowo do sprawdzenia: ");
String s;
s = input.next();
input.close();
/* Odwracanie sowa */
int n = s.length();
StringBuilder str = new StringBuilder();
for(int i = 0; i < n; ++i)
str.insert(0, s.charAt(i));
/* Porównywanie sowa podanego ze sowem odwróconym */
if (s.toLowerCase().equals(str.toString().toLowerCase()))
System.out.println("Sowo: \""+s+"\" - jest palindromem.");
else
System.out.println("Sowo: \""+s+"\" - nie jest palindromem.");
}
}
Odwrócenie znaków moemy zrealizowa, czytajc znaki acucha s od koca. W tym

celu uyjemy ptli for z odliczaniem w dó.
int n = s.length();
for(int i = n-1; i >= 0; --i)
str.append(s.charAt(i));

Korzystajc z dostpnych metod w klasach String i StringBuilder, moemy zrealizo-

wa zadanie bez ptli i deklarowania pomocniczych zmiennych.
if (s.toLowerCase().equals(new
StringBuilder(s).reverse().toString().toLowerCase()))
System.out.println("Sowo: \""+s+"\" - jest palindromem.");
else
System.out.println("Sowo: \""+s+"\" - nie jest palindromem.");

Ze standardowego strumienia wejciowego wczytujemy jeden wiersz (acuch s). Prze-
gldajc w ptli for (znak po znaku) acuch s, budujemy obiekt str (klasy String
Builder) ze znaków acucha s, pomijajc przy tym znaki odstpu:
int n = s.length();
/* Budujemy odwrócony acuch, bez odstpów. */
for(int i = 0; i < n; ++i)
if (s.charAt(i) != ' ')
str.insert(0, s.charAt(i));
lub
for(int i = n-1; i >= 0; --i)
if (s.charAt(i) != ' ')
str.append(s.charAt(i));

acuch s moe zawiera odstpy, a w odwróconym acuchu w obiekcie str odst-
pów nie ma, wic porównywanie tych acuchów nie da prawidowego rezultatu. Mo-
emy porówna acuch str.toString().toLowerCase() z acuchem odwróconym
(metod reverse()) str.reverse().toString().toLowerCase(). Naley pamita, e
wywoanie metody str.reverse() przestawi elementy w acuchu str.
Proponujemy zrealizowa badanie palindromu w ptli:

boolean palindrom = true;
n = str.length();
for(int i = 0, j = n-1; i < j; ++i, --j)
palindrom = palindrom && Character.toLowerCase(str.charAt(i)) ==
Character.toLowerCase(str.charAt(j));
Zakadamy, e wyraenie jest palindromem (zmienna logiczna palindrom = true).

Pocztkowo w ptli zmienna sterujca i wskazuje na pierwszy znak acucha, a zmien-
na j na ostatni znak. Powtarzanie cyklu porówna trwa, jeli i < j. Po kadym cyklu
i zwiksza warto o 1 (++i), a j zmniejsza warto o 1 (--j) — porównywane znaki
zbliaj si do rodka acucha. Porównywane znaki zamieniamy na mae litery, a ko-
niunkcj wyniku porównania i zmiennej palindrom przypisujemy do zmiennej palin-
drom. Jeli zmienna palindrom przyjmie warto false w którym porównaniu, to tak
ju pozostanie do koca ptli. Dlatego te moglibymy w tym momencie porównywa-
nie zakoczy — wystarczy zmodyfikowa warunek w ptli for(int i = 0, j = n-1;
i < j && palindrom; ++i, --j).

Aby uproci wyraenia porównujce znaki, moemy w trakcie budowania acucha

str zamienia litery na mae.

Tabliczk mnoenia zbudujemy w postaci dwuwymiarowej tabeli z wierszem nagów-
ka, zawierajcym symbol mnoenia (wykorzystano w tym celu wielk liter X), i licz-
bami od 1 do 9 (dziewi kolumn). Boczek tabeli zawiera równie liczby od 1 do 9,
odpowiadajce dziewiciu wierszom tabliczki mnoenia. W komórkach, na skrzy-
owaniu wiersza i kolumny, wpisujemy odpowiednie iloczyny. Ptl for stosujemy
czterokrotnie:
do zbudowania acucha znaków linia, zawierajcego 51 znaków minus (–)
i uywanego do rysowania poziomych linii;
do zbudowania wiersza nagówka;
dwie zagniedone ptle wypeniaj tabel — ptla zewntrzna tworzy
kolejne wiersze, ptla wewntrzna wypenia je iloczynami.
System.out.println("Tabliczka mnoenia\n");
/* Linia pozioma */
StringBuilder linia = new StringBuilder();
for(int i = 0; i < 51; ++i)
linia.append("-");
/* Wiersz nagówka */
System.out.println(linia);
System.out.print("| X |");
for(int i = 1; i < 10; ++i)
System.out.printf("%3d |", i);
/* Tabliczka mnoenia */
for(int j = 1; j < 10; ++j) {
System.out.printf("|%3d |", j);
for(int i = 1; i < 10; ++i)
System.out.printf("%3d |", i*j);
}
}
}

W rozwizaniu zadania zastosujemy schemat opracowany w zadaniu 16.4. Tabelki maj
mniejszy wymiar, zawieraj (nie liczc nagówka i boczku) po 6 kolumn i 6 wierszy od-
powiadajcych liczbom od 0 do 10 w ukadzie pitkowym, czyli od 0 do 5 w ukadzie
dziesitkowym. Obliczenia wykonujemy na liczbach cakowitych zapisanych w ukadzie
dziesitkowym, a wyniki konwertujemy na ukad pitkowy (Integer.toString(i, 5)).

Podobny kod wykorzystujemy dwukrotnie, budujc tabliczk dodawania i tabliczk

mnoenia.
System.out.println("Pitkowy system liczenia\n");
StringBuilder linia = new StringBuilder();
for(int i = 0; i < 36; ++i)
linia.append("-");
/* Tabliczka dodawania */
System.out.println("Tabliczka dodawania");
for(int i = 0; i <= 5; ++i)
System.out.printf("%3s |", Integer.toString(i, 5));
for(int j = 0; j <= 5; ++j) {
System.out.printf("|%3s |", Integer.toString(j, 5));
for(int i = 0; i <= 5; ++i)
System.out.printf("%3s |", Integer.toString(i+j, 5));
}
/* Tabliczka mnoenia */
System.out.println("Tabliczka mnoenia");
for(int i = 0; i <= 5; ++i)
System.out.printf("%3s |", Integer.toString(i, 5));
for(int j = 0; j <= 5; ++j) {
System.out.printf("|%3s |", Integer.toString(j, 5));
for(int i = 0; i <= 5; ++i)
System.out.printf("%3s |", Integer.toString(i*j, 5));
}
}
}

Cig harmoniczny to cig odwrotnoci kolejnych liczb naturalnych 1, 1 , 1 , 1 ... . Naj-
2 3 4
pierw wprowadzamy liczb wyrazów cigu n — robimy to w ptli (do ... while ...),
nie pozwalajc uytkownikowi na podanie zera lub liczby ujemnej (w takim przypad-
ku ponawiamy prob o podanie liczby).
Znajc liczb wyrazów cigu, w ptli (for) obliczamy kolejne wyrazy i dodajemy je
do sumy (suma += 1.0/i — aby uzyska wynik zmiennoprzecinkowy, dzielna lub
dzielnik musi by liczb zmiennoprzecinkow. Alternatyw dla podanej instrukcji jest
instrukcja suma += 1/(double)i).

System.out.println("Suma wyrazów cigu harmonicznego");
int n;
do {
System.out.print("Liczba wyrazów, n = ");
} while (n <= 0);
input.close();
double suma = 0.0;
for(int i = 1; i <= n; ++i)
suma += 1.0/i;
System.out.printf("Suma %d wyrazów cigu harmonicznego jest
równa %f.\n", n, suma);
}
}

Warto liczby n uytkownik podaje z klawiatury. Podobnie jak w rozwizaniu zada-
nia 16.6, ograniczamy wprowadzane wartoci do liczb naturalnych (cakowitych nie-
ujemnych). Poniewa 0! = 1 i 1! = 1, to ustalamy pocztkow warto zmiennej silnia
równ 1 (long silnia = 1L; — litera L lub l na kocu literau oznacza, e jest to wiel-
ko typu long. Maa litera l moe myli si z cyfr 1, zatem lepiej stosowa wielk
liter L). W ptli (for) mnoymy warto zmiennej silnia przez kolejne liczby natu-
ralne, uzyskujc ostateczny wynik iloczynu 1·2·3·…·n, czyli warto n!.
System.out.println("Obliczanie silni liczby naturalnej");
int n;
do {
} while (n < 0);
input.close();
long silnia = 1;
for(int i = 1; i <= n; ++i)
silnia *= i;
System.out.printf("%d! = %d\n", n, silnia);
}
}
Nie ograniczylimy podczas wprowadzania danych wartoci zmiennej n. Musimy jed-

nak pamita, e warto silni bardzo szybko ronie i moemy obliczy co najwyej
20! = 2432902008176640000 (dla typu long). Nastpna warto silni przekroczy war-
to Long.MAX_VALUE równ 9223372036854775807.


Obliczenia umiecimy w ptli for o postaci for(;;) {instrukcja;}. Jest to ptla nie-
skoczona (nie ma inicjowania zmiennej sterujcej, sprawdzania i modyfikacji warunku)
i bdzie wykonywana a do chwili, gdy przerwie j jaka instrukcja z wntrza bloku.
Podobny efekt mona uzyska w ptli while(true) { instrukcja; } lub do { instruk-

cja; } while(true);.
Wewntrz ptli wprowadzamy dane z konsoli — podstaw a typu double i wykadnik

n (dopuszczaln wartoci jest liczba naturalna lub –1). Podanie wykadnika równego
–1 spowoduje przerwanie ptli (for) i zakoczenie oblicze (if (n == -1) break;).
Przyjmujemy warto pocztkow potgi double pot = 1.0; ( a 0 1, a z 0 ) i na-

1 2 n
stpnie w ptli obliczamy kolejne potgi ( a , a , ..., a ):
for(int i = 1; i <= n; ++i)
pot *= a;
Program ma jedn wad — oblicza warto symbolu nieoznaczonego 00 , podajc wy-

nik 1. Moemy jednak taki rezultat zaakceptowa (równie metoda pow() z klasy Math
obliczy 00 w ten sam sposób).
System.out.println("Obliczanie potg o wykadniku naturalnym");
for(;;) {
System.out.print("Podstawa, a = ");
int n;
do {
System.out.print("Wykadnik (-1 - koniec)n = ");
} while (n < -1);
if (n == -1) break;
double pot = 1.0;
for(int i = 1; i <= n; ++i)
pot *= a;
System.out.printf("(%f)^%d = %f\n", a, n, pot);
}
input.close();
}
}


Rozdzia 7.
Rozwizania zada
17. Obsuga wyjtków
Jeli wczytujemy liczb, stosujc metod nextDouble() (lub inn podobn) z klasy
Scanner, i wprowadzony cig znaków nie jest poprawnym zapisem liczby, zostanie
zgoszony wyjtek InputMismatchException. Obsugujc ten wyjtek, moemy zigno-
rowa bd i powróci do wczytywania danych.
Wczytywanie danych umiecimy w ptli ze sprawdzaniem warunku na kocu. Zako-

czenie lub powtórzenie ptli zaley od wartoci zmiennej logicznej end.
boolean end;
do {
/* wczytywanie danych */
} while(end);
Instrukcj x = input.nextDouble(), która moe w przypadku wystpienia bdu zgo-

si wyjtek, umieszczamy w bloku try{ } razem z instrukcj podstawiania end = true.
Poprawne wczytanie wartoci zmiennej x spowoduje, e nastpnie zmienna end przyj-
mie warto true, a w konsekwencji opucimy ptl wczytywania danych. Po wpro-
wadzeniu bdnej danej (np. tekst dwa zamiast liczby 2) zostanie zgoszony wyjtek
InputMismatchException. Obsuga tego wyjtku to wywietlenie komunikatu, usunicie
ze strumienia input bdnego tokenu (input.next()) lub caej linii (input.nextLine())
i ustawienie wartoci zmiennej end = false. Ta ostatnia czynno spowoduje powrót
na pocztek ptli wczytywania danych.
import java.util.InputMismatchException;
System.out.println("Wczytywanie liczb");
double x = 0.0;
boolean end;
do {

try {
x = input.nextDouble();
end = true;
} catch(InputMismatchException e) {
System.out.println("To nie jest liczba!");
input.next();
end = false;
}
} while(!end);
input.close();
System.out.printf("Wprowadzona liczba, x = %f\n", x);
}
}
Moemy zrezygnowa ze zmiennej logicznej end, tworzc nieskoczon ptl, w któ-

rej zawrzemy wczytywanie danych i obsug wyjtku. Ptl przerwiemy instrukcj
break po poprawnym odczytaniu liczby ze strumienia.
while(true) {
try {
x = input.nextDouble();
break;
} catch(InputMismatchException e) {
input.next();
}
}

Wczytujemy acuch znaków ze strumienia String s = input.next(). To nie powo-
duje adnych problemów. Konwersji acucha s na liczb moemy dokona, stosujc
metod x = Double.parseDouble(s). Metoda ta zgosi wyjtek NumberFormatException,
jeli acuch znaków s nie jest poprawnym zapisem liczby. Pozostaa cz kodu jest
podobna jak w rozwizaniu zadania 17.1.
boolean end;
do {
try {
x = Double.parseDouble(s);
end = true;
} catch(NumberFormatException e) {
end = false;
}
} while(!end);
Moemy równie zastosowa drugi wariant — przerwanie ptli instrukcj break.

for(;;) {
try {

x = Double.parseDouble(s);
break;
}
}

Sposób I. Zmienna licznik suy do zliczania dodawanych liczb cakowitych. Jeli
wczytany token jest liczb cakowit, to ta liczba jest dodawana do sumy (zmienna
suma += n) i licznik zwikszany jest o 1 (++licznik). Gdy token nie jest liczb cako-
wit, to rzucany jest wyjtek NumberFormatException i po wywietleniu stosownego
komunikatu (w bloku catch) powracamy do ptli wczytujcej dane.
System.out.println("Obliczanie sumy piciu liczb cakowitych");
System.out.println("Podaj pi liczb cakowitych:");
int suma = 0, licznik = 0;
do {
String s = "";
try {
s = input.next();
int n = Integer.parseInt(s);
++licznik;
suma += n;
System.out.println("Liczba "+licznik+": "+n);
System.out.println("To nie jest liczba cakowita: "+s);
}
} while(licznik < 5);
input.close();
System.out.printf("Suma liczb S = %d\n", suma);
}
}
Sposób II. W tym rozwizaniu przed wczytaniem tokenu ze skanera sprawdzimy, czy
jest to liczba cakowita (metoda hasNextInt()). Jeli wynik testu bdzie pozytywny,
to wczytamy liczb, dodamy j do sumy i zwikszymy licznik. W przeciwnym wypad-
ku przeczytamy token i zignorujemy jego warto (moemy wywietli odpowiedni
komunikat).
System.out.println("Obliczanie sumy piciu liczb cakowitych");
System.out.println("Podaj pi liczb cakowitych:");
int suma = 0, licznik = 0;
do {
if (input.hasNextInt()) {

++licznik;
suma += n;
System.out.println("Liczba "+licznik+": "+n);
} else
System.out.println("To nie jest liczba cakowita: "+input.next());
} while(licznik < 5);
input.close();
System.out.printf("Suma liczb S = %d\n", suma);
}
}
Zadanie 17.4. Z17_4a.java, Z17_4b.java

a) Wczytujemy acuch znaków s ze strumienia wejciowego i konwertujemy
ten acuch na liczb cakowit. Jeli s nie reprezentuje liczby cakowitej,
to instrukcja n = Integer.parseInt(s) zwróci wyjtek NumberFormatException.
Przechwycimy ten wyjtek i wywietlimy komunikat "To nie jest liczba
cakowita: " z doczon zawartoci acucha s. Dzielenie zmiennoprzecinkowe
1.0/n lub 1/(double)n da w wyniku odwrotno liczby n. Dla n równego 0 nie
zostanie zgoszony wyjtek, ale otrzymamy wynik Infinity (nieskoczono).
W takiej sytuacji sami zgosimy wyjtek throw new ArithmeticException("Nie
istnieje odwrotno liczby 0."), a nastpnie go przechwycimy i obsuymy
catch(ArithmeticException e) {System.out.println(e.getMessage());}.
Zwrómy uwag na uycie metody getMessage() do pobrania tekstu komunikatu
przekazywanego przez wyjtek e.
System.out.println("Odwrotno liczby cakowitej");
try {
int n = Integer.parseInt(s);
if (n != 0)
System.out.println("1/n = "+1.0/n);
else
throw new ArithmeticException("Nie istnieje odwrotno
liczby 0.");
System.out.println("To nie jest liczba cakowita: "+s);
}
catch(ArithmeticException e) {
System.out.println(e.getMessage());
}
input.close();
}
}
b) Stosujc metod input.hasNextInt(), sprawdzamy, czy kolejny token jest

liczb cakowit. Jeli tak jest, to wczytujemy warto i przechowujemy
j w zmiennej n (int n = input.nextInt()). Gdy token nie jest liczb,
wczytujemy go jako tekst i wykorzystujemy do zbudowania odpowiedniego
komunikatu.

Dla liczby n rónej od zera wykonujemy obliczenie odwrotnoci, dla zera

wywietlamy odpowiedni komunikat.
System.out.println("Odwrotno liczby cakowitej");
if (input.hasNextInt()) {
if (n != 0)
System.out.println("1/n = "+1.0/n);
else
System.out.println("Nie istnieje odwrotno liczby 0.");
} else
System.out.println("To nie jest liczba cakowita: "+input.next());
input.close();
}
}
Przewidzielimy i ominlimy, stosujc instrukcje warunkowe, wszystkie

sytuacje, w których móg wystpi bd (bez uycia wyjtków).

Bd moe wystpi podczas konwertowania wczytywanych danych (acuchów zna-
ków) na liczby lub podczas dzielenia przez zero. Spowoduje to rzucenie wyjtku, któ-
ry nastpnie przechwytujemy i obsugujemy.
System.out.println("Dzielenie z reszt");
String sm = input.next();
String sn = input.next();
try {
int m = Integer.parseInt(sm);
int n = Integer.parseInt(sn);
System.out.printf("%d:%d = %d r. %d\n", m, n, m/n, m%n);
System.out.println("Bd podczas wprowadzania danych!");
}
catch(ArithmeticException e) {
}
input.close();
}
}
Próba dzielenia przez zero spowoduje wywietlenie komunikatu / by zero (warto

e.getMessage() dla ArithmeticException). Moemy w tym miejscu wstawi wasny
komunikat, np. "Dzielenie przez 0".

18. Liczby pseudolosowe i tablice

jednowymiarowe — budujemy
metody statyczne
Metoda random z klasy Math zwraca liczb pseudolosow z przedziau 0, 1 , po po-
mnoeniu przez 6 otrzymamy warto nalec do przedziau 0, 6 . Po rzutowaniu
liczby na typ cakowity (int) otrzymamy jedn z wartoci: 0, 1, 2, 3, 4, 5, a po dodaniu
liczby 1 uzyskamy wynik rzutu kostk do gry, czyli warto ze zbioru {1, 2, 3, 4, 5, 6}.
Warto wyraenia (wynik rzutu) 1+(int)(Math.random()*6) zwracana jest przez bez-

parametrow statyczn metod (funkcj) kostka().
static int kostka(){
return 1+(int)(Math.random()*6);
}
for(int i = 0; i < 100; ++i)
System.out.print(kostka()+" ");
}
}
Tak zdefiniowana statyczna metoda kostka() jest dostpna w pakiecie, w którym znaj-
duje si klasa Z18_1, i moe by wywoana poleceniem Z18_1.kostka().
Inn moliwo stwarza klasa java.util.Random. Najpierw tworzymy obiekt rnd, a na-
stpnie stosujemy metod rnd.nextInt(6) zwracajc liczb cakowit od 0 do 5 (nie-
osigajc wartoci 6). Po dodaniu liczby 1 otrzymamy wynik rzutu kostk.
/* Tworzymy obiekt rnd klasy Random. */
static Random rnd = new Random();
/* Tworzymy funkcj losujc rzut kostk. */
return 1+rnd.nextInt(6);
}

Losowanie rzutów kostk zostao szczegóowo opisane w rozwizaniu zadania 18.1.
Do przechowywania wyników utworzymy statyczn, siedmioelementow tablic liczb
cakowitych wynik. Element o indeksie 0 moemy zastosowa do przechowywania
liczby rzutów (zwikszanie licznika rzutów wynik[0] += 1) lub pozostawi go jako
niewykorzystany. Elementy o indeksach od 1 do 6 bd suyy do zliczania, ile razy
wypado 1 oczko, 2 oczka itd. Dziki takiemu podejciu wynik rzutu kostk bdzie
jednoczenie indeksem elementu tablicy przechowujcego liczb rzutów, w których
ten wynik wypad (zwikszanie licznika wyników: wynik[kostka()] += 1).


public static int kostka(){
}
private static int[] wynik = new int[7];
/* Losowanie */
for(int i = 0; i < 1000; ++i) {
wynik[0] += 1; // licznik rzutów
wynik[kostka()] += 1; // licznik wyników
}
/* Wynik */
System.out.println("Liczba rzutów: "+wynik[0]);
for(int i = 1; i <= 6; ++i)
System.out.printf("%d: %d\t - %.1f%%\n", i, wynik[i],
wynik[i]*100.0/wynik[0]);
}
}
Uzyskane wyniki przedstawiamy, podajc liczb wystpie kadego wyniku oraz udzia
procentowy (wynik[i]*100.0/wynik[0]). Zwrómy uwag na sposób obliczenia: wy-
nik[i] mnoymy przez 100.0 (co daje rezultat zmiennoprzecinkowy) i nastpnie dzie-
limy przez liczb rzutów (wynik[0]). Wykorzystanie w wyraeniu liczby cakowitej
100 daoby wynik cakowity (z pominiciem czci uamkowej procentu). Uycie w a-
cuchu formatujcym symbolu %% jest potrzebne, aby wywietli znak procentu (%).

Suma oczek w dwukrotnym rzucie kostk do gry przyjmuje wartoci od 2 do 12. De-
klarujc trzynastoelementow tablic liczb cakowitych wynik do zliczania wyników,
zastosujemy element wynik[0] do liczenia powtórze dowiadczenia i elementy wy-
nik[2], wynik[3], …, wynik[12] do liczenia wystpie wszystkich moliwych wartoci
sumy oczek w dwóch rzutach. Element wynik[1] pozostanie niewykorzystany. Sposób
liczenia wyników pozostaje taki sam jak w rozwizaniu zadania 18.2. Do dodawania
wyników dwóch rzutów budujemy metod statyczn suma, realizujc dodawanie dwóch
liczb cakowitych podanych jako parametry. Nie jest to konieczne, ale zwiksza czy-
telno kodu programu.
}
static int suma(int m, int n) {
return m+n;
}
private static int[] wynik = new int[13];
System.out.println("Suma oczek w dwukrotnym rzucie kostk");
/* Losowanie */
for(int i = 0; i < 3000; ++i) {
wynik[0] += 1; // licznik losowa
wynik[suma(kostka(), kostka())] += 1; // licznik wyników
}
/* Wynik */
System.out.println("Liczba rzutów: "+wynik[0]);

for(int i = 2; i < 13; ++i)

System.out.printf("Suma %2d: %4d\t - %4.1f%%\n", i, wynik[i],
wynik[i]*100.0/wynik[0]);
}
}

W przedziale a, b znajduje si n 10b a 1 liczb rónicych si o 0,1 (a; a+0,1;
a+0,2, b). Losujemy liczb cakowit z zakresu od 0 do n–1, dzielimy t liczb przez
10 i dodajemy do liczby a — wynik znajdzie si w przedziale a, b .
static double rand(int a, int b) {
int n = (b-a)*10+1;
return a+((int)(Math.random()*n))/10.0;
}
System.out.println("Losowanie liczby z przedziau <a, b>\n");
for(int i = 0; i < 50; ++i)
System.out.printf("%4.1f ", rand(5, 7));
}
}

Przedzia 0, 5 podzielimy na pi rozcznych przedziaów 0, 1 , 1, 2 , 2, 3 , 3, 4
i 4, 5 — kady o dugoci 1. Losowanie liczb przeprowadzimy, korzystajc z obiektu
rnd klasy Random (Random rnd = new Random()). Metoda nextDouble() zwraca pseudo-
losow warto typu double nalec do przedziau 0, 1 , któr nastpnie mnoymy
przez 5 (x = 5*rnd.nextDouble()) i otrzymujemy liczb x z przedziau 0, 5 . Wylo-
sowanych liczb nie zapamitujemy. Na bieco, stosujc cig zagniedonych instruk-
cji if-else, zliczamy w tablicy n (zadeklarowanej w klasie jako prywatna i statyczna
tablica zawierajca pi liczb cakowitych), w którym przedziale mieci si wyloso-
wana liczba.
W zestawieniu wyników podajemy, ile razy zostaa wylosowana liczba naleca do

kolejnego przedziau (n[i] dla i = 0, 1, 2, 3 i 4) oraz jaki procent wszystkich losowa-
nych liczb zmieci si w tym przedziale (n[i]*100.0/500).
private static int[] n = new int[5];
System.out.println("Losowanie liczby z przedziau <0, 5)\n");
double x;
Random rnd = new Random();
for(int i = 0; i < 500; ++i) {
x = 5*rnd.nextDouble();
if (x < 1) n[0] +=1;
else if (x < 2) n[1] +=1;
else if (x < 3) n[2] +=1;
else if (x < 4) n[3] +=1;
else n[4] +=1;

}
for(int i = 0; i < 5; ++i)
System.out.printf("<%d, %d): %4d - %4.1f%%\n", i, i+1, n[i],
n[i]*100.0/500);
}
}
Zauwaajc w tym konkretnym przypadku zaleno pomidzy czci cakowit wy-

losowanej liczby ((int)x) i numerem (indeksem) przedziau, do którego liczba x nale-
y, moemy zrezygnowa z instrukcji warunkowej i uproci proces zliczania:
for(int i = 0; i < 500; ++i) {
x = 5*Math.random();
n[(int)x] += 1;
}

Do przechowywania wyników losowania uyjemy szecioelementowej tablicy (tmp)
liczb cakowitych typu byte (zakres — 128..127). Zmienna j jest indeksem elemen-
tów tablicy tmp i wskazuje jednoczenie, ile elementów zostao ju wylosowanych (war-
toci elementów nie mog si powtarza).
Po wylosowaniu i wpisaniu do tablicy tmp pierwszego elementu (liczba cakowita z za-

kresu 1..49, rzutowana na typ byte) zmienna j przyjmuje warto 1 (efekt postinkre-
mentacji j++) — indeks nastpnego wolnego miejsca w tablicy tmp.
byte j = 0;
tmp[j++] = (byte)(1+49*Math.random());
Dalsze losowanie przebiega w ptli do {...} while (j<6);, która zakoczy si po
wylosowaniu wszystkich szeciu (rónych) wartoci. Po wylosowaniu kolejnej warto-
ci (n) ustawiamy zmienn logiczn jest na warto false (zakadamy, e liczba si
nie powtarza) i porównujemy warto wylosowan n z dotychczasow zawartoci
tablicy tmp.
for(byte i = 0; i < j; ++i)
if (n == tmp[i]) jest = true;
Jeli liczba jest w tablicy, to zmienna jest przyjmie warto true i losowanie trzeba
bdzie powtórzy. Natomiast gdy liczba n nie wystpi w tablicy tmp, to wstawimy do
tablicy t warto i zwikszymy j o 1.
if (!jest)
tmp[j++] = n;
Dopóki j < 6, powtarzamy losowanie kolejnego elementu tablicy.
Po wylosowaniu wszystkich szeciu liczb posortujemy wyniki. W tym celu uyjemy

statycznej metody Arrays.sort(wynik), pochodzcej z klasy java.util.Arrays. Na
koniec wywietlamy wyniki losowania (zastosowano ptl typu for each).

static byte[] lotto() {

byte[] tmp = new byte[6];
byte j = 0;
tmp[j++] = (byte)(1+49*Math.random());
do {
byte n = (byte)(1+49*Math.random());
boolean jest = false;
if (n == tmp[i]) jest = true;
if (!jest)
tmp[j++] = n;
} while (j < 6);
return tmp;
}
byte[] wynik = lotto();
Arrays.sort(wynik);
for(byte x: wynik)
System.out.print(x+" ");
}
}

Metoda lotto() zostaa szczegóowo omówiona w rozwizaniu zadania 18.6. W tym
przykadzie wprowadzamy parametr m zamiast staej wartoci 6 i parametr n zamiast
liczby 49. Gdy uytkownik poda n < m (danie wylosowania m rónych wartoci ze
zbioru zawierajcego mniej ni m elementów), zostanie zgoszony wyjtek.
static byte[] lotto(byte m, byte n) {
if (n < m)
throw new IllegalArgumentException("Liczba elementów wiksza
od liczby dopuszczalnych wartoci!");
byte[] tmp = new byte[m];
byte j = 0;
tmp[j++] = (byte)(1+n*Math.random());
do {
byte w = (byte)(1+n*Math.random());
if (w == tmp[i])
jest = true;
if (!jest)
tmp[j++] = w;
} while (j < m);
return tmp;
}
byte[] wynik = lotto((byte)5, (byte)49);
Arrays.sort(wynik);
for(byte x: wynik)
System.out.print(x+" ");
}
}

Zamiast wypisywa wyniki w ptli, moemy, stosujc statyczn metod toString()

z klasy Array, zamieni tablic wartoci na acuch znaków (elementy tablicy oddzie-
lone przecinkami, zawarte w nawiasie prostoktnym).
System.out.println(Arrays.toString(wynik));

Utworzone metody zapiszemy w dwóch plikach: Z18_8.java (rozwizanie tego zadania)
i MyRandomArray.java — klasa, w której zgromadzimy metody opracowane w tym
i kilku kolejnych zadaniach.
/* Tu wpisujemy kody metod. */
}
Wszystkie te metody zadeklarujemy jako publiczne i statyczne.

a) Metoda int[] rndArray(int n, int m) zwraca tablic zawierajc n liczb
cakowitych wylosowanych z zakresu od 0 do m-1.
Do losowania utworzymy obiekt rnd klasy Random (Random rnd = new
Random()). Wyniki losowania przechowamy w n-elementowej tablicy liczb
cakowitych tmp (int[] tmp = new int[n]). Stosujc metod nextInt()
z klasy Random, w ptli for losujemy i podstawiamy do tablicy pseudolosowe
wartoci z zakresu od 1 do m-1 (tmp[i] = rnd.nextInt(m)). Na koniec
zwracamy referencj do tablicy tmp (return tmp).
public static int[] rndArray(int n, int m) {
int[] tmp = new int[n];
for(int i = 0; i < n; ++i)
tmp[i] = rnd.nextInt(m);
return tmp;
}
Losowanie liczb pseudolosowych moemy równie zrealizowa, uywajc

statycznej metody random() z klasy Math, bez stosowania obiektu rnd:
(int)(m*Math.random()). Math.random() zwraca liczb typu double z przedziau
0, 1 ; po pomnoeniu jej przez m otrzymamy liczb nalec do przedziau
0, m . Rzutujc wynik na typ cakowity int, otrzymamy jedn z wartoci:
0, 1, 2, … m–1.
b) Metoda void arrayPrint(int[] tab) wywietla w konsoli elementy tablicy
tab oddzielone pojedynczym odstpem. Wedug wasnych upodoba mona
zmieni znak separujcy wartoci.
public static void arrayPrint(int[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
System.out.print(tab[i]+" ");
}

Zwrómy uwag na sposób wyznaczania rozmiaru tablicy. Obiekt tab posiada

pole length zawierajce liczb elementów tablicy.
c) Metoda void arrayPrintln(int[] tab) wywietla w konsoli elementy tablicy
tab oddzielone pojedynczym odstpem i przenosi kursor na pocztek nowego
wiersza.
public static void arrayPrintln(int[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
}
d) Metoda void addToArray(int[] tab, int d) do kadego elementu tablicy

(podanej jako pierwszy parametr) dodaje liczb cakowit (drugi parametr).
public static void addToArray(int[] tab, int d) {
int n = tab.length;
for(int i = 0; i < n; ++i)
tab[i] += d;
}
Dziaanie tych metod mona zobaczy w nastpujcym programie:

/* Tu wpisujemy kody metod: rndArray(), arrayPrintln() i addToArray(). */
/* 10 liczb z zakresu od 0 do 99 (< 100) */
arrayPrintln(rndArray(10, 100));
/* 15 liczb z zakresu od 0 do 999 (< 1000) */
int[] t = rndArray(15, 1000);
arrayPrintln(t);
/* 15 liczb z zakresu od 1000 do 1999 */
addToArray(t, 1000);
arrayPrintln(t);
}
}

Metoda int[] rndUniqueArray(int n, int m) zwraca tablic zawierajc n rónych
liczb cakowitych wylosowanych z zakresu od 0 do m-1. Algorytm losowania rónych
liczb zosta szczegóowo omówiony w rozwizaniu zadania 18.6.
public static int[] rndUniqueArray(int n, int m) {
if (m < n)
int j = 0;
tmp[j++] = rnd.nextInt(m);
do {
int k = rnd.nextInt(m);

for(int i = 0; i < j; ++i)

if (k == tmp[i]) jest = true;
if (!jest)
tmp[j++] = k;
} while (j < n);
return tmp;
}
Metod t moemy doczy do klasy MyRandomArray i wstawi do kodu ródowego

programu pokazujcego dziaanie metody. W biecym folderze powinien by skom-
pilowany plik MyRandomArray.class lub kod ródowy tej klasy (korzystamy z meto-
dy arrayPrintln()).
/* Kod metody rndUniqueArray */
/* 10 liczb z zakresu od 0 do 99 bez powtarzania */
MyRandomArray.arrayPrintln(rndUniqueArray(10, 100));
}
}

1. Metoda int[] rndSortArray(int n, int m) zwraca posortowan (w porzdku
niemalejcym) tablic zawierajc n liczb cakowitych wylosowanych z zakresu
od 0 do m-1.
public static int[] rndSortArray(int n, int m) {
for(int i = 0; i < n; ++i)
Arrays.sort(tmp);
return tmp;
}
Metoda ta dziaa tak samo jak metoda int[] rndArray(int n, int m)

omówiona w rozwizaniu zadania 18.8. Jedynym uzupenieniem jest
sortowanie tablicy tmp po zakoczeniu losowania (Arrays.sort(tmp)).
Do sortowania wykorzystujemy statyczn metod sort() z klasy Arrays.
2. Metoda int[] rndSortUniqueArray(int n, int m) zwraca posortowan
(w porzdku rosncym) tablic zawierajc n rónych liczb cakowitych
wylosowanych z zakresu od 0 do m-1. Aby zadanie byo moliwe do
wykonania, liczba elementów n nie moe by wiksza od liczby m,
ograniczajcej z góry zbiór wylosowanych wartoci cakowitych.
Kod metody jest kopi kodu metody rndUniqueArray() (przedstawionej
w rozwizaniu zadania 18.9), uzupenion o sortowanie tablicy po zakoczeniu
losowania (Arrays.sort(tmp)).
Metod doczamy do klasy MyRandomArray i wstawiamy do kodu ródowego
przykadu.

import java.util.*;
/* Kod metody rndSortArray */
/* Kod metody rndSortUniqueArray */
/* 20 posortowanych liczb z zakresu od 0 do 9 */
MyRandomArray.arrayPrintln(rndSortArray(20, 10));
/* 10 posortowanych liczb z zakresu od 0 do 99 bez powtarzania */
MyRandomArray.arrayPrintln(rndSortUniqueArray(10, 100));
}
}
Zwrómy uwag na pierwszy wiersz przykadu import java.util.*;, który powoduje

importowanie wszystkich klas z pakietu java.util (w tym klas Arrays i Random — nie-
zbdnych do poprawnego dziaania tej aplikacji).

Na podstawie rozwizania zadania 18.8 tworzymy nastpujce metody:
1. Metoda double[] rndArray(int n, double a) zwraca n-elementow tablic
liczb zmiennoprzecinkowych typu double, wypenion pseudolosowymi
wartociami z przedziau 0, a . Do losowania wykorzystujemy obiekt rnd
klasy Random i metod nextDouble() zwracajc zmiennoprzecinkow liczb
typu double z przedziau 0, 1 .
public static double[] rndArray(int n, double a) {
double[] tmp = new double[n];
for(int i = 0; i < n; ++i)
tmp[i] = a*rnd.nextDouble();
return tmp;
}
Generowanie liczb pseudolosowych mona równie zrealizowa, stosujc

statyczn metod random() z klasy Math:
for(int i = 0; i < n; ++i)
tmp[i] = a*Math.random();
2. Wywietlanie elementów tablicy moemy zrealizowa przy uyciu jednej

z dwóch metod, analogicznych do metod opracowanych w rozwizaniu
zadania 18.8.
public static void arrayPrint(double[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
}
public static void arrayPrintln(double[] tab) {

int n = tab.length;
for(int i = 0; i < n; ++i)
}

3. Metoda void arrayPrintf(String spec, double[] tab) wywietla

sformatowane elementy tablicy. Formatowanie okrelone jest z wykorzystaniem
parametru spec, w sposób przyjty dla metody printf z klasy System.
public static void arrayPrintf(String spec, double[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
System.out.printf(spec, tab[i]);
}
4. Metoda void addToArray(double[] tab, double d) dodaje do wszystkich

elementów tablicy (podanej jako pierwszy parametr) liczb typu double
(drugi parametr).
public static void addToArray(double[] tab, double d) {
int n = tab.length;
for(int i = 0; i < n; ++i)
tab[i] += d;
}
Kody metod doczamy do klasy MyRandomArray i wstawiamy do kodu

ródowego programu pokazujcego ich dziaanie. Metody te maj nazwy
identyczne z nazwami metod znajdujcych si ju w klasie MyRandomArray,
ale róni si od nich typem parametrów (wystpuje tu tzw. przecianie metod).
Dziaanie metod moemy przedstawi w programie:
/* Kod metod */
/* 10 liczb z przedziau <0, 5.5) */
arrayPrintln(rndArray(10, 5.5));
/* 5 liczb z przedziau <0, 12.5) */
double[] t = rndArray(5, 12.5);
arrayPrintln(t);
/* 5 liczb z przedziau <2.5, 15.0)*/
addToArray(t, 2.5);
arrayPrintf("%6.1f", t);
}
}

Stosujc algorytm opisany w rozwizaniu zadania 18.6 (losowanie niepowtarzajcych
si elementów tablicy) i wzorujc si na rozwizaniu zadania 18.9, budujemy kod me-
tody rndUniqueArray() zwracajcej n-elementow tablic rónych liczb typu double
z przedziau 0, a .
public static double[] rndUniqueArray(int n, double a) {
int j = 0;
tmp[j++] = a*rnd.nextDouble();

do {
double x = a*rnd.nextDouble();
for(int i = 0; i < j; ++i)
if (x == tmp[i]) jest = true;
if (!jest)
tmp[j++] = x;
} while (j < n);
return tmp;
}
Dodajemy metod do klasy MyRandomArray i do kodu przykadu:

/* Kod metody rndUniqueArray */
/* 10 liczb z przedziau <0, 7.5) bez powtarzania wartoci */
MyRandomArray.arrayPrintln(rndUniqueArray(10, 7.5));
}
}

Kody metod double[] rndSortArray(int n, double a) i double[] rndSortUniqueAr-
ray(int n, double a) uzyskamy, kopiujc kody metod double[] rndArray(int n,
double a) i double[] rndUniqueArray(int n, double a) (zob. rozwizania zada 18.11
i 18.12) i wstawiajc sortowanie tablicy tmp po losowaniu liczb (Arrays.sort(tmp)).
Obie metody doczmy do klasy MyRandomArray.
public static double[] rndSortArray(int n, double a) {
for(int i = 0; i < n; ++i)
Arrays.sort(tmp);
return tmp;
}
public static double[] rndSortUniqueArray(int n, double a) {
int j = 0;
do {
for(int i = 0; i < j; ++i)
if (!jest)
tmp[j++] = x;
} while (j < n);
Arrays.sort(tmp);
return tmp;

}
/* 20 posortowanych liczb z przedziau <0, 2.5) */
MyRandomArray.arrayPrintln(rndSortArray(20, 2.5));
/* 10 posortowanych liczb z przedziau <0, 10) bez powtarzania */
MyRandomArray.arrayPrintf("%10.3f", rndSortUniqueArray(10, 10.0));
}
}

Przedstawmy algorytm zaokrglania uamków dziesitnych na przykadzie dwóch uam-
ków i zamienionych na uamki dziesitne. Zaokrglenia dokonamy do 3 miejsc
po przecinku.
Uamek zwyky
Uamek dziesitny (x) 0,333333333333… 0,666666666666…
Liczba miejsc po przecinku (prec) 3 3
Wspóczynnik (wsp) 103 = 1000 103 = 1000
Wyraenie: x*wsp 333,333333333… 666,666666666…
Wyraenie: x*wsp+0.5 333,833333333… 667,166666666…
Wyraenie: (int)(x*wsp+0.5) 333 667
Wyraenie: (int)(x*wsp+0.5)/wsp 0,333 0,667
Otrzymany wynik jest zgodny z reguami zaokrgle uamków dziesitnych. Przed-

stawione obliczenia wykonamy w ptli dla wszystkich elementów tablicy.
public static void roundArray(double[] tab, int prec) {
int n = tab.length;
double wsp = Math.pow(10.0, prec);
for(int i = 0; i < n; ++i)
tab[i] = (int)(tab[i]*wsp+0.5)/wsp;
}

/* 20 posortowanych liczb z przedziau <0, 2.5) */
double[] t = MyRandomArray.rndSortArray(20, 2.5);
roundArray(t, 2);
MyRandomArray.arrayPrintln(t);
}
}
Moemy zbudowa statyczn metod round(), zaokrglajc liczb zmiennoprzecin-

kow z okrelon precyzj dla liczb typu double:
public static double round(double x, int prec) {
return(int)(x*wsp+0.5)/wsp;
}
lub dla liczb typu float:

public static float round(float x, int prec) {

float wsp = (float) Math.pow(10.0, prec);
return (int)(x*wsp+0.5)/wsp;
}
Metody dodajemy do klasy MyRandomArray.

Losowane liczby maj precyzj odpowiadajc precyzji liczb typu double. Metoda
double[] rndArray(int n, double a, int prec) zwraca n-elementow tablic liczb
zmiennoprzecinkowych, zaokrglonych do okrelonej parametrem prec iloci miejsc
po przecinku.
public static double[] rndArray(int n, double a, int prec) {
for(int i = 0; i < n; ++i)
tmp[i] = (int)(a*rnd.nextDouble()*wsp+0.5)/wsp;
return tmp;
}
Jeli zdefiniowalimy w klasie MyRandomArray metod round(), to moemy teraz z niej

skorzysta:
for(int i = 0; i < n; ++i)
tmp[i] = MyRandomArray.round(a*rnd.nextDouble(), prec);
return tmp;
}
Inn moliwo stwarza zdefiniowanie metody losujcej liczb z danego zakresu i za-
okrglon z okrelon precyzj, np.:
public static double random(double a, int prec) {
return MyRandomArray.round(a*Math.random(), prec);
}
i wykorzystanie tej metody do tworzenia tablicy:

for(int i = 0; i < n; ++i)
tmp[i] = MyRandomArray.random(a, prec);
return tmp;
}
Dziaanie metody pokazuje przykad:

/* Kod metody rndArray(int n, double a, int prec) */
/* 10 liczb z przedziau <0, 5.5) z precyzj do 2 miejsc po przecinku */

MyRandomArray.arrayPrintln(rndArray(10, 5.5, 2));

/* 5 liczb z przedziau <0, 12.5) z precyzj do 3 miejsc po przecinku */
double[] t = rndArray(5, 12.5, 3);
}
}

Metoda rndArray() wywoana z parametrami 5, 1.7, 0.2 powinna zwróci picio-
elementow tablic liczb nalecych do przedziau 0; 1,7 , rónicych si o wielo-
krotno liczby 0,2, czyli nalecych do zbioru {0,0; 0,2; 0,4; 0,6; 0,8; 1,0; 1,2; 1,4; 1,6} .
Poniewa w zapisie binarnym liczba 0,2 jest uamkiem nieskoczonym okresowym,
to w wyniku dodawania lub mnoenia przez liczb cakowit na dalszych miejscach
po przecinku pojawi si cyfry róne od 0. Aby t niedogodno wyeliminowa, za-
stosujemy zaokrglenie wyniku do okrelonej liczby miejsc po przecinku.
Najpierw obliczymy ilo liczb speniajcych warunek zadania int k = (int)(a/step)+1

(rozmieszczonych w przedziale 0, a , zaczynajc od 0, z krokiem okrelonym para-
metrem step). Precyzj zaokrglenia (liczb miejsc po przecinku) oszacujemy na pod-
stawie wzoru 1+(int)Math.log10(1/step). Warto elementu tablicy wyznaczymy,
mnoc krok (step) przez wylosowan liczb cakowit z zakresu od 0 do k-1.
public static double[] rndArray(int n, double a, double step) {
int k = (int)(a/step)+1;
double wsp = Math.pow(10.0, 1+(int)Math.log10(1/step));
for(int i = 0; i < n; ++i)
tmp[i] = (int)(step*rnd.nextInt(k)*wsp+0.5)/wsp;
return tmp;
}
/* 20 liczb z przedziau <0, 5.5) z krokiem 0.2 */
MyRandomArray.arrayPrintln(rndArray(20, 5.5, 0.2));
/* 50 liczb z przedziau <0, 12.5) z krokiem 0.05 */
double[] t = rndArray(50, 12.5, 0.05);
}
}
Metod double[] rndArray(int n, double a, double step) doczamy do klasy My

RandomArray.

Najpierw wyznaczymy rozmiar tablicy przekazanej do metody inputArray() (para-
metr int[] tab lub double[] tab). W tym celu wykorzystamy pole length obiektu

tab (int n = tab.length). Wczytywanie danych, przy uyciu obiektu input klasy
Scanner, zorganizujemy w ptli for. W ten sposób moemy zbudowa metody wczy-
tywania danych do tablic z elementami dowolnego typu.
public static void inputArray(int[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i) {
System.out.printf("Liczba %d z %d, n = ", i+1, n);
tab[i] = input.nextInt();
}
}
public static void inputArray(double[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i) {
System.out.printf("Liczba %d z %d, x = ", i+1, n);
tab[i] = input.nextDouble();
}
}

int[] a = new int[5];
inputArray(a);
MyRandomArray.arrayPrintln(a);
double[] b = new double[3];
inputArray(b);
MyRandomArray.arrayPrintln(b);
}
}
Zdefiniowane metody umiecimy w klasie MyArray.

Majc tablic tab zawierajc dane jednego typu, tworzymy tablic tmp o takiej samej
liczbie elementów (int n = tab.length). Stosujc rzutowanie danych liczbowych z jed-
nego typu na drugi typ, przepisujemy w ptli zawarto tablicy tab do tablicy tmp.
public static double[] intArrayToDouble(int[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
tmp[i] = (double)tab[i];
return tmp;
}
public static int[] doubleArrayToInt(double[] tab) {

int n = tab.length;
for(int i = 0; i < n; ++i)
tmp[i] = (int)tab[i];
return tmp;


double[] t = MyRandomArray.rndArray(10, 6, 3);
MyArray.arrayPrintln(t);
int[] u = doubleArrayToInt(t);
MyArray.arrayPrintln(u);
t = intArrayToDouble(u);
MyArray.arrayPrintln(t);
}
}
Zdefiniowane metody umiecimy w klasie MyArray. W ten sposób moemy utworzy

inne metody konwertujce tablice.
19. Dokumentacja klasy

Zadanie 19.1.
Do tworzenia dokumentacji klas uywamy aplikacji javadoc.exe dostpnej w JDK.
W plikach ródowych musimy umieci specjalne komentarze dokumentacyjne za-
czynajce si od znaku /** i zakoczone znakiem */.
Aplikacj uruchamiamy z opcjonalnymi parametrami:

javadoc [options] [packagenames] [sourcefiles] [@files]
Informacje o dziaaniu aplikacji uzyskamy, wpisujc polecenie javadoc –help. Rów-

nie po uruchomieniu aplikacji bez parametrów otrzymamy informacj o jednym b-
dzie, a w konsoli pojawi si poniszy tekst (tumaczenie tekstu pozostawiamy Czytel-
nikowi) zawierajcy dostpne opcje aplikacji:
-overview <file> — Read overview documentation from HTML file,
-public — Show only public classes and members,
-protected — Show protected/public classes and members (default),
-package — Show package/protected/public classes and members,
-private — Show all classes and members,
-help — Display command line options and exit,
-doclet <class> — Generate output via alternate doclet,
-docletpath <path> — Specify where to find doclet class files,
-sourcepath <pathlist> — Specify where to find source files,
-classpath <pathlist> — Specify where to find user class files,
-exclude <pkglist> — Specify a list of packages to exclude,

-subpackages <subpkglist> — Specify subpackages to recursively load,

-breakiterator — Compute 1st sentence with BreakIterator,
-bootclasspath <pathlist> — Override location of class files loaded by the
bootstrap class loader,
-source <release> — Provide source compatibility with specified release,
-extdirs <dirlist> — Override location of installed extensions,
-verbose — Output messages about what Javadoc is doing,
-locale <name> — Locale to be used, e.g. en_US or en_US_WIN,
-encoding <name> — Source file encoding name,
-quiet — Do not display status messages,
-J<flag> — pass <flag> Directly to the runtime system.
Opcje dostpne pod warunkiem stosowania standardowego docletu:

-d <directory> — Destination directory for output files,
-use — Create class and package usage pages,
-version — Include @version paragraphs,
-author — Include @author paragraphs,
-docfilessubdirs — Recursively copy doc-file subdirectories,
-splitindex — Split index into one file per letter,
-windowtitle <text> — Browser window title for the documentation,
-doctitle <html-code> — Include title for the overview page,
-header <html-code> — Include header text for each page,
-footer <html-code> — Include footer text for each page,
-top <html-code> — Include top text for each page,
-bottom <html-code> — Include bottom text for each page,
-link <url> — Create links to javadoc output at <url>,
-linkoffline <url> <url2> — Link to docs at <url> using package list
at <url2>,
-excludedocfilessubdir <name1>:... — Exclude any doc-files subdirectories
with given name,
-group <name> <p1>:<p2>:... — Group specified packages together in
overview page,
-nocomment — Supress description and tags, generate only declarations,
-nodeprecated — Do not include @deprecated information,

-noqualifier <name1>:<name2>:... — Exclude the list of qualifiers from

the output,
-nosince — Do not include @since information,
-notimestamp — Do not include hidden time stamp,
-nodeprecatedlist — Do not generate deprecated list,
-notree — Do not generate class hierarchy,
-noindex — Do not generate index,
-nohelp — Do not generate help link,
-nonavbar — Do not generate navigation bar,
-serialwarn — Generate warning about @serial tag,
-tag <name>:<locations>:<header> — Specify single argument custom tags,
-taglet — The fully qualified name of Taglet to register,
-tagletpath — The path to Taglets,
-charset <charset> — Charset for cross-platform viewing of generated
documentation,
-helpfile <file> — Include file that help link links to,
-linksource — Generate source in HTML,
-sourcetab <tab length> — Specify the number of spaces each tab takes up
in the source,
-keywords — Include HTML meta tags with package, class and member info,
-stylesheetfile <path> — File to change style of the generated
documentation,
-docencoding <name> — Output encoding name.

Postpujc zgodnie z treci zadania i zaczon uwag, uruchomimy w konsoli po-
lecenie:
javadoc –d Z19_2 Z19_2.java
i zobaczymy raport z przebiegu tworzenia dokumentacji:

Loading source file Z19_2.java...
Constructing Javadoc information...
Standard Doclet version 1.6.0_27
Building tree for all the packages and classes...

Generating Z19_2\Z19_2.html...
Generating Z19_2\package-frame.html...
Generating Z19_2\package-summary.html...
Generating Z19_2\package-tree.html...

Generating Z19_2\constant-values.html...
Building index for all the packages and classes...

Generating Z19_2\overview-tree.html...
Generating Z19_2\index-all.html...
Generating Z19_2\deprecated-list.html...
Building index for all classes...

Generating Z19_2\allclasses-frame.html...
Generating Z19_2\allclasses-noframe.html...
Generating Z19_2\index.html...
Generating Z19_2\help-doc.html...
Generating Z19_2\stylesheet.css...
W folderze Z19_2 utworzono 12 plików HTML, kaskadowy arkusz stylów stylesheet.

css, plik package-list (w tym przypadku pusty) oraz folder resources zawierajcy obraz
inherit.gif ( ). Dla nas najwaniejszy bdzie plik index.html (gówny plik dokumenta-
cji) oraz plik Z19_2.html zawierajcy opis klasy Z19_2.
Kod ródowy nie zawiera adnych komentarzy, zatem w pliku Z19_2.html nie znaj-
dziemy zbyt wielu informacji. Moemy jednak dowiedzie si, e:
Klasa Z19_2 dziedziczy po klasie java.lang.Object.
Kompilator utworzy domylny konstruktor Z19_2(), co pozwala tworzy
obiekty naszej klasy, np. Z19_2 x = new Z19_2().
Klasa posiada publiczn i statyczn metod main (nagówek: public static
void main(java.lang.String[] args)), czyli jest aplikacj uruchamian
poleceniem java Z19_2 w konsoli (po uprzednim skompilowaniu pliku
ródowego na plik Z19_2.class).
Nie znajdziemy natomiast w dokumentacji informacji o:

private static final String HELLO = "Hello World!"; — prywatnej
statycznej staej HELLO (a waciwie zmiennej, której wartoci nie mona
zmieni — to gwarantuje uyte sowo kluczowe final), zawierajcej acuch
znaków Hello World!
static String hello() { return HELLO; } — statycznej metodzie (widocznej
w pakiecie domylnym, czyli dla wszystkich klas, których kody znajduj si
w tym samym folderze) hello().
a) Dokumentacj tworzymy poleceniem javadoc –d Z19_2a -nohelp Z19_2.java.
Nie zosta utworzony plik help-doc.html (opis zasad tworzenia dokumentacji)
i nie ma linków do tego pliku.
b) Dokumentacj tworzymy poleceniem javadoc –d Z19_2b -notree Z19_2.java.
Dokumentacja nie zawiera plików package-tree.html i overview-tree.html
(nie ma hierarchii klas przedstawionej w postaci drzewa).
c) Dokumentacj tworzymy poleceniem javadoc –d Z19_2c -noindex Z19_2.java.
Tym razem nie utworzono pliku index-all.html zawierajcego alfabetyczny
wykaz metod.

d) Dokumentacj tworzymy poleceniem javadoc –d Z19_2d -nodeprecatedlist

Z19_2.java. Pomijamy w ten sposób plik deprecated-list.html zawierajcy
list zdeprecjonowanych elementów jzyka (niezalecanych ze wzgldu na
obnion jako i moliwych do zastpienia nowszymi elementami).
e) Dokumentacj tworzymy poleceniem javadoc –d Z19_2e –nodeprecatedlist
-noindex -notree -nohelp –private Z19_2.java, eliminujc elementy
omówione w punktach a), b), c) i d) oraz wczajc do dokumentacji
wszystkie elementy klas (równie prywatne). Tym razem w dokumentacji
pojawia si informacja o prywatnych elementach widocznych w klasie
i pakiecie (domylnym):
private static final java.lang.String HELLO — prywatna (w zakresie
klasy), staa warto pola (ang. Constant Field Values), zawierajca
acuch "Hello World!".
(package private) static java.lang.String hello() — prywatna
(w zakresie pakietu), statyczna metoda hello(), zwracajca acuch znaków.
W przedstawiony sposób Czytelnik moe samodzielnie przetestowa dziaanie innych opcji.
Czytelnik moe zobaczy taki komunikat:

javadoc: error - Illegal package name: "–d"
Loading source file Z19_2.java...
Loading source files for package Z19_2...
javadoc: warning - No source files for package Z19_2
1 error
1 warning
Dzieje si tak, jeli w ciece do programu javadoc jest spacja (a prawdopodobnie
bdzie, bo standardowo rodowisko Javy jest zainstalowane w Program Files).
Podanie penej cieki dostpu do javadoc (w cudzysowie) rozwie ten problem.

Komentarz dokumentacyjny zaczyna si od symbolu /** i jest zakoczony symbolem
*/. Znaki * rozpoczynajce kady wiersz maj wycznie charakter ozdobników i nie
wchodz w skad tekstu dokumentacji. S ignorowane podczas tworzenia dokumenta-
cji. Równie amanie wierszy w edytorze tekstu jest ignorowane.
Pierwszy komentarz zawiera ogólne informacje o klasie Z19_3. Zwrómy uwag na

uyte w komentarzu znaczniki jzyka HTML:
<code></code> — fragmenty kodu prezentowane w dokumentacji,
nazwy metod, zmiennych itp.,
<b></b> — wyrónienie tekstu pismem pogrubionym (bold),
<i></i> — wyrónienie tekstu pismem pochylonym (italic),
<p></p> — akapit (paragraph),
<a href="..."></a> — link do innego dokumentu.

/** Klasa <code>Z19_3</code> stanowi prosty przykad aplikacji

* konsolowej. Pocztki programowania w wielu jzykach zawieraj ten
* klasyczny przykad - wywietlanie w konsoli napisu <b>Hello
* World!</b>, czyli <i>Witaj, wiecie!</i>.
* <p>To radosny okrzyk, wydawany przez kadego pocztkujcego
* programist po napisaniu pierwszego prostego programu w poznawanym
* jzyku.</p>
* <p>Zobacz przykady takich programów:
* <a href="http://en.wikipedia.org/wiki/Hello_world_program_examples"
* target="_blank"> Hello world program examples.</a></p>
*/
Drugi komentarz odnosi si do staej HELLO. Do amania wierszy uyto znacznika <br>,
wcicie w kodzie uzyskano, stosujc znak spacji nierozdzielajcej . Ten komen-
tarz pojawi si w dokumentacji, gdy podczas jej tworzenia uyjemy opcji –private.
/** Identyfikator staej (zmiennej, której wartoci nie moemy zmieni ),
* zawierajcej acuch znaków <code>Hello World!"</code>. Zwyczajowo
* takie identyfikatory zapisujemy wielkimi literami. Prywatna staa
* <code>HELLO</code> jest dostpna wycznie wewntrz klasy
* <code>Z19_3</code>. Zastosowanie staej przedstawimy w dwóch
* przykadach:
* <p><b>Przykad 1.</b>
* <code><br>static String hello() {<br>
* return HELLO;<br>}</code></p>
* <p><b>Przykad 2.</b>
* <code><br>System.out.println("Jeszcze raz: "+HELLO");</code></p>
*/
private static final String HELLO = "Hello World!";
Kolejny komentarz przedstawia metod hello():

/** Metoda zwraca acuch znaków - jest to napis zawarty w staej
* <code>HELLO</code>. Metoda jest widoczna w pakiecie. Metody z innych
* klas pakietu mog t metod wywoa : <code>Z19_3.hello();</code>
*/
static String hello() {
return HELLO;
}
Ostatni komentarz przekazuje informacje o metodzie main() i moliwoci jej wyko-

rzystania. Metoda main() posiada jeden parametr args bdcy tablic parametrów
(w postaci acuchów znaków) przekazywan przez system operacyjny podczas uru-
chamiania aplikacji. Zwrómy uwag na sposób udokumentowania tego parametru
(@param identyfikator_argumentu opis_argumentu...).
/** Metoda <code>main()</code> jest miejscem, od którego rozpoczyna si
* wykonywanie programu. Program moe skada si z wielu klas, ale
* tylko jedna z nich moe zawiera publiczn, statyczn i niezwracajc
* adnej wartoci (<code>public static void</code>) metod
* <code>main()</code>. Metoda <code>main()</code>
* posiada obowizkowo jeden parametr.<br>
* Metod <code>main()</code> moemy uruchomi wewntrz innej klasy:
* <p><b>Przykad 1.</b><code><br>Z19_3.main(null);<br>}<br></code>
* Do metody <code>main()</code> z klasy <code>Z19_3</code> nie
* przekazano adnych parametrów.</p>
* <p><b>Przykad 2.</b><code><br>String[] p = {"par1", "par2"};<br>
* Z19_3.main(p);<br></code> Do metody <code>main()</code> z klasy

* <code>Z19_3</code> przekazano dwa parametry <code>"par1"</code>

* i <code>"par2".</code></p>
* @param args tablica argumentów (egzemplarzy klasy <code>String
* </code>) przekazywana przez system do metody <code>main()</code>.
* Identyfikator <code>args</code> jest skrótem sowa "argumenty" (ang.
* <i>arguments</i>) i moe by zastpiony dowolnym innym, poprawnie
* zbudowanym identyfikatorem.
*/
System.out.println(hello());
System.out.println("Jeszcze raz: "+HELLO);
}
}
Naley te zwróci uwag na pierwsze zdanie w komentarzu. To zdanie (do pierwszej
kropki) pojawia si w opisie skróconym staej, zmiennej lub metody (Summary). Cay
tekst natomiast pojawi si w opisie szczegóowym (Detail).
Dokumentacja zostaa utworzona poleceniem javadoc -d Z19_3 -nodeprecatedlist

-nohelp -private Z19_3.java i znajduje si w folderze Z19_3.
Podczas kompilacji automatycznie tworzony jest domylny, bezparametrowy konstruk-

tor klasy (pod warunkiem, e uytkownik nie zdefiniowa wasnej wersji bezparame-
trowego konstruktora). Jeli chcemy opisa bezparametrowy konstruktor Z19_3(), to
musimy poda jego definicj poprzedzon odpowiednim komentarzem dokumentacyj-
nym. Oto przykad:
/** Bezparametrowy konstruktor <code>Z19_3()</code> pozwala na tworzenie
* obiektów klasy <code>Z19_3</code> przez inne klasy. Umoliwia to
* wywoywanie metody <code>hello()</code> i metody <code>main()</code>
* zdefiniowanej w klasie <code>Z19_3</code> przez te klasy.<br>
* W przypadku metody <code>main()</code> musimy przekaza parametr -
* tablic argumentów. Parametr ten moe by tablic pust.<br>
* <p><b>Przykad</b><br>
* <code>Z19_3 x = new Z19_3();<br>
* System.out.println(x.hello());<br>
* x.main(null);<br></code></p>
*/
public Z19_3(){}
Jeli w uzyskanej dokumentacji pojawi si problemy z wywietlaniem liter z pol-

skimi znakami diakrytycznymi, naley zapisa pliki ródowe z odpowiednim kodo-
waniem i zastosowa przecznik –charset przy generowaniu dokumentacji.
Zadanie 19.4. MyIntArray.java

W komentarzu do klasy umieszczamy dwa znaczniki informujce o autorze i wersji
programu:
@author Wiesaw Rychlicki
@version 1.0 (2012-02-06)
Aby informacje przekazane za pomoc tych znaczników ukazay si w dokumentacji,

naley tworzy j z opcjami –author –version. W przykadowym rozwizaniu zada-
nia zmieniono (skrócono) nazwy metod.

/** Klasa <code>MyIntArray</code> zawiera statyczne metody, uatwiajce
* wprowadzanie danych do jednowymiarowej tablicy liczb cakowitych,
* wywietlanie zawartoci tablicy w konsoli oraz konwertowanie tablicy
* liczb zmiennoprzecinkowych na tablic liczb cakowitych.
* @author Wiesaw Rychlicki
* @version 1.0 (2012-02-06)
*/
public class MyIntArray {
/** Umoliwia wprowadzanie danych liczbowych (typu <code>int</code>)
* z konsoli do tablicy. Dane wprowadzane s przy uyciu metod z klasy
* <code>java.util.Scanner</code>. Podczas wprowadzania danych
* wywietlana jest informacja w postaci <code>Liczba 2 z 5, n = </code>.
* @param tab jednowymiarowa tablica liczb cakowitych.
*/
public static void input(int[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i) {
System.out.printf("Liczba %d z %d, n = ", i+1, n);
tab[i] = input.nextInt();
}
}
/** Umoliwia wywietlanie liczb zawartych w tablicy w konsoli.
* Kolejne liczby oddzielane s odstpem.
*/
public static void print(int[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
}
/** Umoliwia wywietlanie liczb zawartych w tablicy w konsoli.
* Kolejne liczby oddzielane s odstpem. Po wywietleniu ostatniej
* liczby przesyany jest do konsoli znak koca linii.
*/
public static void println(int[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
}
/** Zwraca jednowymiarow tablic liczb typu <code>double</code>
* o wartociach równych wartociom tablicy liczb cakowitych
* przekazanej jako parametr.
*/
public static double[] toDoubleArray(int[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
return tmp;
}
/** Zwraca jednowymiarow tablic liczb typu <code>int</code>,
* o wartociach odpowiadajcych (zaokrglenie w dó) wartociom
* elementów tablicy liczb zmiennoprzecinkowych typu <code>double</code>
* przekazanej jako parametr.

* @param tab jednowymiarowa tablica liczb zmiennoprzecinkowych typu

* <code>double</code>.
*/
public static int[] toIntArray(double[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
tmp[i] = (int)tab[i];
return tmp;
}
}
Dokumentacj utworzono poleceniem javadoc -d MyIntArray -author -version

-nodeprecatedlist -nohelp -private MyIntArray.java.
Zadanie 19.5. MyDoubleArray.java

Kody metod i komentarze dokumentacyjne róni si od przedstawionych w rozwi-
zaniu zadania 19.4 jedynie uytymi typami zmiennych. Dodano dwie dodatkowe meto-
dy. Metoda printf() suy do wywietlania liczb sformatowanych z okrelon iloci
miejsc po przecinku.
/** Umoliwia wywietlanie sformatowanych liczb (zapisanych w tablicy) na
* konsoli. Sposób formatowania okrelony jest z wykorzystaniem parametru
* <code>spec</code>, w sposób okrelony w klasie
* <a href="http://docs.oracle.com/javase/1.5.0/docs/api/java/util/
Formatter.html">
* Formatter</a>, np.: <code>"%.2f "</code> - wywietlanie liczb
* zmiennoprzecinkowych z dwoma miejscami po przecinku.
* @param spec acuch znaków okrelajcy format liczby.
* @param tab jednowymiarowa tablica liczb typu <code>double</code>.
*/
public static void printf(String spec, double[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
}
Ponadto oprócz metody konwertujcej tablic liczb cakowitych tupu int na tablic
typu double (metoda toDoubleArray()) zdefiniowano metod konwertujc tablic
liczb typu float na tablic liczb typu double. Stosujemy przecienie metody, czyli
obie metody maj t sam nazw i typ wyniku, a róni si typem parametru.
/** Zwraca jednowymiarow tablic liczb typu <code>double</code>
* o wartociach równych wartociom elementów tablicy liczb
* zmiennoprzecinkowych typu <code>float</code> przekazanej jako
* parametr.
* <code>float</code>.
*/
public static double[] toDoubleArray(float[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
return tmp;
}
}

Dokumentacj utworzono poleceniem javadoc -d MyDoubleArray -author -version

-nodeprecatedlist -nohelp -private MyDoubleArray.java.
Zadanie 19.6. MyFloatArray.java

Wystarczy zapisa plik MyDoubleArray.java pod nazw MyFloatArray.java i dokona
poprawek w typach danych, zastpujc typ double typem float (i na odwrót w jednej
z metod). Dokumentacj klasy MyFloatArray tworzymy poleceniem javadoc -d MyFloat
Array -author -version -nodeprecatedlist -nohelp -private MyFloatArray.java.
Wspóln dokumentacj trzech klas utworzymy poleceniem javadoc -d MyArrays

-author -version -nodeprecatedlist -nohelp -private MyIntArray.java MyDouble
Array.java MyFloatArray.java.
Zadanie 19.7. MyRandomArray.java

Dokumentacj utworzymy poleceniem javadoc -d MyRandomArray -author -version
-nodeprecatedlist -nohelp -private MyRandomArray.java. Kompletny kod klasy
MyRandomArray wraz z penym komentarzem zamieszczamy na listingu. Analiz kodu
i komentarzy oraz konfrontacj tych informacji z utworzon dokumentacj (HTML)
pozostawiamy Czytelnikowi.
/** Klasa <code>MyRandomArray</code> zawiera statyczne metody

* wypeniajce jednowymiarowe tablice liczb cakowitych lub
* zmiennoprzecinkowych wartociami pseudolosowymi.
* Umoliwia wywietlanie zawartoci tablic w konsoli oraz
* konwertowanie tablic na tablice z innym typem danych liczbowych.
* @version 1.0 (2012-02-06)
*/
/** Zwraca <code>n</code>-elementow tablic liczb cakowitych

* pseudolosowych typu <code>int</code> z zakresu od <code>0</code>
* do <code>m-1</code>.
* @param n liczba naturalna, rozmiar zwracanej tablicy,
* @param m liczba naturalna, okrelajca zakres losowanych wartoci
* (od <code>0</code> do <code>m-1</code>).
* @throws java.lang.NegativeArraySizeException, gdy podany wymiar
* tablicy (<code>n</code>) jest liczb ujemn.
* @throws java.lang.IllegalArgumentException, gdy podany zakres
* (<code>m</code>) nie jest liczb dodatni.
*/
public static int[] rndArray(int n, int m) {
for(int i = 0; i < n; ++i)
return tmp;
}
/** Zwraca posortowan <code>n</code>-elementow tablic liczb

* cakowitych pseudolosowych typu <code>int</code> z zakresu od

* <code>0</code> do <code>m-1</code>.
*/
public static int[] rndSortArray(int n, int m) {
for(int i = 0; i < n; ++i)
Arrays.sort(tmp);
return tmp;
}
/** Zwraca <code>n</code>-elementow tablic liczb cakowitych

* pseudolosowych typu <code>int</code> o niepowtarzajcych si
* wartociach z zakresu od <code>0</code> do <code>m-1</code>.
* @param m liczba naturalna okrelajca zakres losowanych wartoci
* @throws java.lang.IllegalArgumentException, gdy liczba elementów
* tablicy jest wiksza od liczby moliwych wartoci
* (<code>n &rt; m</code>).
*/
public static int[] rndUniqueArray(int n, int m) {
if (m < n)
int j = 0;
do {
for(int i = 0; i < j; ++i)
if (!jest)
tmp[j++] = k;
} while (j < n);
return tmp;
}
/** Zwraca posortowan, <code>n</code>-elementow tablic liczb

* cakowitych pseudolosowych typu <code>int</code> o niepowtarzajcych
* si wartociach z zakresu od <code>0</code> do
* <code>m-1</code>.


* @throws java.lang.IllegalArgumentException, gdy liczba elementów
* tablicy jest wiksza od liczby moliwych wartoci
* (<code>n &rt; m</code>).
*/
public static int[] rndSortUniqueArray(int n, int m) {
if (m < n)
int j = 0;
do {
for(int i = 0; i < j; ++i)
if (!jest)
tmp[j++] = k;
} while (j < n);
Arrays.sort(tmp);
return tmp;
}
/** Wywietla liczby zawarte w tablicy w konsoli, oddzielajc kolejne

* wartoci odstpem.
*/
public static void arrayPrint(int[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
}

* wartoci odstpem. Po wywietleniu ostatniej liczby przesyany jest
* do konsoli znak koca linii.
*/
public static void arrayPrintln(int[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
}
/** Dodaje do wszystkich liczb zawartych w tablicy podan liczb

* cakowit.
* @param tab jednowymiarowa tablica liczb cakowitych typu
* <code>int</code>.
* @param d liczba cakowita typu <code>int</code>.
*/
public static void addToArray(int[] tab, int d) {
int n = tab.length;
for(int i = 0; i < n; ++i)
tab[i] += d;
}

/** Zwraca <code>n</code>-elementow tablic liczb zmiennoprzecinkowych

* pseudolosowych typu <code>double</code> z okrelonego przedziau.
* @param a liczba zmiennoprzecinkowa typu <code>double</code>
* okrelajca przedzia losowanych wartoci:
* <br> <code><0, a)</code> - dla <code>a &gt 0</code>,
* <br> <code>(a, 0&gt</code> - dla <code>a &lt 0</code>.
* <br> Dla <code>a = 0</code> otrzymamy tablic wypenion zerami.
*/
public static double[] rndArray(int n, double a) {
for(int i = 0; i < n; ++i)
return tmp;
}

* pseudolosowych typu <code>double</code> z okrelonego przedziau,
* zaokrglonych z podan precyzj.
* @param prec liczba miejsc po przecinku.
*/
for(int i = 0; i < n; ++i)
tmp[i] = (int)(a*rnd.nextDouble()*wsp+0.5)/wsp;
return tmp;
}

* pseudolosowych typu <code>double</code> z okrelonego przedziau,
* rónicych si o wielokrotno podanego kroku (warto dodatnia).
* @param step krok - najmniejsza moliwa rónica pomidzy liczbami
* w tablicy (rónice pomidzy wartociami liczb w tablicy s
* wielokrotnoci parametru <code>step</code>).
* @throws java.lang.IllegalArgumentException, gdy podany parametr
* <code>step</code> nie jest liczb dodatni.
*/
public static double[] rndArray(int n, double a, double step) {

int k = (int)(a/step)+1;
double wsp = Math.pow(10.0, 1+(int)Math.log10(1/step));
for(int i = 0; i < n; ++i)
tmp[i] = (int)(step*rnd.nextInt(k)*wsp+0.5)/wsp;
return tmp;
}

* pseudolosowych typu <code>double</code> o niepowtarzajcych si wartociach
* z okrelonego przedziau,
* <code>a</code> jest zerem.
*/
public static double[] rndUniqueArray(int n, double a) {
if (a == 0)
throw new IllegalArgumentException("a = 0.0");
int j = 0;
do {
for(int i = 0; i < j; ++i)
if (!jest)
tmp[j++] = x;
} while (j < n);
return tmp;
}

* zmiennoprzecinkowych pseudolosowych typu <code>double</code>
* z okrelonego przedziau.
*/
public static double[] rndSortArray(int n, double a) {
for(int i = 0; i < n; ++i)
Arrays.sort(tmp);

return tmp;
}

* zmiennoprzecinkowych pseudolosowych typu <code>double</code>
* z okrelonego przedziau, o niepowtarzajcych si wartociach.
* <code>a</code> jest zerem.
*/
public static double[] rndSortUniqueArray(int n, double a) {
if (a == 0)
throw new IllegalArgumentException("a = 0.0");
int j = 0;
do {
for(int i = 0; i < j; ++i)
if (!jest)
tmp[j++] = x;
} while (j < n);
Arrays.sort(tmp);
return tmp;
}

* wartoci odstpem.
*/
public static void arrayPrint(double[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
}

* wartoci odstpem. Po wywietleniu ostatniej liczby przesyany jest
* do konsoli znak koca linii.
*/
public static void arrayPrintln(double[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
}

/** Wywietla sformatowane liczby (zapisane w tablicy) w konsoli. Sposób

* formatowania okrelony jest z wykorzystaniem parametru <code>spec</code>
* zbudowanego wedug zasad zdefiniowanych w klasie
* <a href="http://docs.oracle.com/javase/1.5.0/docs/api/java/util/
Formatter.html">.
* Formatter</a>, np.: <code>"%.2f "</code> - wywietla liczb
* zmiennoprzecinkow z dwoma miejscami po przecinku.
* @param spec acuch znaków okrelajcy format liczby.
*/
public static void arrayPrintf(String spec, double[] tab) {
int n = tab.length;
for(int i = 0; i < n; ++i)
}
/** Dodaje do wszystkich liczb zawartych w tablicy podan liczb

* zmiennoprzecinkow typu <code>double</code>.
* <code>double</code>,
* @param d liczba zmiennoprzecinkowa typu <code>double</code>.
*/
public static void addToArray(double[] tab, double d) {
int n = tab.length;
for(int i = 0; i < n; ++i)
tab[i] += d;
}
/** Zaokrgla wszystkie liczby zawarte w tablicy z okrelon precyzj.

* <code>double</code>,
* @param prec liczba cakowita typu <code>int</code>, precyzja
* zaokrglenia.
* @see #round
*/
public static void roundArray(double[] tab, int prec) {
int n = tab.length;
for(int i = 0; i < n; ++i)
tab[i] = (int)(tab[i]*wsp+0.5)/wsp;
}
/** Zwraca liczb zmiennoprzecinkow typu <code>double</code> zaokrglon

* z okrelon precyzj.
* @param x liczba zmiennoprzecinkowa typu <code>double</code>.
* @param prec liczba cakowita typu <code>int</code> okrelajca
* precyzj zaokrglenia:
* <br><code>prec > 0</code> - liczba miejsc po przecinku,
* <br><code>prec = 0</code> - zaokrglenie do wartoci cakowitej,
* <br><code>prec < 0</code> - warto bezwzgldna liczby
* <code>prec</code> okrela liczb zer przed przecinkiem, zaokrglenie
* do penych dziesitek (<code>-1</code>), setek (<code>-2</code>) itd.
*/
public static double round(double x, int prec) {
return(int)(x*wsp+0.5)/wsp;
}

/** Zwraca liczb zmiennoprzecinkow typu <code>float</code> zaokrglon

* z okrelon precyzj.
* @param x liczba zmiennoprzecinkowa typu <code>float</code>.
* @param prec liczba cakowita typu <code>int</code> okrelajca
* precyzj zaokrglenia:
* <br><code>prec > 0</code> - liczba miejsc po przecinku,
* <br><code>prec = 0</code> - zaokrglenie do wartoci cakowitej,
* <br><code>prec < 0</code> - warto bezwzgldna liczby
* <code>prec</code> okrela liczb zer przed przecinkiem, zaokrglenie
* do penych dziesitek (<code>-1</code>), setek (<code>-2</code>) itd.
*/
public static float round(float x, int prec) {
float wsp = (float) Math.pow(10.0, prec);
return (int)(x*wsp+0.5)/wsp;
}
/** Zwraca pseudolosow liczb zmiennoprzecinkow typu <code>double</code>

* z okrelonego przedziau, zaokrglon z podan precyzj.
* @param a liczba zmiennoprzecinkowa typu <code>double</code>,
* okrelajca przedzia losowanej wartoci:
* <br> Dla <code>a = 0</code> otrzymamy warto <code>0.0</code>.
* @param prec precyzja zaokrglenia.
* @see #round
*/
public static double random(double a, int prec) {
return round(a*Math.random(), prec);
}
/** Zwraca pseudolosow liczb zmiennoprzecinkow typu <code>float</code>

* z okrelonego przedziau, zaokrglon z podan precyzj.
* @param a liczba zmiennoprzecinkowa typu <code>float</code>,
* okrelajca przedzia losowanej wartoci:
* <br> Dla <code>a = 0</code> otrzymamy warto <code>0.0f</code>.
* @param prec precyzja zaokrglenia.
* @see #round
*/
public static float random(float a, int prec) {
return (float) round(a*Math.random(), prec);
}
}
20. Dziaania na uamkach

— budujemy klas Fraction
Zadanie 20.1. Z20_1.java, Fraction.java
Zacznijmy od zdefiniowania klasy Fraction z dwoma prywatnymi polami num (ang.
numerator — licznik) i den (ang. denominator — mianownik) typu cakowitego int.

/** Klasa <code>Fraction</code> suy do wykonywania podstawowych dziaa

* na uamkach zwykych (ang. <i>fraction</i> - uamek).
* @version 1.0 (2012-02-07)
*/
public class Fraction {
/** Licznik uamka (<i>numerator</i> - licznik). */
private int num;
/** Mianownik uamka (<i>denominator</i> - mianownik). */
private int den;
}
Do kodu klasy dodamy konstruktor, czyli metod o takiej samej nazwie (Fraction)
jak nazwa klasy. Konstruktor nie zwraca adnej wartoci — jego zadaniem jest inicjo-
wanie pól obiektu. Konstruktor jest wywoywany automatycznie podczas tworzenia
obiektu za pomoc operatora new. Znaczenie parametrów m i n jest objanione w komen-
tarzu dokumentacyjnym.
/** Tworzy nowy obiekt <code>Fraction</code> - uamek w postaci
* <code>m/n</code> - na podstawie wartoci cakowitych parametrów
* <code>m</code> i <code>n</code>.
* @param m liczba cakowita (licznik uamka),
* @param n liczba cakowita (mianownik uamka).
* @throws IllegalArgumentException, gdy podamy mianownik n = 0.
*/
Fraction (int m, int n) {
this.num = m;
if (n != 0)
this.den = n;
else
throw new IllegalArgumentException("Parametr n = 0!");
}
Podstawienie wartoci parametrów do pól obiektu nastpio przy uyciu sowa kluczo-
wego this, które umoliwia dostp do zmiennych egzemplarzowych i metod biecej
klasy (this.num = m; this.den = n;). Poniewa w tym przykadzie nazwy identyfi-
katorów (parametrów i pól klasy) nie powtarzaj si, wykorzystanie sowa this nie
byo konieczne — wystarczyoby podstawienie w postaci: num = m; den = n;. Poda-
nie mianownika równego 0 spowoduje zwrócenie wyjtku IllegalArgumentException.
Metoda toString() jest zaimplementowana w klasie Object i wskazane jest jej przy-
sonicie w kadej nowo tworzonej klasie. Uycie operatora + do czenia (konkate-
nacji) acucha z danymi innego typu powoduje zamian tych danych na acuchy
znaków i poczenie acuchów w jeden acuch. W przypadku dodawania obiektów
wykorzystywana jest w tym celu metoda toString() przesaniajca metod Object.
toString().
/** Zwraca acuch znaków reprezentujcy ten obiekt
* <code>Fraction</code>. Przykad zwracanego acucha
* <code>"3/4”</code>, <code>"-5/25”</code> itp.
*/
@Override public String toString() {
return num+"/"+den;
}

Utworzon klas pokaemy w prostej aplikacji.

/** <h3>Zadanie Z20.1</h3>
* Tworzenie konstruktora <code>Fraction(int, int)</code>
* i metody <code>toString()</code>.
*/
/** Prezentuje dziaanie konstruktora <code>Fraction(int, int)</code>
* i metody <code>toString()</code>.
*/
Fraction a = new Fraction(3, 4);
}
}
Polecenie Fraction a = new Fraction(3, 4) tworzy nowy obiekt a klasy Fraction

i nadaje mu warto uamka ¾.
Operacja dodawania "a = "+a (acucha znaków "a = " i obiektu a) jest równowana
operacji dodawania "a = "+a.toString() i pokazuje dziaanie metody toString().
Zwrómy uwag na uyte komentarze dokumentacyjne. W ten sposób bdziemy two-

rzyli dokumentacj klasy Fraction i wszystkich programów demonstrujcych dziaa-
nie budowanej klasy. Polecenie tworzce dokumentacj wszystkich klas zapisanych
w biecym folderze moe mie posta: javadoc -d Fraction -author -version
-nodeprecatedlist -nohelp –private -linksource *.java.
Opcja –linksource powoduje utworzenie w dokumentacji linków do stron zawiera-

jcych kod ródowy klas (zapisany w postaci stron HTML).

Bezparametrowy konstruktor tworzy obiekt odpowiadajcy liczbie 0 (num = 0; den = 1;).
* <code>0/1</code> o wartoci odpowiadajcej liczbie cakowitej
* <code>0</code>.
*/
Fraction() {
this.num = 0;
this.den = 1;
}
Ten konstruktor równie mógby mie posta Fraction() {this(0, 1);} — uywajc
sowa kluczowego this, wywoamy w ten sposób konstruktor z dwoma parametrami
i zbudujemy obiekt reprezentujcy uamek 0/1.
Konstruktor z jednym parametrem tworzy uamek o wartoci odpowiadajcej liczbie

cakowitej (mianownik tego uamka jest równy 1, a licznik jest równy podanej liczbie
cakowitej).


* <code>m/1</code> o wartoci odpowiadajcej liczbie cakowitej
* <code>m</code>.
* @param m liczba cakowita (licznik uamka).
*/
Fraction(int m) {
this.num = m;
this.den = 1;
}
Równie w tym przypadku moemy skonstruowa obiekt, uywajc sowa kluczowe-

go this konstruktora z dwoma parametrami: Fraction(int m) {this(m, 1);}.
Dziaanie konstruktorów pokaemy w aplikacji:

/** <h3>Zadanie Z20.2</h3>
* Tworzenie konstruktorów <code>Fraction()</code>
* i <code>Fraction(int)</code>.
*/
/** Prezentuje dziaanie bezparametrowego konstruktora
* <code>Fraction()</code> i konstruktora z jednym parametrem
* <code>Fraction(int)</code>.
*/
Fraction a = new Fraction();
System.out.println(new Fraction(4));
}
}

Operator podstawiania (w jzyku Java, w stosunku do obiektów) = przypisuje jednemu
obiektowi referencj do drugiego obiektu. Jeli chcemy utworzy inny obiekt o takiej
samej wartoci, to musimy posuy si konstruktorem kopiujcym:
/** Konstruktor kopiujcy - tworzy nowy obiekt <code>Fraction</code>
* o wartoci równej wartoci obiektu <code>x</code> klasy
* <code>Fraction</code> podanego jako parametr.
* @param x obiekt klasy <code>Fraction</code>.
*/
Fraction (Fraction x) {
this.num = x.num;
this.den = x.den;
}
Tworzymy obiekt a (Fraction a = new Fraction(3, 11)) i drugi obiekt, b, bdcy jego
kopi (Fraction b = new Fraction(a)). Obiekty reprezentuj ten sam uamek 3/11.
Operator == porównuje referencje obiektów, a nie ich wartoci. Wyraenie a == b
przyjmuje warto false.
Deklarujemy zmienn c typu obiektowego i przypisujemy jej referencj do obiektu

a (Fraction c = a) — zmienne a i c reprezentuj ten sam obiekt (i t sam warto
3
/11). Wyraenie a == c przyjmuje warto true.

/** <h3>Zadanie Z20.3</h3>

* Tworzenie konstruktora kopiujcego <code>Fraction(Fraction)</code>.
*/
/** Prezentuje dziaanie konstruktora kopiujcego
* <code>Fraction(Fraction)</code>.
*/
Fraction b = new Fraction(a);
System.out.println("Porównanie a == b, wynik: "+(a == b));
Fraction c = a;
System.out.println("Porównanie a == c, wynik: "+(a == c));
}
}

W przypadku gdy mianownik uamka jest liczb ujemn, naley zmieni znak mia-
nownika i licznika uamka. W kodzie metody pominito sowo kluczowe this. Nie
powoduje to adnych problemów, a kod bdzie czytelniejszy.
/** Koryguje warto pól obiektu <code>Fraction</code> w taki sposób, aby
* mianownik by zawsze liczb dodatni.
*/
private void correction() {
if (den < 0) {
den = -den;
num = -num;
}
}
Wywoanie tej metody umiecimy w kodzie konstruktora:

Fraction (int m, int n) {
this.num = m;
if (n != 0)
this.den = n;
else
this.correction();
}
Dziaanie metody przetestujemy, budujc róne uamki:

/** <h3>Zadanie Z20.4</h3>
* Tworzenie prywatnej metody <code>correction()</code>, poprawiajcej
* znaki licznika i mianownika uamka w taki sposób, aby mianownik by
* zawsze dodatni.
*/
/** Prezentuje dziaanie prywatnej metody <code>correction()</code>
* w kodzie konstruktora.
*/


System.out.println("-3/4 = "+new Fraction(-3, 4));
System.out.println("3/-4 = "+new Fraction(3, -4));
System.out.println("2/5 = "+new Fraction(2, 5));
System.out.println("-2/-5 = "+new Fraction(-2, -5));
}
}

Metod zwracajc najwikszy wspólny dzielnik moemy zbudowa na podstawie
rozwizania zadania 15.8. Przyjmujemy zgodnie z definicj nwd(0, n) = n (przypadek
nwd(m, 0) w naszej klasie nie wystpi — mianownik jest zawsze dodatni). Ponadto
dla m < 0 zmienimy znak liczby (if (m < 0) m = -m;) i wykonamy obliczenia dla |m|.
/** Zwraca najwikszy wspólny dzielnik pary liczb cakowitych dodatnich
* <code>m</code> i <code>n</code>, podanych jako parametry wywoania
* metody.
* </br><b>Uwaga:</b> <i>Podanie ujemnych wartoci tych parametrów nie
* spowoduje bdu; znaki liczb zostan zignorowane - liczby zostan
* zastpione ich bezwzgldnymi wartociami</i>.
* @param m liczba cakowita dodatnia,
* @param n liczba cakowita dodatnia.
*/
private int nwd(int m, int n) {
if (m == 0)
return n;
if (m < 0) m = -m;
while (m != n)
if (m > n)
m -= n;
else
n -= m;
return m;
}
Metoda reduce() oblicza najwikszy wspólny dzielnik dla licznika i mianownika

uamka reprezentowanego przez obiekt (int d = nwd(num, den)). Jeli dzielnik d jest
róny od jednoci, to dzielimy licznik i mianownik przez ten dzielnik.
/** Skraca uamek reprezentowany przez obiekt przez najwikszy wspólny
* dzielnik licznika i mianownika.
*/
public Fraction reduce() {
int d = nwd(num, den);
if (d != 1) {
this.den /= d;
this.num /= d;
}
return this;
}
T metod bdziemy pó niej stosowa w metodach wykonujcych dziaania na uamkach.
Uamek moemy skraca przez dodatni dzielnik d podany jako parametr.

/** Skraca uamek reprezentowany przez obiekt przez podany dzielnik

* <code>d</code>, o ile jest to moliwe.
* @param d liczba cakowita dodatnia typu <code>int</code>.
* @throws IllegalArgumentException, gdy podamy dzielnik
* <code>d ≤ 0</code>.
*/
public Fraction reduce(int d) {
if (d <= 0)
throw new IllegalArgumentException("Parametr d <= 0!");
if (this.num%d == 0 && this.den%d ==0) {
this.den /= d;
this.num /= d;
}
return this;
}
Rozszerzanie uamka nie powoduje zmiany jego wartoci i polega na pomnoeniu licz-
nika i mianownika uamka przez t sam liczb rón od zera.
/** Rozszerza uamek reprezentowany przez obiekt przez podan liczb
* cakowit <code>n ≠ 0</code>.
* @param n liczba cakowita typu <code>int</code> róna od 0.
* @throws IllegalArgumentException, gdy podamy <code>n = 0</code>.
*/
public Fraction equivalent(int n) {
if (n == 0)
this.den *= n;
this.num *= n;
this.correction(); // mianownik powinien pozosta dodatni
return this;
}
Dziaanie metody przetestujemy, budujc róne uamki:

/** <h3>Zadanie Z20.5</h3>
* Tworzenie prywatnej metody <code>nwd(int, int)</code> obliczajcej
* najwikszy wspólny dzielnik pary liczb dodatnich oraz publicznej
* metody (<code>reduce()</code> skracajcej uamek reprezentowany przez
* obiekt.
*/
/** Prezentuje dziaanie metody <code>reduce()</code>.
*/
System.out.println("a = "+a+" = "+a.reduce());
a = new Fraction(15, 20);
a = new Fraction(-9, -18);
a = new Fraction(0, 5);
}
}


ac
Mnoenie uamków moemy przedstawi prostym wzorem a c . Obliczamy
b d bd
iloczyn liczników uamków i iloczyn mianowników, a nastpnie budujemy z tych ilo-
czynów nowy uamek (obiekt Fraction).
/** Zwraca nowy obiekt <code>Fraction</code> - iloczyn uamka
* reprezentowanego przez obiekt wywoujcy metod i uamka
* reprezentowanego przez obiekt przekazany jako parametr.
* @param x uamek, obiekt klasy <code>Fraction</code>.
*/
public Fraction mult(Fraction x) {
return new Fraction(this.num*x.num, this.den*x.den).reduce();
}
am
Mnoenie uamka przez liczb cakowit wykonujemy podobnie a m .
b b
/** Zwraca nowy obiekt <code>Fraction</code> - iloczyn uamka
* reprezentowanego przez obiekt wywoujcy metod i liczby cakowitej
* typu <code>int</code> przekazanej jako parametr.
* @param m liczba cakowita typu <code>int</code>.
*/
public Fraction mult(int m) {
return new Fraction(this.num*m, this.den).reduce();
}
Moemy zdefiniowa mnoenie uamka przez liczb naturaln przy uyciu konstruk-
tora jednoargumentowego i wyej okrelonego mnoenia uamków:
return this.mult(new Fraction(m));
}
lub:
return new Fraction(m).mult(this);
}
W celu sprawdzenia zbudowanych metod wykonamy kilka przykadowych mnoe.

/** <h3>Zadanie Z20.6</h3>
* Tworzenie metod <code>mult(Fraction)</code> i <code>mult(int)</code>,
* zwracajcych nowy obiekt bdcy iloczynem uamka reprezentowanego
* przez obiekt i drugiego uamka lub liczby cakowitej.
*/
/** Prezentuje dziaanie metod zwracajcych obiekt reprezentujcy iloczyn
* uamka przez uamek i uamka przez liczb.
*/
System.out.println("3/4 * 8/9 = "+new Fraction(3, 4).
mult(new Fraction(8, 9)));
Fraction a = new Fraction(-5, 7);
Fraction b = new Fraction(7, 15);

System.out.println("a*b = "+a.mult(b));
System.out.println("b*a = "+b.mult(a));
System.out.println("a*2 = "+a.mult(2));
System.out.println("a*(-14) = "+a.mult(-14));
}
}

Mnoenie dwóch uamków (obiektów Fraction):
/** Zwraca obiekt klasy <code>Fraction</code> bdcy iloczynem dwóch
* obiektów <code>Fraction</code>.
* @param x obiekt klasy <code>Fraction</code>,
* @param y obiekt klasy <code>Fraction</code>.
*/
public static Fraction prod(Fraction x, Fraction y) {
return x.mult(y);
}
Mnoenie uamka (obiektu Fraction) przez liczb cakowit lub mnoenie liczby przez
uamek:
/** Zwraca obiekt klasy <code>Fraction</code> bdcy iloczynem obiektu
* <code>Fraction</code> i liczby cakowitej typu <code>int</code>.
*/
public static Fraction prod(Fraction x, int m) {
return x.mult(m);
}
/** Zwraca obiekt klasy <code>Fraction</code> bdcy iloczynem liczby

* cakowitej typu <code>int</code> i obiektu <code>Fraction</code>.
*/
public static Fraction prod(int m, Fraction x) {
return x.mult(m);
}
Iloczyn dwóch liczb cakowitych zapisany w postaci obiektu klasy Fraction:

/** Zwraca obiekt klasy <code>Fraction</code> reprezentujcy iloczyn
* dwóch liczb cakowitych typu <code>int</code>.
* @param m liczba cakowita typu <code>int</code>,
* @param n liczba cakowita typu <code>int</code>.
*/
public static Fraction prod(int m, int n) {
return new Fraction(m).mult(n);
}
Kilka przykadowych iloczynów ilustruje dziaanie utworzonych metod statycznych.

/** <h3>Zadanie Z20.7</h3>
* Tworzenie metod statycznych realizujcych mnoenie dwóch obiektów
* <code>Fraction</code>, obiektu <code>Fraction</code>

* i liczby cakowitej oraz mnoenie dwóch liczb cakowitych z wynikiem

* typu <code>Fraction</code>.
*/
/** Prezentuje dziaanie metod statycznych obliczajcych iloczyn
* uamka przez uamek, uamka przez liczb cakowit i iloczyn dwóch
* liczb cakowitych z wynikami typu <code>Fraction</code>.
*/
System.out.println("a*b = "+Fraction.prod(a, b));
System.out.println("a*4 = "+Fraction.prod(a, 4));
System.out.println("-3*b = "+Fraction.prod(-3, b));
System.out.println("2*3 = "+Fraction.prod(2, 3));
}
}

Utworzenie uamka odwrotnego jest prost czynnoci — wystarczy zamieni war-
to licznika i mianownika. Uamek w postaci 0/1 (liczba 0) nie ma odwrotnoci, wic
zamiana licznika i mianownika spowoduje prób utworzenia uamka 1/0 (new Frac-
tion(1, 0)) — konstruktor zgosi wyjtek IllegalArgumentException.
/** Zwraca obiekt <code>Fraction</code> reprezentujcy odwrotno uamka
* zawartego w obiekcie wywoujcym t metod.
* @throws IllegalArgumentException, gdy ten obiekt reprezentuje uamek
* <code>0/1</code>.
*/
public Fraction multInv() {
return new Fraction(this.den, this.num);
}
Podobnie dziaa metoda statyczna:

/** Zwraca obiekt <code>Fraction</code> reprezentujcy odwrotno uamka
* zawartego w obiekcie <code>x</code> podanym jako parametr.
* @throws IllegalArgumentException, gdy obiekt <code>x</code>
* reprezentuje uamek <code>0/1</code>.
*/
public static Fraction multInv(Fraction x) {
return new Fraction(x.den, x.num);
}
Metody przetestujemy, obliczajc odwrotnoci kilku uamków. Zwrómy uwag na

moliwo wykonywania dzielenia uamków wedug szkolnej reguki: aby podzieli
przez uamek, mnoymy przez jego odwrotno .
/** <h3>Zadanie Z20.8</h3>
* Tworzenie metod wyznaczajcych odwrotno uamka.
*/
/** Prezentuje dziaanie metod obliczajcych odwrotno uamka.
*/


System.out.println("1/a = "+a.multInv());
Fraction b = new Fraction(-7, 9);
System.out.println("1/b = "+Fraction.multInv(b));
Fraction c = new Fraction();
try {
System.out.println("1/c = "+Fraction.multInv(c));
} catch(IllegalArgumentException e) {
System.out.println("Nie istnieje odwrotno 0!");
}
System.out.println("a/b = "+a.mult(b.multInv()));
System.out.println("a/b = "+b.multInv().mult(a));
System.out.println("a/b = "+Fraction.
prod(a,Fraction.multInv(b)));
}
}

Do klasy Fraction doczymy metody wykonujce dzielenie uamka przez uamek
i dzielenie uamka przez liczb cakowit.
/** Zwraca nowy obiekt <code>Fraction</code> - iloraz uamka zawartego
* w obiekcie wywoujcym metod (dzielna) i uamka reprezentowanego
* przez obiekt przekazany jako parametr (dzielnik).
* @param x uamek - obiekt klasy <code>Fraction</code> (dzielnik).
* @throws ArithmeticException, gdy obiekt <code>x</code> reprezentuje
* <code>0/1</code>.
*/
public Fraction div(Fraction x) {
if (x.num == 0)
throw new ArithmeticException("Dzielenie przez 0!");
return new Fraction(this.num*x.den, this.den*x.num).reduce();
}
/** Zwraca nowy obiekt <code>Fraction</code> - iloraz uamka zawartego

* w obiekcie wywoujcym metod (dzielna) i liczby cakowitej typu
* <code>int</code> przekazanej jako parametr (dzielnik).
* @param m liczba cakowita typu <code>int</code> (dzielnik).
* @throws ArithmeticException, gdy podamy <code>m = 0</code>.
*/
public Fraction div(int m) {
if (m == 0)
return new Fraction(this.num, this.den*m).reduce();
}
Dziaanie metod sprawdzimy, wykonujc kilka przykadowych dziele. Zwrómy uwa-

g na przypadki dzielenia przez 0 — nastpuje zwrócenie wyjtku przez metod i jego
obsuga w programie.
/** <h3>Zadanie Z20.9</h3>
* Tworzenie metod <code>div(Fraction)</code> i <code>div(int)</code>

* zwracajcych nowy obiekt bdcy ilorazem uamka reprezentowanego

*/
/** Prezentuje dziaanie metod zwracajcych obiekt reprezentujcy iloraz
* uamka przez uamek i uamka przez liczb.
*/
System.out.println("(3/4) / (3/7) = "+new Fraction(3, 4).
div(new Fraction(3, 7)));
System.out.println("a/b = "+a.div(b));
System.out.println("b/a = "+b.div(a));
System.out.println("a/2 = "+a.div(2));
System.out.println("a/(-4) = "+a.div(-4));
try {
Fraction c = new Fraction(0, 5);
System.out.println("a/c = "+a.div(c));
} catch(ArithmeticException e) {
}
try {
System.out.println("a/0 = "+a.div(0));
}
}
}

Do klasy Fraction doczamy cztery metody statyczne realizujce róne przypadki
dzielenia — niezbdne objanienia zawarte s w komentarzach dokumentacyjnych.
/** Zwraca obiekt klasy <code>Fraction</code> bdcy ilorazem dwóch
* @param x obiekt klasy <code>Fraction</code> (dzielna),
* @param y obiekt klasy <code>Fraction</code> (dzielnik).
* @throws ArithmeticException, gdy obiekt <code>y</code> reprezentuje
* <code>0/1</code>.
*/
public static Fraction quot(Fraction x, Fraction y) {
if (y.num == 0)
return x.div(y);
}
/** Zwraca obiekt klasy <code>Fraction</code> bdcy ilorazem obiektu

* <code>Fraction</code> (dzielna) i liczby cakowitej typu
* <code>int</code> (dzielnik).
* @param x obiekt klasy <code>Fraction</code> (dzielna),
* @param m liczba cakowita typu <code>int</code> (dzielnik).
* @throws ArithmeticException, gdy podamy <code>m = 0</code>.
*/

public static Fraction quot(Fraction x, int m) {

if (m == 0)
return x.div(m);
}
/** Zwraca obiekt klasy <code>Fraction</code> bdcy ilorazem liczby

* cakowitej typu <code>int</code> (dzielna) i obiektu
* <code>Fraction</code> (dzielnik).
* @param m liczba cakowita typu <code>int</code> (dzielna).
* @param x obiekt klasy <code>Fraction</code> (dzielnik).
* @throws ArithmeticException, gdy obiekt <code>x</code> reprezentuje
* <code>0/1</code>.
*/
public static Fraction quot(int m, Fraction x) {
if (x.num == 0)
return new Fraction(m).div(x);
}
/** Zwraca obiekt klasy <code>Fraction</code> reprezentujcy iloraz

* @param m liczba cakowita typu <code>int</code> (dzielna),
* @param n liczba cakowita typu <code>int</code> (dzielnik).
* @throws ArithmeticException, gdy podamy <code>n = 0</code>.
*/
public static Fraction quot(int m, int n) {
if (n == 0)
return new Fraction(m, n).reduce();
}
Kilka przykadowych dziele pokazuje dziaanie przecionych metod quot() dla ró-
nych par argumentów (dzielenie uamka przez uamek, uamka przez liczb cakowit,
liczby cakowitej przez uamek oraz dzielenie dwóch liczb cakowitych z wynikiem
typu Fraction).
/** <h3>Zadanie Z20.10</h3>
* Tworzenie metod statycznych realizujcych dzielenie dwóch obiektów
* <code>Fraction</code>, obiektu <code>Fraction</code> przez liczb
* cakowit, liczby cakowitej przez obiekt oraz dzielenie dwóch liczb
* cakowitych z wynikiem typu <code>Fraction</code>.
*/
/** Prezentuje dziaanie metod statycznych obliczajcych iloraz uamka
* przez uamek, uamka przez liczb cakowit, liczby cakowitej przez
* uamek i iloraz dwóch liczb cakowitych z wynikami typu
* <code>Fraction</code>.
*/
System.out.println("a/b = "+Fraction.quot(a, b));
System.out.println("a/4 = "+Fraction.quot(a, 4));
System.out.println("-3/b = "+Fraction.quot(-3, b));
System.out.println("4/12 = "+Fraction.quot(4, 12));

try {
System.out.println("a/c = "+Fraction.quot(a, c));
}
try {
System.out.println("a/0 = "+Fraction.quot(a, 0));
}
}
}

Doczmy do klasy Fraction prywatn metod obliczajc najmniejsz wspóln wie-
lokrotno pary liczb dodatnich (w metodzie nie sprawdzamy, czy ten warunek jest
speniony, poniewa gwarantuje nam to przyjte zaoenie, e w obiekcie mianowniki
s liczbami dodatnimi).
/** Zwraca najmniejsz wspóln wielokrotno pary liczb cakowitych
* dodatnich <code>m</code> i <code>n</code> podanych jako parametry
* wywoania metody.
* @param m liczba cakowita dodatnia,
* @param n liczba cakowita dodatnia.
*/
private int nww(int m, int n) {
int wm = m;
int wn = n;
while (wm != wn)
if (wm > wn)
wn += n;
else
wm += m;
return wm;
}
Czytelnik moe zastosowa inny algorytm wyznaczania NWW.
Porównujemy mianowniki obu uamków. Jeli s równe, to uamki dodajemy wedug

a c ac
wzoru i zwracamy wynik (new Fraction(this.num+x.num, this.den)). Gdy
b b b
mianowniki s róne, to obliczamy najmniejsz wspóln wielokrotno mianowników
(int wm = nww(this.den, x.den)), rozszerzamy uamki do wspólnego mianownika (wm)
wm wm wm wm wm wm
a c a c a c
a c b d b d b d .
i nastpnie je dodajemy —
b d wm b wm d wm wm wm
b d
/** Zwraca nowy obiekt <code>Fraction</code> - sum obiektu wywoujcego
* t metod i obiektu przekazanego jako parametr.
*/

public Fraction add(Fraction x) {

if (this.den == x.den)
return new Fraction(this.num+x.num, this.den).reduce();
else {
int wm = nww(this.den, x.den);
return new Fraction(wm/this.den*this.num+wm/x.den*x.num, wm).
reduce();
}
}
Dodawanie liczby cakowitej do uamka zrealizujemy wedug wzoru

a a mb a mb
m .
b b b b
/** Zwraca nowy obiekt <code>Fraction</code> - sum obiektu wywoujcego
* t metod i liczby cakowitej przekazanej jako parametr.
*/
public Fraction add(int m) {
return new Fraction(this.num+m*this.den, this.den).reduce();
}
Pozostaje jeszcze przetestowanie dziaania metody add().

/** <h3>Zadanie Z20.11</h3>
* Tworzenie metod <code>add(Fraction)</code> i <code>add(int)</code>,
* zwracajcych nowy obiekt bdcy sum uamka reprezentowanego
*/
/** Prezentuje dziaanie metod zwracajcych obiekt reprezentujcy sum
* uamków i sum uamka i liczby cakowitej.
*/
System.out.println("3/4 + 1/2 = "+new Fraction(3, 4).
add(new Fraction(1, 2)));
System.out.println("a+b = "+a.add(b));
System.out.println("b+a = "+b.add(a));
System.out.println("a+2 = "+a.add(2));
System.out.println("a-3 = "+a.add(-3));
}
}

Sum dwóch obiektów x i y obliczymy, wykorzystujc metod add() dla jednego obiek-
tu, a drugi podamy jako parametr (x.add(y)).
/** Zwraca obiekt klasy <code>Fraction</code> bdcy sum dwóch
* @param y obiekt klasy <code>Fraction</code>.
*/

public static Fraction sum(Fraction x, Fraction y) {

return x.add(y);
}
Podobnie obliczymy sum obiektu x i liczby cakowitej m (x.add(m)) oraz — korzysta-

jc z przemiennoci dodawania — sum liczby cakowitej m i obiektu x.
/** Zwraca obiekt klasy <code>Fraction</code> bdcy sum obiektu
* <code>Fraction</code> i liczby cakowitej typu <code>int</code>.
*/
public static Fraction sum(Fraction x, int m) {
return x.add(m);
}
/** Zwraca obiekt klasy <code>Fraction</code> bdcy sum liczby

* cakowitej typu <code>int</code> i obiektu <code>Fraction</code>.
*/
public static Fraction sum(int m, Fraction x) {
return x.add(m);
}
Do kompletu metod (sum()) doczymy metod dodajc dwie liczby cakowite i zwra-
cajc wynik w postaci obiektu klasy Fraction.
/** Zwraca obiekt klasy <code>Fraction</code> reprezentujcy sum
* @param n liczba cakowita typu <code>int</code>.
*/
public static Fraction sum(int m, int n) {
return new Fraction(m+n);
}
Przykady kilku dodawa ilustruj zastosowanie statycznych metod wykonujcych

dodawanie.
/** <h3>Zadanie Z20.12</h3>
* Tworzenie metod statycznych realizujcych dodawanie dwóch obiektów
* <code>Fraction</code> oraz obiektu <code>Fraction</code>
* i liczby cakowitej.
*/
/** Prezentuje dziaanie metod statycznych obliczajcych sum
* dwóch uamków oraz uamka i liczby cakowitej.
*/
System.out.println("a+b = "+Fraction.sum(a, b));
System.out.println("a+4 = "+Fraction.sum(a, 4));

System.out.println("-3+b = "+Fraction.sum(-3, b));

System.out.println("2+3 = "+Fraction.sum(2, 3));
}
}

Zamiana uamka na przeciwny polega na zmianie znaku licznika (przyjlimy zasad,
e mianownik jest zawsze dodatni).
/** Zwraca obiekt <code>Fraction</code> reprezentujcy uamek przeciwny
* do uamka zawartego w obiekcie wywoujcym t metod.
*/
public Fraction addInv() {
return new Fraction(-this.num, this.den);
}
/** Zwraca obiekt <code>Fraction</code> reprezentujcy uamek przeciwny

* do uamka zawartego w obiekcie <code>x</code> podanym jako parametr.
*/
public static Fraction addInv(Fraction x) {
return new Fraction(-x.num, x.den);
}
Pokazujc dziaanie metody wyznaczajcej uamek przeciwny, wykonamy dodawanie

dwóch liczb (uamków) wzajemnie przeciwnych (wynik 0/1) oraz odejmowanie uam-
ków w myl szkolnej reguy mówicej, e odejmowanie mona zastpi dodawaniem
liczby przeciwnej.
/** <h3>Zadanie Z20.13</h3>
* Tworzenie metod wyznaczajcych uamek przeciwny.
*/
/** Prezentuje dziaanie metod obliczajcych uamek przeciwny.
*/
System.out.println("-a = "+a.addInv());
Fraction b = new Fraction(-7, 9);
System.out.println("-b = "+Fraction.addInv(b));
System.out.println("a+(-a) = "+a.add(a.addInv()));
System.out.println("(-a)+a = "+a.addInv().add(a));
System.out.println("a-b = "+a.add(b.addInv()));
System.out.println("a-b = "+b.addInv().add(a));
System.out.println("a-b = "+Fraction.sum(a,Fraction.addInv(b)));
}
}

W rozwizaniu zadania 20.11 dokadnie omówiono dodawanie uamków. Odejmowa-
nie realizujemy w podobny sposób — we wzorach symbol dodawania (+) zastpimy
symbolem odejmowania (–). Nie zapomnijmy zmieni nazwy metody.

/** Zwraca nowy obiekt <code>Fraction</code> - rónic obiektu

* wywoujcego t metod i obiektu przekazanego jako parametr.
*/
public Fraction sub(Fraction x) {
if (this.den == x.den)
return new Fraction(this.num-x.num, this.den).reduce();
else {
int wm = nww(this.den, x.den);
return new Fraction(wm/this.den*this.num-wm/x.den*x.num, wm).
reduce();
}
}
/** Zwraca nowy obiekt <code>Fraction</code> - rónic obiektu

* wywoujcego t metod (odjemna) i liczby cakowitej przekazanej jako
* parametr (odjemnik).
* @param m liczba cakowita typu <code>int</code> (odjemnik).
*/
public Fraction sub(int m) {
return new Fraction(this.num-m*this.den, this.den).reduce();
}
Metod sub() sprawdzimy, wykonujc kilka przykadowych dziaa.

/** <h3>Zadanie Z20.14</h3>
* Tworzenie metod <code>sub(Fraction)</code> i <code>sub(int)</code>
* zwracajcych nowy obiekt bdcy rónic uamka reprezentowanego przez
* obiekt i drugiego uamka lub liczby cakowitej.
*/
/** Prezentuje dziaanie metod zwracajcych obiekt reprezentujcy rónic
* uamków i rónic uamka i liczby cakowitej.
*/
System.out.println("3/4 - 1/2 = "+new Fraction(3, 4).
sub(new Fraction(1, 2)));
System.out.println("a-b = "+a.sub(b));
System.out.println("b-a = "+b.sub(a));
System.out.println("a-2 = "+a.sub(2));
System.out.println("a-(-3) = "+a.sub(-3));
}
}

Rónic dwóch obiektów x i y obliczymy, wykorzystujc metod sub() dla pierwsze-
go obiektu, a drugi podamy jako parametr (x.sub(y)).
/** Zwraca obiekt klasy <code>Fraction</code> bdcy rónic dwóch
* @param x obiekt klasy <code>Fraction</code> (odjemna),
* @param y obiekt klasy <code>Fraction</code> (odjemnik).
*/

public static Fraction diff(Fraction x, Fraction y) {

return x.sub(y);
}
Podobnie od obiektu x odejmiemy liczb cakowit m (x.sub(m)).

/** Zwraca obiekt klasy <code>Fraction</code> bdcy rónic obiektu
* <code>Fraction</code> (odjemna) i liczby cakowitej typu
* <code>int</code> (odjemnik).
* @param x obiekt klasy <code>Fraction</code> (odjemna),
* @param m liczba cakowita typu <code>int</code> (odjemnik).
*/
public static Fraction diff(Fraction x, int m) {
return x.sub(m);
}
Odejmowanie nie jest przemienne, ale obowizuje wzór m x x m . Praw stron

tego wzoru moemy zapisa, uywajc odpowiednich metod x.sub(m).addInv().
/** Zwraca obiekt klasy <code>Fraction</code> bdcy rónic liczby
* cakowitej typu <code>int</code> (odjemna) i obiektu
* <code>Fraction</code> (odjemnik).
* @param m liczba cakowita typu <code>int</code> (odjemna),
* @param x obiekt klasy <code>Fraction</code> (odjemnik).
*/
public static Fraction diff(int m, Fraction x) {
return x.sub(m).addInv();
}
Kolejna metoda odejmuje dwie liczby cakowite i zwraca wynik w postaci obiektu
Fraction.
/** Zwraca obiekt klasy <code>Fraction</code> reprezentujcy rónic
* @param m liczba cakowita typu <code>int</code> (odjemna),
* @param n liczba cakowita typu <code>int</code> (odjemnik).
*/
public static Fraction diff(int m, int n) {
return new Fraction(m-n);
}
Kilka przykadowych oblicze pokae nam dziaanie metody diff().

/** <h3>Zadanie Z20.15</h3>
* Tworzenie metod statycznych realizujcych odejmowanie dwóch obiektów
* <code>Fraction</code>, obiektu <code>Fraction</code>
* i liczby cakowitej.
*/
/** Prezentuje dziaanie metod statycznych obliczajcych rónic dwóch
* uamków oraz uamka i liczby cakowitej.
*/
System.out.println("a-b = "+Fraction.diff(a, b));

System.out.println("b-a = "+Fraction.diff(b, a));

System.out.println("a-4 = "+Fraction.diff(a, 4));
System.out.println("(-3)-b = "+Fraction.diff(-3, b));
System.out.println("b-(-3) = "+Fraction.diff(b, -3));
System.out.println("2-3 = "+Fraction.diff(2, 3));
}
}

Warto prywatnych pól obiektu (licznik i mianownik uamka) moemy odczyta przy
uyciu metod getNum() i getDen() (czasem taka informacja moe by przydatna).
/** Zwraca warto licznika uamka reprezentowanego przez obiekt.
*/
public int getNum() {
return this.num;
}
/** Zwraca warto mianownika uamka reprezentowanego przez obiekt.

*/
public int getDen() {
return this.den;
}
Przykad odczytywania prywatnych pól obiektu z zastosowaniem zdefiniowanych metod.

/** <h3>Zadanie Z20.16</h3>
* Tworzenie metod pobierajcych dane z prywatnych pól obiektu
*/
/** Prezentuje dziaanie metod pobierajcych dane z prywatnych pól
* obiektu <code>Fraction</code> - licznik i mianownik uamka.
*/
Fraction a = new Fraction(4, -7);
System.out.println("licznik: "+a.getNum());
System.out.println("mianownik: "+a.getDen());
}
}

Czasem potrzebujemy zmieni warto wybranych (prywatnych) pól obiektu bez two-
rzenia nowego obiektu i usuwania poprzedniej instancji. Moemy to zrealizowa, de-
finiujc odpowiednie metody (szczegóy w komentarzach).
/** Ustawia warto licznika uamka reprezentowanego przez obiekt.
* @param m liczba cakowita typu <code>int</code>, nowa warto
* licznika uamka reprezentowanego przez obiekt.
*/
public Fraction setNum(int m) {
this.num = m;
return this;
}

/** Ustawia warto mianownika uamka.

* @param n liczba cakowita dodatnia typu <code>int</code>, nowa
* warto mianownika uamka reprezentowanego przez obiekt.
* @throws IllegalArgumentException, gdy podamy mianownik ujemny lub
* równy 0.
*/
public Fraction setDen(int n) {
if (n > 0) {
this.den = n;
return this;
} else
throw new IllegalArgumentException("Parametr n <= 0!");
}
/** Ustawia warto licznika i mianownika uamka.

* @param m liczba cakowita typu <code>int</code>, nowa warto
* licznika uamka reprezentowanego przez obiekt.
* @param n liczba cakowita dodatnia typu <code>int</code>, nowa
* warto mianownika uamka reprezentowanego przez obiekt.
* @throws IllegalArgumentException, gdy podamy mianownik ujemny lub
* równy 0.
*/
public Fraction setFrac(int m, int n) {
if (n > 0) {
this.num = m;
this.den = n;
return this;
} else
throw new IllegalArgumentException("Parametr n <= 0!");
}
Przykad wykorzystania metod setNum(), setDen() i setFrac() pokazuje poprawne za-

stosowanie metod oraz sytuacje prowadzce do bdu (z obsug wyjtków zgaszanych
przez metody — próba ustawienia mianownika ujemnego lub wartoci 0).
/** <h3>Zadanie Z20.17</h3>
* Tworzenie metod zmieniajcych dane w prywatnych polach obiektu
*/
/** Prezentuje dziaanie metod zmieniajcych dane w prywatnych polach
* obiektu <code>Fraction</code>.
*/
Fraction a = new Fraction(4, -7);
System.out.println("Zmiana wartoci:");
System.out.println(" - licznika (3), a = "+a.setNum(3));
System.out.println(" - mianownika (11), a = "+a.setDen(11));
System.out.println(" - uamka (3, 5), a = "+a.setFrac(3, 5));
try {
a.setDen(-2);
} catch (IllegalArgumentException e) {
System.out.println("Mianownik: "+e.getMessage());
}
try {
a.setFrac(-2, 0);

} catch (IllegalArgumentException e) {
System.out.println("Mianownik: "+e.getMessage());
}
}
}

Adnotacja Override informuje kompilator, e metoda Fraction.equals() przesania
dziedziczon metod Object.equals(). Parametr o jest obiektem klasy Object, z któ-
rej dziedzicz wszystkie klasy. Najpierw referencj obiektu wywoujcego metod
equals porównujemy z referencj parametru (this == o) — równo referencji gwa-
rantuje równo obiektów (obie referencje wskazuj ten sam obiekt) i moemy zwró-
ci wynik true.
Jeli porównanie nie zakoczyo si, to sprawdzamy, czy parametr o jest referencj do
jakiegokolwiek obiektu. Spenienie równoci o == null spowoduje zwrócenie warto-
ci false (obiekt wywoujcy metod ma referencj rón od null). Warto false
zwrócimy równie wtedy, gdy parametr o jest obiektem innej klasy ni Fraction, czyli
nie jest obiektem tej klasy (!(o instanceof Fraction)).
Jeli porównywanie trwa nadal, to mamy ju do czynienia z dwoma obiektami klasy
Fraction. Tworzymy nowy obiekt klasy Fraction i rzutujemy parametr o klasy Object
na typ obiektowy Fraction (Fraction c = (Fraction) o). Teraz pozostaje porównanie
dwóch obiektów klasy Fraction — obiektu wywoujcego metod i obiektu c:
if (this.num*c.den == this.den*c.num)
return true;
else
return false;
Jak wspomniano w uwadze do zadania, podczas obliczania iloczynów w porównaniu

(this.num*c.den == this.den*c.num) moemy przekroczy maksymaln warto typu
int, wic moemy otrzyma bdny wynik.
/** Porównuje obiekt klasy <code>Fraction</code> (wywoujcy t metod)
* z dowolnym innym obiektem i zwraca warto <code>true</code>, gdy
* obiekty s tego samego typu i reprezentuj t sam warto (uamek).
* Metoda przesania metod <code>Object.equals()</code>.
*/
@Override public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || !(o instanceof Fraction))
return false;
Fraction c = (Fraction) o;
if (this.num*c.den == this.den*c.num)
return true;
else
return false;
}
Tworzc kopi (obiekt d) obiektu wywoujcego metod, moemy obiekty c i d skró-

ci. Porównanie skróconych uamków ograniczy si do porównania ich liczników

i mianowników (bez mnoenia). Kopi obiektu robimy po to, aby w wyniku skracania
nie zmieni pól obiektu wywoujcego metod.
Fraction d = new Fraction(this);
c.reduce();
d.reduce();
if (d.num == c.num && d.den == c.den)
return true;
else
return false;
Przedefiniowanie metody hashCode() nie jest w tym zadaniu konieczne. Pokaemy

jednak, jak mona t metod zrealizowa 1:
@Override public int hashCode() {
int d = nwd(num, den);
int result = 17;
result = 31*result+num/d;
result = 31*result+den/d;
return result;
}
Analiz kodu przykadu zastosowania metody equals() dla obiektów klasy Fraction
/** <h3>Zadanie Z20.18</h3>
* Tworzenie metody equals() do porównywania obiektu <code>Fraction</code>
* z innymi obiektami tej samej klasy lub innych klas.
*/
/** Prezentuje dziaanie metody equals() przesaniajcej metod
* Object.equals.
*/
Fraction d = new Fraction(20, 36);
System.out.println("Trzy róne obiekty reprezentuj t sam
liczb 4/7.");
System.out.println("Czwarty obiekt reprezentuje inn liczb
20/36 = 5/9.");
System.out.println("Metoda equals() jest relacj równowanoci:");
System.out.println(" * jest zwrotna:");
System.out.println("a.equals(a): "+a.equals(a));
System.out.println(" * jest symetryczna:");
System.out.println("a.equals(b): "+a.equals(b));
System.out.println("b.equals(a): "+b.equals(a));
1
Opracowane na podstawie: J. Bloch, Java. Efektywne programowanie. Wydanie II, Helion 2009.

System.out.println("a.equals(d): "+a.equals(d));
System.out.println("d.equals(a): "+d.equals(a));
System.out.println(" * jest przechodnia:");
System.out.println("a.equals(b): "+a.equals(b));
System.out.println("b.equals(c): "+b.equals(c));
System.out.println("a.equals(c): "+a.equals(c));
System.out.println("Podstawiamy d = a, obie referencje wskazuj
ten sam obiekt.");
d = a;
System.out.println("Porównujemy obiekty rónych typów:");
System.out.println("a.equals(5): "+a.equals(5));
System.out.println("Zmieniamy warto obiektu a. Referencja d
nadal wskazuje ten sam obiekt.");
a.setFrac(5, 1);
System.out.println("Porównujemy obiekty rónych typów:");
System.out.println("a.equals(Integer.valueOf(5)): "
+a.equals(Integer.valueOf(5)));
System.out.println("Podstawiamy d = null, referencja d nie
wskazuje adnego obiektu.");
d = null;
System.out.println("b.equals(null): "+b.equals(null));
}
}

Rzutujemy licznik uamka (this.num) na typ zmiennoprzecinkowy double lub float
i dzielimy przez mianownik (this.den). W wyniku dzielenia otrzymujemy liczb
zmiennoprzecinkow odpowiedniego typu.
/** Zwraca warto dziesitn typu <code>double</code> uamka
* reprezentowanego przez obiekt wywoujcy t metod.
*/
public double doubleValue() {
return (double)this.num/this.den;
}
/** Zwraca warto dziesitn typu <code>float</code> uamka

* reprezentowanego przez obiekt wywoujcy t metod.
*/
public float floatValue() {
return (float)this.num/this.den;
}
Podobnie postpujemy w metodach statycznych, dzielc licznik (rzutowany na typ

zmiennoprzecinkowy) przez mianownik.
/** Zwraca warto dziesitn typu <code>double</code> uamka
* reprezentowanego przez obiekt podany jako parametr.
* @param x obiekt typu <code>Fraction</code>.

*/
public static double toDouble(Fraction x) {
return (double)x.num/x.den;
}
/** Zwraca warto dziesitn typu <code>float</code> uamka

* reprezentowanego przez obiekt podany jako parametr.
* @param x obiekt typu <code>Fraction</code>.
*/
public static float toFloat(Fraction x) {
return (float)x.num/x.den;
}
Dziaanie metod ilustrujemy czterema przykadami oblicze:

/** <h3>Zadanie Z20.19</h3>
* Tworzenie metod zamieniajcych uamek zwyky (obiekt
* <code>Fraction</code>) na uamek dziesitny.
*/
/** Prezentuje dziaanie metod zamieniajcych uamek zwyky (obiekt
* <code>Fraction</code>) na uamek dziesitny.
*/
System.out.println("Double: a = "+a+" = "+a.doubleValue());
System.out.println("Float: a = "+a+" = "+a.floatValue());
double x = Fraction.toDouble(b);
System.out.println("Double: b = "+b+" = "+x);
System.out.println("Float: b = "+b+" = "+Fraction.toFloat(b));
}
}

Mamy cztery poprawne postacie acucha wejciowego str — liczb cakowit lub
dwie liczby cakowite oddzielone znakiem slash (/), kropk (.) albo przecinkiem (,).
a) Jeli w acuchu wejciowym str nie wystpuje aden z tych znaków,
to mamy przypuszczalnie do czynienia z liczb cakowit (np. "23").
Polom obiektu przypisujemy wartoci:
this.num = Integer.parseInt(str);
this.den = 1;
Gdy acuch str nie jest poprawnym zapisem liczby cakowitej, to uyta
do konwersji metoda Integer.parseInt() rzuci wyjtek.
b) Znajdujcy si na pozycji i = str.indexOf('/') znak slash (/) rozdziela
acuch znaków na dwie liczby — licznik (str.substring(0, i)) i mianownik
(str.substring(i+1)). Polom obiektu przypisujemy wartoci:
this.num = Integer.parseInt(str.substring(0, i));
this.den = Integer.parseInt(str.substring(i+1));
Jeli mianownik okae si zerem, to rzucimy wyjtek:

if (this.den == 0)
Gdy jeden z podcigów (str.substring(0, i) lub str.substring(i+1))

nie jest poprawn liczb cakowit, to metoda Integer.parseInt() rzuci
wyjtek.
c) Wystpujca na pozycji i = str.indexOf('.') kropka (.) rozdziela acuch
na dwie czci — cz cakowit liczby (str.substring(0, i)) i cig cyfr
czci uamkowej (str.substring(i+1)). Rozwamy to na przykadzie:
75 275
"2.75" o"2" i "75" o 2 .
100 100
Suma (zczenie) tych dwóch podcigów daje nam licznik uamka:
this.num = Integer.parseInt(str.substring(0, i)+str.substring(i+1));
Drugi podcig wyznacza mianownik uamka (potga liczby 10) — liczba cyfr
jest równa liczbie zer w mianowniku.
int k = str.length()-i; // liczba cyfr po kropce
this.den = 1;
int n = 1;
while (n++ < k)
this.den *= 10;
Bd w postaci liczby moe by sygnalizowany wyjtkami zgoszonymi

przez metod parseInt().
d) Przecinek (,) rozdziela acuch — wedug przykadu z podpunktu c)
(kod jest wspólny dla obu podpunktów).
Na koniec zbudowany uamek podlega korekcji (tak aby mianownik
by dodatni) oraz skróceniu.
/** Tworzy nowy obiekt <code>Fraction</code> - uamek na
* podstawie acucha znaków o postaci "4/7", "5", "2.45" lub "2,45".
* @param str acuch znaków o postaci "4/7", "5", "2.45" lub "2,45".
* @throws NumberFormatException, gdy podamy acuch znaków nie
* przedstawia uamka zwykego lub dziesitnego.
*/
public Fraction(String str) {
int i = str.indexOf('.');
if (i == -1)
i = str.indexOf(',');
if (i == -1) {
i = str.indexOf('/');
if (i == -1) {
this.num = Integer.parseInt(str);
this.den = 1;
} else {
this.num = Integer.parseInt(str.substring(0, i));
this.den = Integer.parseInt(str.substring(i+1));
if (this.den == 0)
}
} else {

this.num = Integer.parseInt(str.substring(0, i)+

str.substring(i+1));
int k = str.length()-i;
this.den = 1;
int n = 1;
while (n++ < k)
this.den *= 10;
}
this.correction();
this.reduce();
}
W przykadzie pokazujemy dziaanie zdefiniowanego konstruktora

tworzcego obiekt na podstawie rónych acuchów znaków.
/** <h3>Zadanie Z20.20</h3>
* Tworzenie konstruktora budujcego obiekt <code>Fraction</code>) na
* podstawie acucha znaków o postaci "4/7", "5", "2.45" lub "2,45".
*/
/** Prezentuje dziaanie konstruktora <code>Fraction(String)</code>).
*/
Fraction a = new Fraction("14/35");
Fraction b = new Fraction("3");
Fraction c = new Fraction("2.45");
Fraction d = new Fraction("2,45");
try {
Fraction e = new Fraction("45;35");
System.out.println("e = "+e);
System.out.println("Niewaciwy parametr - "+e.getMessage());
}
}
}

Liczb zmiennoprzecinkow (typu float lub double) zamieniamy na acuch znaków,
wykorzystujc operator konkatenacji (+), czyli czenia tekstów, oraz konstruktor zbu-
dowany w rozwizaniu zadania 20.20 (new Fraction(""+x)). W tej operacji ""+x liczba
x zamieniana jest na acuch znaków i czona z pustym acuchem.
/** Zwraca obiekt klasy <code>Fraction</code> reprezentujcy okrelon
* warto typu <code>float</code>.
* @param x liczba zmiennoprzecinkowa typu <code>float</code>.
*/
public static Fraction valueOf(float x) {
return new Fraction(""+x);
}

* warto typu <code>double</code>.
* @param x liczba zmiennoprzecinkowa typu <code>double</code>.

*/
public static Fraction valueOf(double x) {
return new Fraction(""+x);
}
Kolejne metody statyczne zwracaj obiekt klasy Fraction odpowiadajcy liczbie ca-
kowitej m (m/1) lub parze liczb cakowitych m i n (m/n).
* warto typu cakowitego <code>int</code>.
* @param m liczba cakowita.
*/
public static Fraction valueOf(int m) {
return new Fraction(m);
}
/** Zwraca obiekt klasy <code>Fraction</code> reprezentujcy uamek

* <code>m/n</code> na podstawie wartoci cakowitych parametrów
* <code>m</code> i <code>n</code>.
* @param m liczba cakowita (licznik uamka),
* @param n liczba cakowita (mianownik uamka).
* @throws IllegalArgumentException, gdy podamy mianownik n = 0.
*/
public static Fraction valueOf(int m, int n) {
if (n != 0)
return new Fraction(m, n);
else
}
Ostatnia z omawianych metod zamienia acuch znaków (o odpowiedniej postaci) na

obiekt Fraction.
/** Zwraca obiekt klasy <code>Fraction</code> na podstawie acucha
* znaków przedstawiajcego uamek dziesitny lub zwyky.
* @param str acuch znaków przedstawiajcy uamek dziesitny "0.12",
* "0,12" lub zwyky "2/3".
* @throws NumberFormatException wystpi wyjtek, gdy parametr
* <code>str</code> nie jest liczb cakowit lub uamkiem dziesitnym
* (zapis w notacji naukowej nie jest interpretowany).
*/
public static Fraction valueOf(String str) {
return new Fraction(str);
}
W przykadzie pokazujemy dziaanie zdefiniowanych metod statycznych tworzcych

obiekt na podstawie parametrów rónych typów.
/** <h3>Zadanie Z20.21</h3>
* Tworzenie metod statycznych <code>valueOf()</code> zwracajcych
* obiekt <code>Fraction</code>, zbudowanych na podstawie parametrów
* rónych typów.
*/
/** Prezentuje dziaanie metod statycznych <code>valueOf()</code>.
*/
System.out.println("a = "+Fraction.valueOf("2.45"));

System.out.println("b = "+Fraction.valueOf("2,45"));
System.out.println("c = "+Fraction.valueOf("15/45"));
System.out.println("d = "+Fraction.valueOf(15, 45));
System.out.println("e = "+Fraction.valueOf(5));
try {
Fraction e = Fraction.valueOf("45;35");
}
try {
Fraction e = Fraction.valueOf("15/0");
} catch (ArithmeticException e) {
}
}
}

Tworzymy obiekt a o wartoci pocztkowej 1 (Fraction a = new Fraction(1)). Za-
1
uwamy, e kolejne wyrazy cigu speniaj zaleno an 1 1 , co moemy za-
an
pisa w postaci instrukcji podstawiania a = a.multInv().add(1). Obliczenia kolejnych
wyrazów wykonamy w ptli.
/** <h3>Zadanie 20.22</h3> */
Fraction a = new Fraction(1);
for(int i = 1; i <= 15; ++i) {
System.out.println("a("+i+") = "+a+" = "+a.doubleValue());
a = a.multInv().add(1);
}
}
}
Maksymalnie moemy obliczy 45 wyrazów cigu.
Moemy zauway , e liczniki kolejnych wyrazów cigu (dotyczy to równie mianow-

ników) s liczbami Fibonacciego. Cig jest zbieny do liczby M (stosunek zotego
podziau odcinka).

Zauwamy, e kady nastpny skadnik sumy 1 1 1 1 1 ... jest 2 razy mniej-
2 4 8 16
szy od poprzedniego. Ustawiamy wartoci pocztkowe a = 1; suma = a; (Fraction
a = new Fraction(1); Fraction suma = new Fraction(a);). W ptli wywietlamy
warto sumy (zmienna suma) i obliczamy nastpny skadnik a = a.div(2) i kolejn
warto sumy suma = suma.add(a).

/** <h3>Zadanie Z20.23</h3> */

Fraction suma = new Fraction(a);
for(int i = 0; i < 30; ++i) {
System.out.println("s("+i+") = "+suma+" = "+
suma.doubleValue());
a = a.div(2);
suma = suma.add(a);
}
}
}
Moemy obliczy co najwyej 30 sum czstkowych tego szeregu. Moemy zauway

zbieno sum czstkowych do liczby 2. Istotnie jest to szereg geometryczny zbieny
1 1
s 2.
1 1
1
2 2
Kady nastpny skadnik sumy 1 1 1 1 1 1 ... jest 2 razy mniejszy od po-

2 4 8 16 32
przedniego (dotyczy bezwzgldnej wartoci skadników szeregu). Ustawiamy war-
toci pocztkowe a = 1; suma = a; (Fraction a = new Fraction(1); Fraction suma
= new Fraction(a);). W ptli wywietlamy warto sumy (zmienna suma) i obliczamy
nastpny skadnik a = a.div(2).addInv() (zmieniamy znak wyrazu na przeciwny)
i kolejn warto sumy suma = suma.add(a).
/** <h3>Zadanie Z20.24</h3> */
Fraction suma = new Fraction(a);
for(int i = 1; i <= 30; ++i) {
System.out.println("s("+i+") = "+suma+" = "+
suma.doubleValue());
a = a.div(2).addInv();
suma = suma.add(a);
}
}
}
Zmian znaków kolejnych skadników moemy równie zrealizowa tak: a = a.div(-2).
Moemy obliczy co najwyej 30 sum czstkowych tego szeregu. Zwrómy uwag na

zbieno sum czstkowych do liczby 2 | 0,66666666666667 . Istotnie jest to szereg
3
geometryczny zbieny s 1 1 2.
§ 1· 3 3
1 ¨ ¸
© 2¹ 2


Definiujemy pomocnicz sta ZERO reprezentujc uamek (obiekt Fraction) o warto-
ci 0. Wspóczynniki równania wczytujemy w postaci tekstu (uywajc skanera input
i metody next()). Konstruktor Fraction zamieniajcy tekst na obiekt rozpoznaje po-
prawnie nastpujce postacie danych: "2", "2/3", "2.4" i "2,4" (równie ze znakiem
— na pocztku acucha).
b
Jeeli wspóczynnik a nie jest zerem, to równanie ma jedno rozwizanie: x
a
(b.div(a).addInv()). Natomiast gdy a jest zerem, to warto wspóczynnika b decy-
duje o tym, czy równanie jest tosamociowe ( b 0 ), czy sprzeczne ( b z 0 ).
/** <h3>Zadanie Z20.25</h3> */
private static final Fraction ZERO = new Fraction();
System.out.println("Podaj wspóczynniki równania ax+b=0");
Fraction a = new Fraction(input.next());
Fraction b = new Fraction(input.next());
if (!a.equals(ZERO))
System.out.println("x = "+b.div(a).addInv());
else if(b.equals(ZERO))
System.out.println("Równanie tosamociowe.");
else
System.out.println("Równanie sprzeczne.");
}
}
Program mona rozbudowa, dodajc powtarzanie oblicze (w ptli) i obsug wyjt-

ków powstaych podczas wprowadzania danych.

Zgodnie z sugesti zawart w podanej wskazówce definiujemy statyczn metod input
Fraction() do wprowadzania uamków w postaci acucha znaków (np. "5", "3/4" lub
"1.5"). Dodatkowo definiujemy sta ZERO typu Fraction reprezentujc uamek 0/1.
ax by e
Do rozwizania mamy ukad dwóch równa z dwiema niewiadomymi: ® .
¯cx dy f
a b
Obliczamy gówny wyznacznik ukadu W ad cb oraz wyznaczniki
c d
e b
Wx ed fb (wspóczynniki przy zmiennej x zastpujemy wyrazami wol-
f d
a e
nymi) i W y af ce (wspóczynniki przy zmiennej y zastpujemy wyrazami
c f

wolnymi). Do obliczania tych wyznaczników budujemy metod det() (ang. deter-

minant — wyznacznik). Jeli wyznacznik gówny W z 0 (!W.equals(ZERO)), to roz-
Wx Wy
wizaniem ukadu jest para liczb x i y . Gdy W Wx Wy 0 , to ukad
W W
jest nieoznaczony (nieskoczenie wiele par liczb x i y spenia równania ukadu). Nato-

miast w przypadku W 0 W xz 0 Wy z 0 ukad jest sprzeczny.
/** <h3>Zadanie Z20.26</h3> */
private static final Fraction ZERO = new Fraction();
private static Fraction inputFraction(String s) {
System.out.print(s);
return Fraction.valueOf(input.next());
}
private static Fraction det(Fraction a, Fraction b, Fraction c,
Fraction d) {
return Fraction.diff(Fraction.prod(a, d), Fraction.prod(c, b));
}
System.out.println("Podaj wspóczynniki równania ax+by=e");
Fraction a = inputFraction("a = ");
Fraction b = inputFraction("b = ");
Fraction e = inputFraction("e = ");
System.out.println("Podaj wspóczynniki równania cx+dy=f");
Fraction c = inputFraction("c = ");
Fraction d = inputFraction("d = ");
Fraction f = inputFraction("f = ");
Fraction W = det(a, b, c, d);
Fraction Wx = det(e, b, f, d);
Fraction Wy = det(a, e, c, f);
if (!W.equals(ZERO)) {
System.out.println("Ukad oznaczony:");
System.out.println("x = "+Wx.div(W));
System.out.println("y = "+Wy.div(W));
} else if(Wx.equals(ZERO) && Wy.equals(ZERO))
System.out.println("Ukad nieoznaczony.");
else
System.out.println("Ukad sprzeczny.");
}
}

1§ a·
Wzór iteracyjny x ¨ x ¸ moemy zapisa w postaci x = x.add(a.div(x)).div(2)
2© x¹
— mnoenie przez ½ zastpujemy dzieleniem przez 2. Iteracj powtarzamy cztero-
krotnie (ptla for), wywietlajc w kadym cyklu warto obliczonego przyblienia.
/** <h3>Zadanie Z20.27</h3> */

Fraction x = new Fraction(1);

System.out.println("x = "+x+" = "+x.doubleValue());
for(int i = 0; i < 4; ++i) {
x = x.add(a.div(x)).div(2);
System.out.println("x = "+x+" = "+x.doubleValue());
}
Fraction y = x.mult(x);
System.out.println("Sprawdzenie x^2 = "+y+" = "+y.doubleValue());
}
}
Otrzymany wynik sprawdzamy, podnoszc x do kwadratu (x.mult(x)).
21. Klasa opakowujca Angle — miara

kta i funkcje trygonometryczne
Zadanie 21.1. Z21_1.java, Angle.java
Objanienie poszczególnych metod zawarte jest w komentarzach dokumentacyjnych.
/** Klasa <code>Angle</code> jest klas opakowujc. Zawiera jedno
* prywatne pole typu <code>double</code>, przechowujce miar kta
* wyraonego w radianach.
*/
public class Angle {
/** Przechowuje miar kta reprezentowanego przez obiekt podan w radianach.
*/
private double x;
/** Tworzy nowy obiekt <code>Angle</code> reprezentujcy kt <code>x rad</code>.

* @param x liczba typu <code>double</code>, miara kta w radianach.
*/
public Angle(double x) {
this.x = x;
}
/** Zwraca warto funkcji sinus kta reprezentowanego przez obiekt.

*/
public double sin() { /* sinus */
return Math.sin(this.x);
}
/** Zwraca warto funkcji cosinus kta reprezentowanego przez obiekt.

*/
public double cos() { /* cosinus */
return Math.cos(this.x);
}
/** Zwraca warto funkcji tangens kta reprezentowanego przez obiekt.

*/
public double tan() { /* tangens */
return Math.tan(this.x);
}

/** Zwraca warto funkcji cotangens kta reprezentowanego przez obiekt.

*/
public double cot() { /* cotangens */
return 1/Math.tan(this.x);
}
/** Zwraca warto funkcji secans kta reprezentowanego przez obiekt.

*/
public double sec() { /* secans */
return 1/Math.cos(this.x);
}
/** Zwraca warto funkcji cosecans kta reprezentowanego przez obiekt.

*/
public double csc() { /* cosecans */
return 1/Math.sin(this.x);
}
}
W podanym przykadzie najpierw tworzymy obiekt alfa reprezentujcy kt o mierze

S
rad 45q
. Nastpnie obliczamy wartoci funkcji trygonometrycznych dla tego kta.
4
Angle alfa = new Angle(Math.PI/4);
System.out.println("sin(alfa) = "+alfa.sin());
System.out.println("cos(alfa) = "+alfa.cos());
System.out.println("tan(alfa) = "+alfa.tan());
System.out.println("cot(alfa) = "+alfa.cot());
System.out.println("sec(alfa) = "+alfa.sec());
System.out.println("csc(alfa) = "+alfa.csc());
}
}

Jedyne pole x obiektu klasy Angle przechowuje miar kta (reprezentowanego przez
obiekt) wyraon w radianach i t wielko zwracamy jako wynik metody radian().
/** Zwraca miar kta reprezentowanego przez obiekt wyraon w radianach.
*/
public double radian() {
return x;
}
Zamiany radianów (x) na stopnie dokonujemy wedug wzoru x 180 (x/Math.PI*180).

S
/** Zwraca miar kta reprezentowanego przez obiekt wyraon w stopniach.
*/
public double degree() {
return x/Math.PI*180;
}
S
Przykadowe obliczenia wykonamy dla któw D rad i E 1 rad .
4

/** Zadanie Z21.2 */

System.out.println("alfa = "+alfa.radian()+" rad");
System.out.println("alfa = "+alfa.degree()+"\u00B0");
Angle beta = new Angle(1.0);
System.out.println("beta = "+beta.radian()+" rad");
System.out.println("beta = "+beta.degree()+"\u00B0");
}
}

Kt peny (jeden peny obrót) dzielimy na 360 czci i 1/360 cz kta penego na-
zywamy stopniem ktowym (1°). Stopie dzielimy na 60 czci — 60 minut ktowych
(1' = 1/60°), z kolei minut dzielimy na 60 czci — 60 sekund ktowych (1" = 1/60'
= 1/3600°). Zamiany radianów (x) na stopnie dokonujemy wedug wzoru x 180 . Na-
S
stpnie otrzymany uamek dziesitny przedstawimy w postaci sumy czci cakowitej
stopni (deg) i dwóch uamków min/60 (min — cakowita liczba minut ktowych, od 0
do 59), sek/3600 (sek — cakowita liczba sekund ktowych, od 0 do 59). Wynik zapi-
sujemy w postaci cigu znaków, np. 45°30'15", co odpowiada liczbie 45 30 15 q
60 3600
(liczba dziesitna 45,50416666666667°).
/** Zwraca acuch znaków (o postaci 45°30'15") przedstawiajcy miar kta
* reprezentowanego przez obiekt wyraon w stopniach, minutach
* i sekundach.
*/
if (this.x == 0)
return "0\u00B0";
double x = this.x/Math.PI*180;
StringBuffer str = new StringBuffer();
if (x < 0) {
str.append("-");
x = -x;
}
int deg = (int)Math.floor(x);
x = (x-Math.floor(x))*60;
int min = (int)Math.floor(x);
x = (x-Math.floor(x))*60;
int sek = (int)Math.floor(x+0.5);
if (sek == 60) {
sek = 0;
++min;
}
if (min == 60) {
min = 0;
++deg;
}
if (deg != 0) {
str.append(deg);
str.append("\u00B0");

}
if (min != 0 || (deg != 0 && sek != 0))
str.append(min).append("\'");
if (sek != 0)
str.append(sek).append("\"");
return str.toString();
}
Zwrómy uwag na warunkowe pomijanie zerowych wartoci stopni, minut lub sekund
w wyjciowym acuchu oraz indywidualne potraktowanie przypadku kta 0 rad =
0°. Jeli w wyniku zaokrglenia otrzymamy 60", to zamieniamy t warto na 1' i do-
dajemy do liczby sekund. Teraz moe zdarzy si, e otrzymamy 60' — zamienimy
to na 1° i skorygujemy liczb stopni. Przykadowe obliczenia wykonamy dla któw
S
D rad i E r1 rad .
4
System.out.println("alfa = "+alfa.radian()+" rad");
System.out.println("alfa = "+alfa);
Angle beta = new Angle(1.0);
System.out.println("beta = "+beta);
beta = new Angle(-1.0);
}
}

Tworzymy trzy kolejne wersje konstruktora Angle. Szczegóowe komentarze doku-
mentacyjne uatwi zrozumienie kodu konstruktorów. Zasad miary stopniowej kta
przybliono w rozwizaniu zadania 21.3.
/** Tworzy nowy obiekt <code>Angle</code> reprezentujcy kt o podanej
* liczbie (cakowitej) stopni z przedziau <0, 360>.
* @param deg miara kta w stopniach, liczba cakowita typu
* <code>int</code> z przedziau <0, 360>.
* @throws IllegalArgumentException, gdy liczba stopni nie mieci si
* w przedziale <0, 360>.
*/
public Angle(int deg) {
if (deg < 0 || deg > 360)
throw new IllegalArgumentException("Liczba stopni poza zakresem.");
x = deg/180.0*Math.PI;
}

* liczbie stopni i minut.
* @param deg liczba stopni, liczba cakowita typu <code>int</code>
* z przedziau <0, 360>,
* @param min liczba minut, liczba cakowita typu <code>int</code>

* z przedziau <0, 60>.

* w przedziale <0, 360>,
* @throws IllegalArgumentException, gdy liczba minut nie mieci si
*/
public Angle(int deg, int min) {
if (deg < 0 || deg > 360)
throw new IllegalArgumentException("Liczba stopni poza zakresem.");
if (min < 0 || min > 60)
throw new IllegalArgumentException("Liczba minut poza zakresem.");
x = (deg+min/60.0)/180.0*Math.PI;
}

* liczbie stopni, minut i sekund.
* @param deg liczba stopni, liczba cakowita typu <code>int</code>
* @param min liczba minut, liczba cakowita typu <code>int</code>
* @param sek liczba sekund, liczba cakowita typu <code>int</code>
* z przedziau <0, 60>.
* @throws IllegalArgumentException, gdy liczba minut nie mieci si
* @throws IllegalArgumentException, gdy liczba sekund nie mieci si
*/
public Angle(int deg, int min, int sek) {
if (deg < 0 || deg > 360)
throw new IllegalArgumentException("Liczba stopni poza
zakresem.");
if (min < 0 || min > 60)
throw new IllegalArgumentException("Liczba minut poza
zakresem.");
if (sek < 0 || sek > 60)
throw new IllegalArgumentException("Liczba sekund poza
zakresem.");
x = (deg+min/60.0+sek/3600.0)/180.0*Math.PI;
}
Obliczenia przykadowe podamy dla kilku któw, np. 15°, 22°30' i 10°30" (zero mi-
nut pominlimy w tym zapisie, ale musimy przekaza do metody warto 0 jako drugi
parametr).
Angle alfa = new Angle(15);
System.out.print("alfa = "+alfa);
System.out.println(" = "+alfa.radian()+" rad");
alfa = new Angle(22, 30);

alfa = new Angle(10, 0, 30);

}
}

Wyznaczamy pooenie znaków stopnia (int p = st.indexOf("\u00B0")), minuty
(int q = st.indexOf("\'")) i sekundy ktowej (int r = st.indexOf("\"")) w cigu
wejciowym. Otrzymamy indeksy wskazujce pooenie tych znaków w acuchu st
lub warto -1, gdy znak nie wystpuje w acuchu. Na tej podstawie moemy wstp-
nie oceni poprawno cigu znaków. Pominiemy t analiz i spróbujemy wyznaczy
liczb stopni, minut i sekund, konwertujc odpowiedni podcig na liczb cakowit.
Czynnoci te ujmujemy w bloku try {...} i przechwytujemy ewentualne wyjtki.
Przyczyn zgoszenia wyjtku moe by brak jednego z symboli (°, ' lub "), co spo-
woduje podanie parametru -1 do metody substring() i wygenerowanie wyjtku java.
lang.StringIndexOutOfBoundsException. Drugim powodem zgoszenia wyjtku moe
by bd w zapisie liczb, np. 2O°30'15" (litera O zamiast cyfry 0) — metoda parseInt()
zgosi wyjtek java.lang.NumberFormatException. Przechwycimy te wyjtki i zastpi-
my je wyjtkiem throw new IllegalArgumentException(st).
Jeli dane wejciowe s poprawne, to moemy zamieni odczytane wartoci deg, min
i sek na miar kta w radianach i podstawi uzyskan warto do pola x obiektu: this.x
= (deg+min/60.0+sek/3600.0)/180.0*Math.PI;.
public Angle(String st) {
int deg, min, sek;
int p = st.indexOf("\u00B0"); // stopie
int q = st.indexOf("\'"); // minuta ktowa
int r = st.indexOf("\""); // sekunda ktowa
try {
deg = Integer.parseInt(st.substring(0, p));
min = Integer.parseInt(st.substring(p+1, q));
sek = Integer.parseInt(st.substring(q+1, r));
} catch (Exception e) {
throw new IllegalArgumentException(st);
}
this.x = (deg+min/60.0+sek/3600.0)/180.0*Math.PI;
}
Ta wersja konstruktora ma co najmniej trzy wady:

1. Nie dopuszcza skróconych postaci danych, np. 25°15' lub 33° (naley
napisa 25°15'0" lub 33°'0'0").
2. Pozwala na dziwne postacie danych, np. 13°–13'17" (ujemna liczba minut)
lub 1°360'99" (zbyt dua liczba minut i sekund) — dane te zostan
zinterpretowane jako 12°47'17" (od 13° odjto 13' i wyszo 12°47')
lub 7°1'39" (360' = 6°, 99" = 1'39" — ogólny bilans si zgadza).
3. le interpretuje ujemn miar kta, np. 22°30'0" = 0.39269908169872414
rad, ale –22°30'0" zostanie zinterpretowane jako –21°30'0" =
–0.3752457891787809 rad.

Spróbujemy te wady wyeliminowa. Zainicjowanie zmiennej sek = 0 i dodanie in-

strukcji warunkowej:
if (r > 0)
pozwoli pomija w cigu danych liczb sekund i symbol sekundy ("). Dopuszczalna
jest posta danych bez sekund, np. 22°30'. Zainicjujmy dodatkowo min = 0 i dodajmy
instrukcje warunkowe:
if (q > 0) {
if (r > 0)
}
Teraz moemy wprowadza dane w postaci 22°15'37", 22°15' lub 22°. Nie mona
pomin minut, gdy wystpuj sekundy — kt 15°30" musimy zapisa jako 15°0'30"
— oraz nie mona pomin stopni — musimy pisa 0°45' zamiast 45'. To ju nie jest
zbyt dua niedogodno.
Liczba minut i liczba sekund powinny przyjmowa wartoci wycznie dodatnie z zakresu
od 0 do 59. Fakt ten sprawdzimy przed przeliczaniem podanej miary kta na radiany:
if ((min < 0) || (min > 59) || (sek < 0) || (sek > 59))
i zgosimy wyjtek, gdy dane nie bd poprawne.
Problem ujemnej miary kta moemy rozwiza tak:

boolean znak =false;
if (deg < 0) {
znak = true;
deg = -deg;
}
if (znak)
this.x = -this.x;
Po tych zmianach kod konstruktora bdzie wyglda nastpujco:

public Angle(String st) {
int deg, min = 0, sek = 0;
int p = st.indexOf("\u00B0"); // stopie
int q = st.indexOf("\'"); // minuta ktowa
int r = st.indexOf("\""); // sekunda ktowa
try {
deg = Integer.parseInt(st.substring(0, p));
if (q > 0) {
if (r > 0)
}
} catch (Exception e) {
}

if ((min < 0) || (min > 59) || (sek < 0) || (sek > 59))
boolean znak =false;
if (deg < 0) {
znak = true;
deg = -deg;
}
if (znak)
this.x = -this.x;
}
Dziaanie konstruktora moemy sprawdzi dla kilku przykadowych acuchów zna-

ków (poprawnych lub bdnych).
String[] angles = { "15°30'27\"", "43°52'", "22°", "-22°30'",
"22°30'", "35'30\"", "1°65'", "abc", "36", "15°-30'" };
Angle alfa = null;
for(String a: angles) {
try {
alfa = new Angle(a);
} catch (IllegalArgumentException e){
System.out.println("Bdne dane: "+a);
}
}
}
}

Funkcje trygonometryczne s funkcjami okresowymi w swojej dziedzinie (zbiorze liczb
rzeczywistych). Funkcje odwrotne moemy okreli w sposób jednoznaczny wycznie
w wybranych przedziaach.
S S
Zwykle przyjmujemy takie dziedziny funkcji odwrotnych: , dla funkcji arcus
2 2
S S
sinus i arcus cosecans, 0, S dla arcus cosinus i arcus secans, §¨ , ·¸ dla funkcji
© 2 2¹
arcus tangens i 0, S dla arcus cotangens.
W obliczeniach wykorzystamy metody z klasy Math: asin() (arcus sinus), acos()

(arcus cosinus) i atan() (arcus tangens) oraz znane waciwoci funkcji trygonome-
trycznych i funkcji do nich odwrotnych.
Funkcje sinus i cosinus przyjmuj wartoci z przedziau 1, 1 , wic argumentem

funkcji odwrotnej mog by wycznie liczby z tego przedziau. Funkcjom arcus sinus
i arcus cosinus odpowiadaj metody:

public void setOfSin(double x) {

if (x >= -1 && x <= 1)
this.x = Math.asin(x);
else
throw new IllegalArgumentException();
}
public void setOfCos(double x) {

if (x >= -1 && x <= 1)
this.x = Math.acos(x);
else
}
Zbiór wartoci funkcji tangens i cotangens jest zbiorem wszystkich liczb rzeczywistych,
czyli argumenty funkcji odwrotnych nie podlegaj ograniczeniom.
public void setOfTan(double x) {
this.x = Math.atan(x);
}
public void setOfCot(double x) {
if (x == 0.0)
this.x = Math.PI/2;
else
this.x = Math.PI+Math.atan(1/x);
}

Funkcje secans i cosecans przyjmuj wartoci ze zbioru f, 1 1, f , wic ar-
gumenty funkcji odwrotnych nie mog nalee do przedziau 1, 1 .
public void setOfSec(double x) {
if (x > -1 && x < 1)
else
this.x = Math.acos(1/x);
}
public void setOfCsc(double x) {

if (x > -1 && x < 1)
else
this.x = Math.asin(1/x);
}
Tworzc program demonstrujcy dziaanie tych metod wybieramy takie wartoci argu-
mentu x, dla których wywietlone wyniki bd atwe do zweryfikowania.
Angle alfa = new Angle(0);;
double x = Math.sqrt(2)/2;
alfa.setOfSin(x);
System.out.printf("sin x = %.6f, ", x);
alfa.setOfCos(-x);

System.out.printf("cos x = %.6f, ", -x);

x = -1;
alfa.setOfTan(x);
System.out.printf("tan x = %.6f, ", x);
alfa.setOfCot(x);
System.out.printf("cot x = %.6f, ", x);
x = 2/Math.sqrt(3);
alfa.setOfSec(x);
System.out.printf("sec x = %.6f, ", x);
alfa.setOfCsc(x);
System.out.printf("csc x = %.6f, ", x);
}
}
S 3 S
We my znan warto sin 60q sin cos cos 30q . Std moemy obliczy
3 2 6
S 2 S
csc 60q csc sec sec 30q . Wykonujc powyszy program, uzyskamy tak
3 3 6
odpowied (dla metod setOfSec() i setOfCsc()), zgodn z oczekiwaniem:
sec x = 1,154701, alfa = 30°
csc x = 1,154701, alfa = 60°

W klasie Math mamy metod atan2() z dwoma parametrami x i y, które s wspórzd-
nymi punktu P w prostoktnym ukadzie wspórzdnych. Wspórzdne tego punktu mo-
emy zapisa w ukadzie biegunowym w postaci r , T , gdzie x r cosT i y r sin T .
Do obliczenia miary kta T suy wanie metoda atan2(). Zwracany kt naley do
przedziau od S do S (miara kta ma znak parametru y). W metodzie korygujemy
ten wynik dla ujemnych wartoci parametru y, dodajc 2S (podwójny okres funkcji
tangens). Ostateczny wynik naley do przedziau od 0 do 2S (od 0° do 360°).
public void setOfPoint(double x, double y) {
if (x == 0 && y == 0)
if (y >= 0)
this.x = Math.atan2(y, x);
else
this.x = 2*Math.PI+Math.atan2(y, x);
}
Przykad dziaania metody setOfPoint():

Angle a = new Angle(0);
double x = 5.0, y = 5.0;

a.setOfPoint(x, y);
System.out.printf("P(%.2f, %.2f), ", x, y);
System.out.println("kt "+a.degree()+"\u00B0");
x = 0.0; y = -5.0;
System.out.printf("P(%.2f, %.2f), ", x, y);
a.setOfPoint(x, y);
System.out.println("kt "+a.degree()+"\u00B0");
}
}

Kod konstruktora bdzie podobny do kodu metody setOfPoint() przedstawionej w roz-
wizaniu zadania 21.7.
public Angle(double x, double y) {
if (x == 0 && y == 0)
if (y >= 0)
this.x = Math.atan2(y, x);
else
this.x = 2*Math.PI+Math.atan2(y, x);
}
Dziaanie konstruktora pokaemy na przykadzie dwóch punktów A(3, 4) i B(-5, 0).

Pomimo cakowitych wartoci wspórzdnych punktów musimy pamita o konieczno-
ci ich przedstawienia w postaci liczb zmiennoprzecinkowych (kompilator na podsta-
wie typów parametrów wywoania konstruktora dobierze waciwy kod konstruktora).
// punkt A(4.0, 3.0)
Angle a = new Angle(4.0, 3.0);
System.out.println("A(4.0, 3.0), kt "+a);
// punkt B(-5.0, 0.0)
Angle b = new Angle(-5.0, 0.0);
System.out.println("B(-5.0, 0.0), kt "+b);
}
}
W aktualnej postaci klasy Angle dla punktu A(4, 3) poprawne bd konstrukcje
Angle a = new Angle(4.0, 3.0), Angle a = new Angle(4.0, 3) i Angle a = new
Angle(4, 3.0), którym odpowiada kt 36°52'12". Natomiast konstrukcja Angle
a = new Angle(4, 3) zbuduje kt 4°3', korzystajc z konstruktora Angle(int, int)
pochodzcego z rozwizania zadania 21.4.

We wszystkich utworzonych metodach statycznych valueOf() na podstawie parame-
trów wywoania utworzymy obiekt klasy Angle i zwrócimy referencj do tego obiek-
tu. W zalenoci od typu i liczby parametrów wejciowych wykorzystamy odpowied-
ni konstruktor.

Metoda zwraca obiekt Angle reprezentujcy kt x radianów.

public static Angle valueOf(double x) {
return new Angle(x);
}
Metoda zwraca obiekt reprezentujcy kt o podanej cakowitej liczbie stopni. Moe-
my zamieni podan liczb stopni deg na radiany i wywoa podstawowy konstruktor
Angle(double), znany z zadania 20.1 (nie ma kontroli zakresu dla zmiennej deg):
public static Angle valueOf(int deg) {
return new Angle(deg/180.0*Math.PI);
}
lub wykorzysta konstruktor z zadania 21.4 (uyty konstruktor sprawdzi, czy zmienna
deg mieci si w zakresie od 0° do 360°):
public static Angle valueOf(int deg) {
return new Angle(deg);
}
Kolejne metody statyczne zbudujemy wedug tego samego schematu:

public static Angle valueOf(int deg, int min) {
return new Angle((deg+min/60.0)/180.0*Math.PI);
}
public static Angle valueOf(int deg, int min, int sek) {
return new Angle((deg+min/60.0+sek/3600.0)/180.0*Math.PI);
}
lub:
public static Angle valueOf(int deg, int min) {
return new Angle(deg, min);
}
public static Angle valueOf(int deg, int min, int sek) {
return new Angle(deg, min, sek);
}
Zamian cigu znaków (postaci xxx°yy'zz") na obiekt klasy Angle moemy zrealizowa,
uywajc metody statycznej wykorzystujcej odpowiedni konstruktor:
public static Angle valueOf(String st) {
return new Angle(st);
}
Poniewa ten konstruktor ma pewne ograniczenia (omówione w rozwizaniu zadania

21.5), moemy spróbowa rozwiza ten problem inaczej. Szczegóow analiz kodu
public static Angle valueOf(String st) {
int deg = 0, min = 0, sek = 0;
int pst = st.indexOf("\u00B0"); // stopie
if (pst == -1) { // nie ma symbolu stopnia
int pmin = st.indexOf("\'"); // minuta ktowa
if (pmin == -1) { // nie ma symbolu minuty
int psek = st.indexOf("\""); // sekunda ktowa

if (psek == -1) { // nie ma symbolu sekundy

} else // tylko sekundy
sek = Integer.parseInt(st.substring(pmin+1, psek));
} else {
min = Integer.parseInt(st.substring(0, pmin));
if (psek != -1)
}
} else { // jest symbol stopnia
deg = Integer.parseInt(st.substring(0, pst));
int pmin = st.indexOf("\'"); // minuta ktowa
if (pmin == -1) {
if (psek != -1)
sek = Integer.parseInt(st.substring(pst+1, psek));
} else {
min = Integer.parseInt(st.substring(pst+1, pmin));
if (psek != -1)
}
}
return new Angle(deg, min, sek);
}
W tej postaci metoda akceptuje nastpujce cigi znaków: 15°, 15°33', 15°33'25",
15°25", 33', 33'25", 25". Za bdne uznaje cigi cyfr bez jakichkolwiek symboli (tyl-
ko liczba bez znaku stopnia, minuty lub sekundy), niebdce liczbami (zawierajce
litery lub inne znaki niedozwolone w zapisie liczb), oraz poprawnie zbudowane cigi
znaków ze znakiem minus na pocztku, np. –22°30'. Ten ostatni przypadek wynika
z ogranicze narzuconych przez uyty konstruktor (liczba stopni od 0 do 360) — ko-
strutor ten jednak sprawdza poprawno liczby minut i sekund, wic nie bdziemy
z niego rezygnowa.
Wprowadzimy poprawki rozszerzajce zakres liczby któw na wartoci ujemne od

–360 do 0. Instrukcj return new Angle(deg, min, sek) zastpimy nastpujcym ci-
giem instrukcji:
boolean minus = false;
if (deg < 0) {
deg = -deg;
minus = true;
}
Angle tmp = new Angle(deg, min, sek);
if (minus)
tmp.x = -tmp.x;
return tmp;
W przypadku bdnych danych metoda rzuca wyjtek IllegalArgumentException, gdy

wejciowy acuch znaków nie odpowiada poprawnej mierze kta, lub NumberFormat
Exception, gdy w wejciowym acuchu (pomidzy symbolami jednostek) znajduje
si niepoprawna posta liczby cakowitej.

Pozostaje jeszcze metoda zwracajca obiekt — kt wyznaczony przez punkt P(x, y),
rodek ukadu wspórzdnych i o OX:
public static Angle valueOf(double x, double y) {
return new Angle(x, y);
}
Dziaanie zdefiniowanych metod sprawdzimy, piszc program:

Angle a;
a = Angle.valueOf(Math.PI/4);
a = Angle.valueOf(25);
a = Angle.valueOf(25, 30);
a = Angle.valueOf(25, 30, 17);
String[] angles = { "33°", "33°52'", "33°52'17\"", "33°30\"",

"52'17\"", "17\"", "1°65'", "2o°13'", "36", "15°-30'" };
Angle alfa = null;
for(String x: angles) {
try {
alfa = Angle.valueOf(x);
} catch (Exception e){
System.out.println("Bdne dane: "+x+" "+e);
}
}
a = Angle.valueOf(0.5, Math.sqrt(3)/2);
}
}

Dodawanie lub odejmowanie obiektów sprowadza si do wykonania odpowiedniego
dziaania na polu x tych obiektów i zwrócenia wyniku.
public Angle add(Angle x) {
return new Angle(this.x+x.x);
}
public Angle sub(Angle x) {
return new Angle(this.x-x.x);
}
Przykad ilustrujcy dziaanie metod:

/** Zadanie Z21.10 */
private static void writeln(String s, Angle x) {
StringBuilder w = new StringBuilder(s);

w.append(" = ").append(x.radian()).append(" rad");

w.append(" = ").append(x.degree()).append("\u00B0");
System.out.println(w);
}
Angle a = new Angle(Math.PI/3);
Angle b = new Angle(Math.PI/6);
writeln("a", a);
writeln("b", b);
writeln("a+b", a.add(b));
writeln("a-b", a.sub(b));
}
}
Zbudowan tu metod writeln() wykorzystamy w kilku kolejnych zadaniach (kopiu-

jc kod metody do kodu rozwizania zadania).

W metodach statycznych sum() i diff() sucych do dodawania i odejmowania obiek-
tów Angle (miar któw) wykorzystamy jeden z tych obiektów, metody add() i sub()
(pokazane w rozwizaniu zadania 21.10) i drugi obiekt podany jako parametr.
public static Angle sum(Angle x, Angle y) {
return x.add(y);
}
public static Angle diff(Angle x, Angle y) {
return x.sub(y);
}
Przykad ilustrujcy dziaanie metod statycznych:

/** Zadanie Z21.11 */
/* Tu wstaw kod metody: writeln */
Angle a = new Angle(Math.PI/2);
Angle b = new Angle(Math.PI/6);
writeln("a", a);
writeln("b", b);
writeln("a+b", Angle.sum(a, b));
writeln("a-b", Angle.diff(a, b));
}
}
Kod metody writeln pokazano w rozwizaniu zadania 21.11.

Mnoenie miary kta (obiektu) przez liczb zmiennoprzecinkow lub cakowit (wie-
lokrotno kta):
public Angle mult(double a) {
return new Angle(a*this.x);
}

public Angle mult(int n) {

return new Angle(n*this.x);
}
Dzielenie miary kta (obiektu) przez liczb:

public Angle div(double a) {
if (a == 0.0)
return new Angle(a*this.x/a);
}
public Angle div(int n) {
if (n == 0)
return new Angle(this.x/n);
}
Przykad dziaania metod mult() i div():

/** Zadanie Z21.12 */
Angle a = new Angle("22°30'");
writeln("a", a);
writeln("2a", a.mult(2));
writeln("4a", a.mult(4));
writeln("1.5a", a.mult(1.5));
writeln("a/2", a.div(2));
}
}
Wyniki bd wywietlanie w postaci 1.5a = 0.5890486225480862 rad = 33.75°. Jeli

chcemy, aby miara stopniowa bya podawana z minutami i sekundami, to naley w ko-
dzie metody writeln() zamieni wiersz:
w.append(" = ").append(x.degree()).append("\u00B0");
na nastpujcy:
w.append(" = ").append(x.toString());

W metodach statycznych prod() i quot() sucych do dzielenia obiektów Angle (miar
któw) przez liczb wywoamy metody mult() i div() (pokazane w rozwizaniu za-
dania 21.12) dla obiektu podanego jako pierwszy parametr. Drugi parametr (liczb)
przekaemy jako parametr do metod mult() i div().
public static Angle prod(Angle x, double y) {
return x.mult(y);
}
public static Angle prod(Angle x, int n) {
return x.mult(n);
}
public static Angle quot(Angle x, double y) {
return x.div(y);

}
public static Angle quot(Angle x, int n) {
return x.div(n);
}
Przykad dziaania metod statycznych prod() i quot():

/** Zadanie Z21.13 */
Angle a = new Angle("11°15'");

writeln("a", a);
writeln("2a", Angle.prod(a, 2));
writeln("4a", Angle.prod(a, 4));
writeln("1.5a", Angle.prod(a, 1.5));
writeln("a/3", Angle.quot(a, 2));
}
}

Definiujemy publiczne i statyczne stae typu obiektowego i nadajemy im odpowied-
nie wartoci. Ze wzgldu na uycie sowa final nie bdziemy mogli tym staym przy-
pisa referencji do innych obiektów, np. Angle RADIAN = new Angle(2.0). Niestety,
moliwo zmiany pola obiektu przy uyciu metod setOfXxx (zob. zadania 21.6 i 21.7)
jest nadal aktualna.
public static final Angle RIGHT_ANGLE = new Angle(Math.PI/2);
public static final Angle STRAIGHT_ANGLE = new Angle(Math.PI);
public static final Angle FULL_ANGLE = new Angle(2*Math.PI);
public static final Angle RADIAN = new Angle(1.0);
public static final Angle DEGREE = new Angle(1);
public static final Angle ARCMINUTE = new Angle(0, 1);
public static final Angle ARCSECOND = new Angle(0, 0, 1);
W przykadzie wywietlimy wartoci miar któw reprezentowanych przez zdefinio-

wane stae.
/** Zadanie Z21.14 */
System.out.println("Kt prosty: "+Angle.RIGHT_ANGLE);
System.out.println("Kt pópeny: "+Angle.STRAIGHT_ANGLE);
System.out.println("Kt peny: "+Angle.FULL_ANGLE);
System.out.println("1 radian: "+Angle.RADIAN);
System.out.println("PI radian: "+Angle.RADIAN.mult(Math.PI));
System.out.println("1 stopie : "+Angle.DEGREE);
System.out.println("1 minuta ktowa: "+Angle.ARCMINUTE);
System.out.println("1 sekunda ktowa: "+Angle.ARCSECOND);
}
}
Zwrómy uwag na moliwo wykonywania oblicze (przy uyciu metod) zwiza-

nych z tymi staymi, np. Angle.RADIAN.mult(Math.PI).


Kty dopeniajce maj wspólne jedno rami i ich suma jest ktem prostym (co mo-
emy wyrazi wzorem D E 90q , czyli E 90q D ).
public static Angle compl(Angle x) {
if (x.x < 0.0 && x.x > RIGHT_ANGLE.x)
return RIGHT_ANGLE.sub(x);
}
Kty przylege maj wspólne jedno rami i ich suma jest ktem pópenym ( D E 180q ,
czyli E 180q D ).
public static Angle suppl(Angle x) {
if (x.x < 0.0 && x.x > STRAIGHT_ANGLE.x)
return STRAIGHT_ANGLE.sub(x);
}
Przykad oblicze z zastosowaniem metod compl() i suppl():

/** Zadanie Z21.15 */
Angle alfa = new Angle(27, 32, 15);
System.out.println("Kt dopeniajcy do alfa: "+
Angle.compl(alfa));
System.out.println("Kt przylegy do alfa: "+Angle.suppl(alfa));
}
}

Do wczytywania danych wykorzystamy obiekt input klasy Scanner. Najpierw spraw-
dzimy, czy w strumieniu danych jest liczba cakowita. Jeli tak, to potraktujemy j ja-
ko miar kta wyraon w stopniach. W przeciwnym razie sprawdzamy, czy nie jest
to liczba zmiennoprzecinkowa. Jeli wprowadzono liczb zmiennoprzecinkow, to
zamieniamy t liczb (traktowan jako miar kta w stopniach) na radiany i wywou-
jemy odpowiedni metod. Natomiast gdy w strumieniu nie ma liczby, to spodziewa-
my si tekstu o postaci 23°35'25". Bdny cig znaków wygeneruje wyjtek zgoszo-
ny przez konstruktor Angle(String).
private static Angle inputAngle(String s) {
System.out.print("Podaj "+s);
if (input.hasNextInt())
return new Angle(input.nextInt());
else if (input.hasNextDouble())
return new Angle(Math.toRadians(input.nextDouble()));
else {
return new Angle(str);
}
}

W trójkcie równoramiennym kty przy podstawie ( E ) maj równe miary. Suma k-
tów wewntrznych trójkta jest ktem pópenym: D 2E 180q , czyli 2E 180q D
180q D
(do oblicze wykorzystamy metod suppl()). Std E , co moemy wyrazi
2
formu Angle beta = Angle.suppl(alfa).div(2). Sprawdzenie oblicze wykonamy,
dodajc miary wszystkich któw trójkta: beta.mult(2).add(alfa).
/** Zadanie Z21.16 */
/* Tu wstaw kod metody inputAngle. */
System.out.println("Obliczanie miar któw w trójkcie
równoramiennym.");
Angle alfa = inputAngle("Kt przy wierzchoku trójkta
równoramiennego,\nalfa = ");
Angle beta = Angle.suppl(alfa).div(2);
System.out.println("Kt przy wierzchoku trójkta
równoramiennego, alfa = "+alfa);
System.out.println("Kt przy podstawie trójkta równoramiennego,
beta = "+beta);
System.out.println("Sprawdzenie - suma któw w trójkcie:"+
beta.mult(2).add(alfa));
}
}

Do wprowadzania danych wykorzystamy metod inputAngle() omówion w rozwi-
zaniu zadania 21.16. Kt lecy naprzeciw podstawy w trójkcie równoramiennym
obliczymy ze wzoru D 180q 2E , gdzie E jest miar kta przylegego do podstawy.
Obliczenie to zrealizujemy w nastpujcy sposób: Angle alfa = Angle.suppl(beta.
mult(2)).
/** Zadanie Z21.17 */
/* Tu wstaw kod metody inputAngle. */
równoramiennym.");
Angle beta = inputAngle("Kt przy podstawie trójkta
równoramiennego,\nalfa = ");
Angle alfa = Angle.suppl(beta.mult(2));
beta = "+beta);
System.out.println("Sprawdzenie - suma któw w trójkcie:
"+beta.mult(2).add(alfa));
}
}
Obliczenia sprawdzimy, dodajc miary któw trójkta: beta.mult(2).add(alfa).


Do wprowadzania danych (dugoci odcinków) wykorzystamy metod inputSide()
(ang. side — bok wielokta).
private static Double inputSide(String s) {
System.out.print("Podaj "+s);
return input.nextDouble();
}
Do wyznaczenia miary kta moemy zastosowa twierdzenie cosinusów (bdce uogól-

nieniem twierdzenia Pitagorasa), wyraone wzorem c 2 a 2 b 2 2ab cos J (kt J
a2 b2 c2
ley naprzeciw boku c). Std obliczymy cos J . Przestawiajc cyklicznie
2ab
b2 c2 a2 c2 a2 b2
dugoci boków, otrzymamy kolejne wzory: cos D i cos E
2bc 2ca
a2 c2 b2
(po uporzdkowaniu cos E ).
2ac
b2 c2 a2
Podstawiajc b = c we wzorze cos D , otrzymamy
2bc
b2 b2 a 2 2b 2 a 2 a2
cosD 1
2bb 2b 2 2b 2
Na podstawie tego wzoru obliczymy:

alfa.setOfCos(1-a*a/(2*b*b));
Kt E moemy obliczy w sposób poznany w rozwizaniu zadania 21.16:

Angle beta = Angle.suppl(alfa).div(2)
lub ponownie stosujc wzór wynikajcy z twierdzenia cosinusów:

c2 a2 b2 b2 a 2 b2 a2 a
cos E
2ca 2ba 2ab 2b
beta.setOfCos(a/2/b);
Kod programu przedstawia si nastpujco:

/** Zadanie Z21.18 */
/* Tu wstaw kod metody inputSide. */
równoramiennym.");
double a = inputSide("Dugo podstawy trójkta
równoramiennego,\na = ");
double b = inputSide("Dugo ramienia trójkta
równoramiennego,\nb = ");


alfa.setOfCos(1-a*a/(2*b*b));
Angle beta = new Angle(0);
beta.setOfCos(a/2/b);
beta = "+beta);
System.out.println("Sprawdzenie - suma któw w trójkcie: "+
}
}

Do wprowadzania danych (dugoci odcinków) wykorzystamy metod inputSide()
przedstawion w rozwizaniu zadania 21.18.
Wysoko opuszczona na podstaw dzieli trójkt równoramienny na dwa przystajce

trójkty prostoktne o przyprostoktnych o dugoci a i h (kty ostre lece naprze-
2
a
ciw tych boków maj miary D i E ). Poniewa tan D 2 a
, to moemy obliczy
2 2 h 2h
miar kta D :
alfa.setOfTan(a/2/h); // poowa kta alfa
alfa = alfa.mult(2); // kt alfa
h 2h
Podobnie obliczymy tan E , wic:
a a
2
beta.setOfTan(2*h/a); // kt beta
Oto kompletny kod programu:

/** Zadanie Z21.19 */
System.out.println("Obliczanie miar któw w trójkcie równoramiennym.");
double a = inputSide("Dugo podstawy trójkta równoramiennego,\na = ");
double h = inputSide("Wysoko trójkta równoramiennego,\nh = ");
beta.setOfTan(2*h/a);
alfa.setOfTan(a/2/h);
alfa = alfa.mult(2);
System.out.println("Kt przy wierzchoku trójkta równoramiennego,
alfa = "+alfa);
beta = "+beta);


}
}

Do wprowadzania danych (dugoci boków trójkta) zastosujemy metod inputSide()
przedstawion w rozwizaniu zadania 21.18. Miary któw obliczymy na podstawie
twierdzenia cosinusów — wzory omówiono w rozwizaniu zadania 21.18.
/** Zadanie Z21.20 */
System.out.println("Obliczanie miar któw w trójkcie o bokach
a, b i c.");
double a = inputSide("Dugo boku trójkta,\na = ");
double b = inputSide("Dugo boku trójkta,\nb = ");
double c = inputSide("Dugo boku trójkta,\nc = ");
alfa.setOfCos((b*b+c*c-a*a)/(2*b*c));
beta.setOfCos((a*a+c*c-b*b)/(2*a*c));
Angle gamma = new Angle(0);
gamma.setOfCos((a*a+b*b-c*c)/(2*a*b));
System.out.println("gamma = "+gamma);
alfa.add(beta).add(gamma));
}
}
Po obliczeniu miar dwóch któw ( D i E ) miar trzeciego kta moemy wyznaczy

ze wzoru J 180q D E :
Angle gamma = Angle.diff(Angle.STRAIGHT_ANGLE, Angle.sum(alfa, beta));
lub:
Angle gamma = Angle.STRAIGHT_ANGLE.sub(alfa.add(beta));
22. Liczby rzymskie i klasa Roman

Analizujc zapis liczb rzymskich (z zakresu od 1 do 3999), moemy zauway, e sym-
bole M (1000), C (100), X (10) i I (1) mog powtarza si do trzech razy obok siebie,
a symbole D (500), L (50) i V (5) wystpuj maksymalnie jeden raz. Ponadto wane
s kombinacje dwóch znaków: CM (900), CD (400), XC (90), XL (40), IX (9) i IV (4).

Kod zamieniajcy liczb n na cig znaków w systemie rzymskim jest obszerny, ale
niezbyt trudny do zrozumienia. Liczb n zmniejszamy kolejno, jeli jest to moliwe,
o wartoci 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1. W zamian za to do wy-
niku dodajemy odpowiednio znaki M, CM, D, CD, C, XC, L, XL, X, IX, V, IV, I. Znaki
M, C, X i I mog wystpi co najwyej trzykrotnie (std uycie ptli while), pozostae
tylko raz. Naley zauway, e wystpienie CM wyklucza pojawienie si D, CD i C
w dalszej czci cigu znaków, podobnie D wyklucza CD i C oraz CD wyklucza C
(stosujemy zagniedone instrukcje warunkowe). Podobne reguy obowizuj dla ze-
stawu znaków XC, L, XL i X oraz IX, V, IV i I.
StringBuilder tmp = new StringBuilder("");
/* Znaki rzymskie M, CM, D i CD - liczby 1000, 900, 500, 400 */
while (n >= 1000) {
n -= 1000;
tmp.append("M");
}
if (n >= 900) {
n -= 900;
tmp.append("CM");
} else if (n >= 500) {
n -= 500;
tmp.append("D");
} else if (n >= 400) {
n -= 400;
tmp.append("CD");
}
/* Znaki rzymskie C, XC, L, XL - liczby 100, 90, 50, 40 */

while (n >= 100) {
n -= 100;
tmp.append("C");
}
if (n >= 90) {
n -= 90;
tmp.append("XC");
} else if (n >= 50) {
n -= 50;
tmp.append("L");
} else if (n >= 40) {
n -= 40;
tmp.append("XL");
}
/* Znaki rzymskie X, IX, V, IV - liczby 10, 9, 5, 4 */

while (n >= 10) {
n -= 10;
tmp.append("X");
}
if (n >= 9) {
n -= 9;
tmp.append("IX");
} else if (n >= 5) {
n -= 5;
tmp.append("V");
} else if (n >= 4) {
n -= 4;

tmp.append("IV");
}
/* Znak I - liczba 1 */
while (n >= 1) {
n -= 1;
tmp.append("I");
}
Obiekt tmp zawiera pocztkow warto liczby n w zapisie rzymskim (aktualna war-
to n jest zerem).
Pobieran z klawiatury warto liczby bdziemy przechowywali w zmiennej liczba

(typu int). W programie utworzymy ptl ze sprawdzaniem warunku na kocu — dzia-
anie ptli przerwiemy, gdy zmienna liczba bdzie miaa warto 0. W ptli wczytu-
jemy liczb cakowit i sprawdzamy, czy jej warto mieci si w zakresie od 1 do
3999. Jeli liczba jest poza tym zakresem, wywietlamy stosowny komunikat ("Liczba
poza zakresem.") i przechodzimy (instrukcj continue) do sprawdzania warunku po-
wtarzania ptli, pomijajc kod zamiany n na liczb w systemie rzymskim.
System.out.println("Rzymski sposób zapisu liczb od 1 do 3999");
int liczba;
do {
System.out.print("Podaj liczb (0 - koniec oblicze ), n = ");
liczba = input.nextInt();
if (liczba < 1 || liczba > 3999) {
System.out.println("Liczba poza zakresem.");
continue;
}
int n = liczba;
/* Tu wstaw kod zamiany n na liczb w systemie rzymskim */
System.out.println(liczba+" = "+tmp.toString());
} while (liczba !=0);
}
}
Stosujc dwie tablice z wartociami wybranych liczb rzymskich i odpowiadajcych

im wartoci dziesitnych:
private static final String[] rz = {"M", "CM", "D", "CD", "C", "XC", "L", "XL",
"X", "IX", "V", "IV", "I"};
private static final int[] ar = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5,
4, 1};
moemy uproci kodowanie liczb w systemie rzymskim.

for(int i = 0; i<13; ++i) {
while (n >= ar[i]) {

n -= ar[i];
tmp.append(rz[i]);
}
}
Na pocztku warto zmiennej n jest równa konwertowanej liczbie i mieci si w za-
kresie od 1 do 3999. Elementy w obu tablicach s uporzdkowane od wartoci najwik-
szej (1000) do najmniejszej (1). Bierzemy kolejne wartoci i dopóki liczba jest wiksza
od tej wartoci, dopóty do cigu znaków rzymskich dodajemy odpowiedni symbol,
a liczb zmniejszamy o t warto. Po dojciu do koca tablicy mamy poprawnie za-
kodowan liczb w systemie rzymskim.

Oprócz tablic (wprowadzonych w rozwizaniu zadania 22.1):
private static final String[] rz = {"M", "CM", "D", "CD", "C", "XC", "L", "XL",
"X", "IX", "V", "IV", "I"};
private static final int[] ar = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5,
4, 1};
dodamy tablic lp zawierajc maksymaln liczb powtórze symboli z tablicy rz:

private static final int[] lp = {3, 1, 1, 1, 3, 1, 1, 1, 3, 1, 1, 1, 3};
oraz tablic err z niedozwolonymi kombinacjami symboli:

private static final String[] err = {"CMD", "CMC", "XCL", "XCX", "IXV", "IXI",
"DCD", "CDC", "LXL", "XLX", "VIV", "IVI"};
Cig symboli CMD oznaczaby liczb 900+500 = 1400, któr poprawnie zapisujemy
w postaci MCD (1000+400). Kolejny cig CMC mona interpretowa jako 900+100 =
1000, ale to nie ma sensu, bo 1000 zapisujemy jednym znakiem M. Podobnie jest z po-
zostaymi cigami uznanymi za bdne i zapisanymi w tablicy err.
Najpierw sprawdzimy, czy podany cig znaków (roman) nie zawiera niedozwolonych
cigów zapisanych w tablicy err. Przegldajc tablic bdnych sekwencji znaków,
sprawdzamy, czy wystpuj w acuchu roman. Jeli tak si zdarzy, to metoda indexOf()
zwróci warto -1 i zostanie zgoszony wyjtek.
for (String x: err)
if (roman.indexOf(x) != -1)
throw new ArithmeticException("Niewaciwy cig znaków: "+x+
" w "+roman);
Jeli cig wejciowy nie zawiera niedozwolonych sekwencji, moemy ustali poczt-
kow warto wyniku (tmp) i zainicjowa indeks analizowanego znaku rzymskiego
(pobieranego z tablicy rz).
int tmp = 0;
int index = 0; // indeks analizowanego znaku rzymskiego
Przegldamy w ptli (for (int i = 0; i < 13; i++)) tablic rz.

Zerujemy (int powt = 0) licznik powtórze symbolu rz[i]. W ptli (while) spraw-
dzamy, ile razy symbol rzymski (rz[i]) pojawia si w cigu znaków roman. Kada
pozytywna odpowied powoduje zwikszenie zmiennej tmp (tmp += ar[i]) o warto
(ar[i]) odpowiadajc sprawdzanemu symbolowi (rz[i]), zwikszenie indeksu o roz-
miar symbolu (index += rz[i].length()) i zwikszenie licznika powtórze (++powt).
Badany na pocztku ptli while warunek roman.startsWith(rz[i], index) sprawdza,
czy w acuchu roman na pozycji o indeksie index rozpoczyna si cig znaków rz[i]
— wynik jest wartoci logiczn (true lub false). Po wyjciu z ptli while spraw-
dzamy, czy symbol rz[i] nie wystpi zbyt wiele razy (if (powt > lp[i])...). Jeli
liczba powtórze przekracza dozwolon liczb (zapisan w tabeli lp), to zgaszany
jest wyjtek.
Po wyjciu z ptli for dokonujemy jeszcze jednego sprawdzenia:

if (index != roman.length())
throw new ArithmeticException("Niewaciwa liczba rzymska: "+roman);
Rozbieno pomidzy wartoci zmiennej index i dugoci acucha roman wiad-

czy o niepoprawnej budowie liczby rzymskiej.
Poniszy kod zamienia acuch znaków roman na liczb tmp lub zgasza wyjtek:
for (String x: err)
if (roman.indexOf(x) != -1)
throw new ArithmeticException("Niewaciwy cig znaków: "+
x+" w "+roman);
int tmp = 0; // warto pocztkowa wyniku
int index = 0; // indeks analizowanego znaku
for (int i = 0; i < 13; i++) {
int powt = 0;
while (roman.startsWith(rz[i], index)) {
tmp += ar[i];
index += rz[i].length();
++powt;
}
if (powt > lp[i])
throw new ArithmeticException("Za duo znaków: "+rz[i]+" w "+roman);
}
if (index != roman.length())
throw new ArithmeticException("Niewaciwa liczba rzymska: "+roman);
W gównej ptli programu (do {...} while(true);) wczytujemy liczb rzymsk, do-
konujemy jej zamiany na liczb dziesitn i wywietlamy wynik. Ptla zostanie prze-
rwana (wiadomie przez uytkownika) po wprowadzeniu pustego acucha znaków
lub w wyniku bdnej postaci liczby (wystpi wyjtek). Ewentualne przechwycenie
i obsuenie wyjtku pozostawimy Czytelnikowi.
/* Tu wstaw cztery tablice: rz, ar, lp i err. */


System.out.println("Odczytywanie liczb rzymskich");

String roman;
do {
System.out.print("Podaj liczb rzymsk: ");
roman = input.next();
if (roman.equals(""))
break;
/* Tu wstaw kod zamiany liczb rzymskich na dziesitne. */
System.out.println(roman+" = "+tmp);
} while (true);
}
}

Na podstawie rozwizania zadania 22.1 moemy zbudowa nastpujc metod:
private static String decToRoman(int n) {
if (n < 1 || n > 3999)
throw new ArithmeticException("Liczba poza zakresem: "+n);
String[] rz = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX",
"V", "IV", "I"};
int[] ar = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
for(int i = 0; i<13; ++i) {
while (n >= ar[i]) {
n -= ar[i];
tmp.append(rz[i]);
}
}
return tmp.toString();
}
Tablice niezbdne do konwersji liczb dziesitnych na rzymskie zostay umieszczone

w kodzie metody. Zatem kod metody jest kompletny i moe w tej postaci by przeno-
szony do dowolnej aplikacji. Dziaanie metody pokaemy dla kilkunastu liczb wybra-
nych w sposób losowy.
/* Tu wstaw kod metody decToRoman() */

System.out.println("Zapis liczb w systemie rzymskim");
for(int i = 0; i < 15; ++i) {
int n = (int)(1+3999*Math.random());
System.out.println(n+" = "+decToRoman(n));
}
}
}
Definicje tablic rz i ar moemy umieci w kodzie klasy (tak jak w zadaniu 21.1 lub
21.2) i usun z kodu metody decToRoman().


Utworzymy klas RN z dwoma polami: r typu String (do przechowywania symboli
rzymskich) oraz d typu int (do przechowywania wartoci dziesitnej symbolu). Klas
definiujemy z modyfikatorem final — po tej klasie nie bdzie mona dziedziczy.
Pola klasy definiujemy z modyfikatorami protected i final (do pól bdzie dostp, ale
po utworzeniu obiektu nie bdzie mona zmieni wartoci pól). Konstruktor deklaru-
jemy jako metod prywatn. Poza klas RN konstruktor nie bdzie dostpny. Wykorzy-
stamy go tylko do utworzenia trzynastoelementowej tablicy rn (statycznej i finalnej),
czyli jedynego elementu udostpnionego przez zdefiniowan klas.
final class RN {
protected final String r;
protected final int d;
private RN(String r, int d) {
this.r = r; this.d = d;
};
static final RN[] rn = {new RN("M", 1000), new RN("CM", 900),
new RN("D", 500), new RN("CD", 400), new RN("C", 100),
new RN("XC", 90), new RN("L", 50), new RN("XL", 40),
new RN("X", 10), new RN("IX", 9), new RN("V", 5),
new RN("IV", 4), new RN("I", 1)};
}
Z tej tablicy moe korzysta metoda decToRoman():

private static String decToRoman(int n) {
for(int i = 0; i<13; ++i) {
while (n >= RN.rn[i].d) {
n -= RN.rn[i].d;
tmp.append(RN.rn[i].r);
}
}
}
Pokazujc dziaanie metody, wywietlimy potgi liczby 2 zapisane w systemie rzymskim.

/* Tu wstaw kod klasy RN.*/
/* Tu wstaw kod metody decToRoman(). */

System.out.println("Potgi liczby 2 w systemie rzymskim");
int i = 0, n = 1;
while (i < 13) {
System.out.println("2^"+i+" = "+decToRoman(n));
++i;
n *= 2;
}
}
}

Kody obu klas (RN i Z22_4) znajdoway si w jednym pliku: Z22_4.java. Po kompi-
lacji otrzymujemy dwa pliki: RN.class i Z22_4.class — kada skompilowana klasa
znajduje si w odrbnym pliku.

Wykorzystajmy klas RN i metod decToRoman() z rozwizania zadania 22.4. Na pod-
stawie rozwizania zadania 22.2 moemy zbudowa metod:
private static int romanToDec(String s) {
int tmp = 0;
for (int i = 0; i < 13; i++)
while (s.startsWith(RS.rn[i].r, index)) {
tmp += RS.rn[i].d;
index += RS.rn[i].r.length();
}
if (!s.equals(decToRoman(tmp)) || tmp > 3999)
throw new ArithmeticException("Niewaciwa liczba rzymska: "+s);
return tmp;
}
Dziaanie metody sprawdzimy dla kilku liczb rzymskich zapisanych w tablicy.

/* Tu wstaw kod klasy RN lub w biecym folderze umie skompilowany

plik klasy (RN.class). */
/* Tu wstaw kod metody decToRoman(). */

/* Tu wstaw kod metody romanToDec(). */

System.out.println("Odczytywanie liczb w systemie rzymskim");
String[] test = {"XXVII", "CCXLV", "III", "MMMCMXCIX", "MXXIV"};
for(String r: test)
System.out.println(r+" = "+romanToDec(r));
}
}
Zadanie 22.6. Z22_6.java, Roman.java

Na pocztek tworzymy klas z jednym prywatnym polem (int n;) i publicznym kon-
struktorem z jednym parametrem — liczb cakowit. Jeli podana liczba nie mieci
si w zakresie od 1 do 3999, to wygenerowany zostanie wyjtek.
public class Roman {
private int n;
public Roman(int n) {
if(n < 1 || n > 3999)
throw new ArithmeticException("Liczba poza zakresem");

else
this.n = n;
}
}
Klas moemy rozszerzy o kolejne metody — metod zwracajc warto dziesitn

liczby naturalnej przechowywanej w obiekcie:
public int intValue() {
return n;
}
oraz metod statyczn zwracajc obiekt klasy Roman odpowiadajcy podanej liczbie
cakowitej:
public static Roman valueOf(int n) {
return new Roman(n);
}
Z klasy w tej postaci jest jeszcze niewielki poytek. Do jej kodu dodamy wewntrzn
klas RN (z rozwizania zadania 22.4), dopisujc w nagówku modyfikator static:
private static final class RN {
final String r;
final int d;
private RN(String r, int d) {
this.r = r; this.d = d;
};
static final RN[] rn = {new RN("M", 1000), new RN("CM", 900),
new RN("D", 500), new RN("CD", 400), new RN("C", 100),
new RN("XC", 90), new RN("L", 50), new RN("XL", 40),
new RN("X", 10), new RN("IX", 9), new RN("V", 5),
new RN("IV", 4), new RN("I", 1)};
}
oraz metody statyczne korzystajce z tablicy rn zdefiniowanej w tej klasie (tym razem
zadeklarowane jako publiczne): decToRoman() (zadanie 22.4) i romanToDec() (zada-
nie 22.5).
public static String decToRoman(int n) {
for(int i = 0; i<13; ++i) {
while (n >= RN.rn[i].d) {
n -= RN.rn[i].d;
tmp.append(RN.rn[i].r);
}
}
}
public static int romanToDec(String s) {

int tmp = 0;
for (int i = 0; i < 13; i++)
while (s.startsWith(RN.rn[i].r, index)) {
tmp += RN.rn[i].d;

index += RN.rn[i].r.length();
}
if (!s.equals(decToRoman(tmp)) || tmp > 3999)
throw new ArithmeticException("Niewaciwa liczba rzymska: "
+s);
return tmp;
}
Korzystajc z metody decToRoman(), moemy przesoni metod toString() dziedzi-

czon z klasy Object:
return decToRoman(this.n);
}
Natomiast metod romanToDec() moemy zastosowa do zbudowania konstruktora

tworzcego nowy obiekt na podstawie liczby zapisanej w systemie rzymskim lub sta-
tycznej metody nadajcej obiektowi now warto utworzon na podstawie acucha
znaków.
public Roman(String s) {
this.n = romanToDec(s);;
}
public static Roman valueOf(String s) {

return new Roman(s);
}
Teraz moemy uzna klas Roman za kompletn.
Klasa RN jest klas wewntrzn klasy Roman i jej kod ródowy znajduje si w pliku
Roman.java. Po kompilacji otrzymujemy dwa pliki: Roman.class i Roman$RN.class
— kada skompilowana klasa znajduje si w odrbnym pliku. Klasa RN jest dostp-
na jednak wycznie wewntrz klasy Roman.
Przykad wykorzystania obiektów i metod klasy Roman:

Roman a = new Roman(2012);
System.out.println(a.intValue()+" = "+a);
Roman b = Roman.valueOf("XLIV");
System.out.println(b.intValue()+" = "+b);
a = Roman.valueOf(137);
System.out.println(a.intValue()+" = "+a);
Roman c = new Roman("MMMCMXCIX");
System.out.println(c.intValue()+" = "+c);
System.out.println("175 = "+Roman.decToRoman(175));
System.out.println("XXXIV = "+Roman.romanToDec("XXXIV"));
System.out.println("MMMM = "+Roman.romanToDec("MMMM"));
}
}


Ustalimy liczb pyta (int pytania = 10) i maksymaln warto wylosowanej liczby
(int zakres = 50). Na podstawie tych parametrów utworzymy tablic a, wypenion
wylosowanymi i niepowtarzajcymi si wartociami. W tym celu wykorzystamy me-
tod rndUniqueArray() z klasy MyRandomArray. Wystarczy, e do biecego folderu
skopiujemy skompilowany kod klasy (MyRandomArray.class) lub kod ródowy kla-
sy (MyRandomArray.java). Nastpnie wartoci elementów tablicy zwikszymy o 1;
w ten sposób otrzymamy liczby z zakresu od 1 do 50 (zmienna zakres).
Ustalimy liczb punktów (int pkt = 0). W ptli zamieniamy liczb z tablicy na obiekt
klasy Roman. Wypisujemy liczb rzymsk w konsoli. Uytkownik podaje warto dzie-
sitn tej liczby. Jeli podana warto jest równa liczbie rzymskiej (n == roman.int
Value()), powikszamy liczb punktów (++pkt). Po zakoczeniu ptli wywietlimy
wynik — sum zdobytych punktów.
int pytania = 10; // 10 pyta
int zakres = 50; // najwiksza liczba 50
int[] a = MyRandomArray.rndUniqueArray(pytania, zakres);
MyRandomArray.addToArray(a, 1);
int pkt = 0;
Roman roman;
for(int i = 0; i < pytania; ++i) {
roman = Roman.valueOf(a[i]);
System.out.print(roman+" = ");
if (n == roman.intValue()) ++pkt;
}
System.out.println("Wynik: "+pkt+" z "+pytania+".");
}
}

Rozwizanie jest podobne do rozwizania zadania 22.7. Rónica polega na odwróce-
niu czynnoci w gównej ptli programu. Wywietlamy warto dziesitn liczby,
a uytkownik wprowadza rzymsk posta tej liczby. Do porównania acuchów zna-
ków — wprowadzonego przez uytkownika (s) i przedstawiajcego liczb rzymsk
(roman.toString()) — uyjemy metody equals() z klasy String.
int pkt = 0;
Roman roman;
for(int i = 0; i < pytania; ++i) {
roman = Roman.valueOf(a[i]);
System.out.print(a[i]+" = ");
if (s.equals(roman.toString())) ++pkt;
}
System.out.println("Wynik: "+pkt+" z 10.");

23. Trójmian kwadratowy

i klasa QuadratPoly
Zadanie 23.1. Z23_1.java, QuadratPoly.java
W klasie definiujemy trzy prywatne pola a, b i c typu int, odpowiadajce tradycyjne-
mu zapisowi postaci trójmianu kwadratowego.
Konstruktor z trzema parametrami (a, b i c) pozwala na tworzenie obiektów klasy

QuadratPoly. Podanie wartoci 0 jako pierwszego parametru spowoduje zgoszenie
wyjtku. Metody value() obliczajce warto trójmianu dla podanego argumentu de-
finiujemy w dwóch wariantach — dla argumentu cakowitego n lub dla zmiennoprze-
cinkowego argumentu x. Warto trójmianu liczymy wedug wzoru:
ax 2 bx c a ( x b) x c
(tzw. schemat Hornera umoliwiajcy szybkie obliczanie wartoci wielomianu dowol-
nego stopnia).
public class QuadratPoly {
private int a, b, c;
public QuadratPoly() {}
public QuadratPoly(int a, int b, int c) {
if (a == 0)
throw new ArithmeticException("Niedozwolony parametr
a = 0!");
this.a = a;
this.b = b;
this.c = c;
}
public int value(int n) {
return (a*n+b)*n+c;
}
public double value(double x) {
return (a*x+b)*x+c;
}
}
W przykadzie demonstrujemy obliczanie wartoci trójmianu kwadratowego 2 x 2 3x 1

dla cakowitych argumentów z przedziau 5, 5 oraz prób skonstruowania obiektu
QuadratPoly z niedozwolon wartoci parametru (a = 0).
QuadratPoly w = new QuadratPoly(2, -3, 1);
for(int i = -5; i < 6; ++i)
System.out.printf("w(%d) = %d\n", i, w.value(i));
QuadratPoly v = new QuadratPoly(0, 3, -1);
}
}


Wanym pojciem charakteryzujcym trójmian kwadratowy jest wyrónik ' b 2 4ac .
Aby tej wielkoci nie oblicza wielokrotnie, dodamy do klasy pole:
private int delta;
W konstruktorze obliczymy warto wyrónika i przechowamy j w polu delta.

this.delta = b*b-4*a*c;
Tworzymy publiczn metod zwracajc warto wyrónika (getDelta()).

public int getDelta() {
return delta;
}
W przykadzie utworzymy dwa obiekty QuadratPoly (trójmiany kwadratowe) i obli-

czymy ich wyróniki.
QuadratPoly w1 = new QuadratPoly(2, -3, 1);
System.out.println("Delta: "+w1.getDelta());
QuadratPoly w2 = new QuadratPoly(1, 2, 1);
System.out.println("Delta: "+w2.getDelta());
}
}

Metoda toString() zdefiniowana w klasie QuadratPoly przesoni metod dziedziczo-
n z klasy Object. Zwrócony acuch znaków bdzie znanym z matematyki zapisem
trójmianu.
Wspóczynnik a jest róny od zera, dla a = –1 na pocztku acucha umiecimy tylko

znak liczby (–), dla a = 1 wspóczynnik pominiemy, w pozostaych przypadkach wy-
pisujemy warto wspóczynnika. Symbol x 2 w trybie tekstowym zapiszemy w sposób
umowny: x^2.
Drugi czon trójmianu wypisujemy tylko wtedy, gdy wspóczynnik b nie jest zerem.
Dla wartoci dodatnich wypisujemy znak +, warto wspóczynnika b i symbol x; dla
wartoci ujemnych wypisujemy tylko warto wspóczynnika b i symbol x. Podobnie
postpujemy w przypadku wspóczynnika c.
StringBuilder wz = new StringBuilder();
if (a == -1)
wz.append("-");
else if (a != 1)
wz.append(a);
wz.append("x^2");

if (b == -1)
wz.append("-x");
else if (b == 1)
wz.append("+x");
else if (b > 1)
wz.append("+").append(b).append("x");
else if (b < -1)
wz.append(b).append("x");
if (c > 0)
wz.append("+").append(c);
else if (c < 0)
wz.append(c);
return wz.toString();
}
Dziaanie metody sprawdzimy dla dwóch przykadowych trójmianów. Zauwamy,

e w wyraeniu "w(x) = "+w lub v+" = 0" metoda jest wywoywana przez operator
konkatenacji (+). Nie musimy w tej sytuacji jawnie wywoywa metody (np. "w(x) =
"+w.toString()).
System.out.println("w(x) = "+w);
QuadratPoly v = new QuadratPoly(1, 0, -4);
System.out.println(v+" = 0");
}
}

Przydatn informacj jest znak wyrónika trójmianu kwadratowego. Do klasy doda-
my metod zwracajc znak wyrónika; zrobimy to wedug nastpujcego schematu:
–1 — delta ujemna, 0 — delta równa zero, 1 — delta dodatnia.
public int sgnDelta() {
return (delta > 0)?1:(delta < 0)?-1:0;
}
Wspóczynniki wielomianu wprowadzimy z klawiatury, korzystajc z obiektu input

klasy Scanner. Zwrómy uwag na sposób wczytywania wspóczynnika a. Wczytywa-
nie powtarzamy do skutku, a podana warto bdzie róna od zera. Nie jest to potrzeb-
ne w przypadku wczytywania wspóczynników b i c.
Jeli wyrónik (delta) jest ujemny, to równanie nie ma pierwiastków rzeczywistych

(0 pierwiastków). Gdy wyrónik jest równy zero, mamy jeden pierwiastek rzeczywi-
sty (podwójny). Dla wyrónika dodatniego s dwa róne pierwiastki rzeczywiste.
Moemy zauway zwizek pomidzy liczb pierwiastków i znakiem wyrónika wy-

raonym w postaci liczby (liczba pierwiastków jest równa 1+w.sgnDelta()).

System.out.println("Podaj wspóczynniki trójmianu kwadratowego
ax^2+bx+c");
int a, b, c;
do {
a = input.nextInt();
} while (a == 0);
b = input.nextInt();
c = input.nextInt();
QuadratPoly w = new QuadratPoly(a, b, c);
System.out.println("Trójmian kwadratowy: "+w);
System.out.println("Liczba rzeczywistych pierwiastków: "+
(1+w.sgnDelta()));
}
}
Odpowied moemy sformuowa, uywajc instrukcji warunkowej:

System.out.print("Trójmian kwadratowy: "+w+" ");
int sgn = w.sgnDelta();
if (sgn == 1)
System.out.println("ma dwa róne pierwiastki rzeczywiste.");
else if (sgn == 0)
System.out.println("ma jeden pierwiastek rzeczywisty
dwukrotny.");
else
System.out.println("nie ma pierwiastków rzeczywistych.");
lub wyraenia warunkowego:

int znak = w.sgnDelta();
System.out.println("Liczba rzeczywistych pierwiastków: "+
(znak == -1)?0:(znak == 0)?:1:2);
Kolejn moliwo utworzenia odpowiedzi stwarza nam instrukcja wyboru.

String s = "";
switch (w.sgnDelta()) {
case 1:
s = "ma dwa róne pierwiastki rzeczywiste.";
break;
case 0:
s = "ma jeden pierwiastek rzeczywisty dwukrotny.";
break;
case -1:
s = "nie ma pierwiastków rzeczywistych.";
break;
}
System.out.print("Trójmian kwadratowy: "+w+" "+s);


b ' b '
Na podstawie wzorów x1 i x2 budujemy dwie metody (getX1()
2a 2a
i getX2()) zwracajce wartoci rzeczywistych pierwiastków trójmianu kwadratowego,
o ile takie wartoci istniej ( ' t 0 ). Jeli wyrónik trójmianu jest ujemny ( ' 0 ), to
metoda Math.sqrt(delta) zwraca warto NaN. Tak sam warto zwracaj metody
getX1() i getX2().
public double getX1() {
return (-b-Math.sqrt(delta))/(2*a);
}
public double getX2() {

return (-b+Math.sqrt(delta))/(2*a);
}
Wspóczynniki równania wprowadzimy, stosujc obiekt input klasy Scanner. Wpro-

wadzanie danych mona dodatkowo zabezpieczy przed bdami, przechwytujc i ob-
sugujc wyjtki pochodzce od metody nextInt(). Pozostawimy to do decyzji Czy-
telnika. W rozwizaniu zadania wykorzystano metod sgnDelta() i instrukcj wyboru
switch (zob. objanienia z rozwizania zadania 23.4).
System.out.println("Podaj wspóczynniki równania ax^2+bx+c = 0");
int a, b, c;
do {
} while (a == 0);
System.out.print("Równanie "+w+" = 0 ");
case 1:
System.out.println("ma dwa pierwiastki rzeczywiste:");
System.out.println("x = "+w.getX1());
break;
case 0:
System.out.println("ma pierwiastek rzeczywisty dwukrotny:");
break;
case -1:
System.out.println("nie ma pierwiastków rzeczywistych.");
break;
}
}
}


Wykresem trójmianu kwadratowego ax 2 bx c, a z 0 jest parabola o wierzchoku
§ b '·
¨ , ¸ . Metoda getP() zwraca pierwsz wspórzdn (x) wierzchoka tej para-
© 2a 4a ¹
boli, a metoda getQ() — drug wspórzdn (y).
public double getP() {
return -(double)b/(2*a);
}
public double getQ() {

return -(double)delta/(4*a);
}
Pierwsze z powyszych zda, opisujcych to rozwizanie, formuujemy w programie

przykadowym dla konkretnego trójmianu, wykorzystujc informacje zwrócone przez
metody toString(), getP() i getQ().
StringBuilder s = new StringBuilder("Wykresem trójmianu ");
s.append(w).append(" jest parabola o wierzchoku (");
s.append(w.getP()).append(", ").append(w.getQ()).append(").");
}
}

Uytkownik nie ma dostpu do prywatnych pól klasy. W wielu sytuacjach potrzebuje
wiedzie, jaki znak ma wspóczynnik a trójmianu. Metoda isAPositive() zwraca war-
to true, gdy wspóczynnik a jest dodatni, i warto false w przeciwnym wypadku
(warto wyraenia logicznego a > 0).
public boolean isAPositive() {
return a > 0;
}
Jeli a jest dodatnie, to zbiorem wartoci trójmianu ax 2 bx c jest przedzia q, f ,

'
a dla ujemnego wspóczynnika a — przedzia f, q , gdzie q .
4a
QuadratPoly w = new QuadratPoly(-2, -3, 1);
StringBuilder s = new StringBuilder();
if (w.isAPositive())
s.append("<").append(w.getQ()).append(", +oo)");
else

s.append("(-oo, ").append(w.getQ()).append(">");
System.out.println("Zbiór wartoci trójmianu "+w+": "+s);
}
}

Wprowadzenie danych zorganizujemy tak jak w rozwizaniu zadania 23.4. Jeli a
b
jest dodatnie, to trójmian ax 2 bx c osiga w punkcie x warto minimaln
2a
' '
ymin , a dla ujemnego wspóczynnika a — warto maksymaln ymax .
4a 4a
b
Budujc odpowied , uyjemy wartoci zwracanych przez metody getP() ( )
2a
'
i getQ() ( ) oraz wyraenia warunkowego zwracajcego odpowiednie sowo (za-
4a
lene od znaku parametru a): (w.isAPositive())?"minimaln":"maksymaln". Odpo-
wied budujemy z wykorzystaniem obiektu s i metod klasy StringBuilder.
StringBuilder s = new StringBuilder("Trójmian kwadratowy ");
s.append(w).append(" osiga dla x = ").append(w.getP());
s.append(" warto ").append((w.isAPositive())?"minimaln":"maksymaln");
s.append(" y = ").append(w.getQ()).append(".");

Metoda getVertex() zwraca wspórzdne wierzchoka paraboli w postaci acucha
znaków, np. (–2, 1.5).
public String getVertex() {
return "("+getP()+", "+getQ()+")";
}
Wynik zwracany przez metod moe by wykorzystany podczas konstruowania opi-
sów waciwoci trójmianu.
System.out.println("Wierzchoek paraboli y = "+w+
" ma wspórzdne "+w.getVertex()+".");
}
}

W rozwizaniu zadania 23.7 mona byo zobaczy sposób przedstawiania zbioru war-
toci trójmianu kwadratowego. Na tej podstawie budujemy metod zwracajc w po-
staci acucha znaków przedzia liczbowy bdcy zbiorem wartoci funkcji (przeciw-
dziedzin).

public String getCodomain() {

if (isAPositive())
s.append("<").append(getQ()).append(", +oo)");
else
s.append("(-oo, ").append(getQ()).append(">");
return s.toString();
}
Wynik zwracany przez metod moe by wykorzystany podczas opisywania waci-
woci trójmianu kwadratowego.
/** Zadanie Z23.10 */
System.out.println("Zbiór wartoci trójmianu "+w+
": "+w.getCodomain());
w = new QuadratPoly(2, 3, -5);
System.out.println("Zbiór wartoci trójmianu "+w+
": "+w.getCodomain());
}
}

Korzystajc z metod klasy QuadratPoly i rozwiza poprzednich zada, moemy spo-
rzdzi kompletny opis funkcji kwadratowej.
/** Zadanie Z23.11 */
private static void opisFunkcji(QuadratPoly w) {
System.out.println("Funkcja kwadratowa f(x) = "+w);
System.out.println("1. Dziedzina: R (zbiór liczb
rzeczywistych)");
System.out.println("2. Zbiór wartoci: "+w.getCodomain());
System.out.println("3. Przedziay monotonicznoci:");
s.append(" - funkcja jest ");
s.append((w.isAPositive())?"malejca":"rosnca");
s.append(" w przedziale (-oo, ");
s.append(w.getP()).append(">\n - funkcja jest ");
s.append((w.isAPositive())?"rosnca":"malejca");
s.append(" w przedziale <");
s.append(w.getP()).append(", +oo)");
s.delete(0, s.length());
s.append("4. Ekstremum:\n");
s.append(" - funkcja osiga dla x = ").append(w.getP());
s.append(" warto ");
s.append((w.isAPositive())?"minimaln":"maksymaln");
s.append(" y = ").append(w.getQ());
System.out.println("5. Miejsca zerowe:");
s.delete(0, s.length());
case 1:

s.append("ma dwa pierwiastki rzeczywiste");

s.append("\n x = ").append(w.getX1());
s.append("\n x = ").append(w.getX2());
break;
case 0:
s.append("ma pierwiastek rzeczywisty dwukrotny");
s.append("\n x = "+w.getX1());
break;
case -1:
s.append("nie ma pierwiastków rzeczywistych");
break;
}
s.insert(0, " Funkcja ");
}
opisFunkcji(w);
w = new QuadratPoly(1, -2, 1);
opisFunkcji(w);
w = new QuadratPoly(1, 0, 1);
opisFunkcji(w);
}
}

Wczytywanie danych (wspóczynników a, b i c) wykonamy podobnie jak w rozwi-
zaniu 23.4. Zbiór rozwiza nierównoci kwadratowej ax 2 bx c ! 0, a z 0 , jest
zaleny od znaku wspóczynnika a, znaku wyrónika trójmianu (') i rzeczywistych
pierwiastków równania kwadratowego ax 2 bx c 0 .
'>0 '=0 '<0

a>0 f, x x , f
1 2
f, x x , f lub
0 0 R \ ^x0 ` f, f lub R
a<0 x , x
2 1

b ' b '

Zauwamy, e gdy a > 0 i ' > 0, to x1 x2 , natomiast dla a < 0
2a 2a
kolejno pierwiastków jest odwrócona: x2 x1 . W przypadku ' = 0 otrzymujemy
b
pierwiastek dwukrotny x0 (wedug powyszych wzorów: x0 x1 x2 ).
2a
/** Zadanie Z23.12 */

System.out.println("Nierówno kwadratowa ax^2+bx+c > 0");
/* Deklaracja i wczytanie wspóczynników a, b i c */

System.out.println("Nierówno "+w+" > 0 ");
case 1:
if (w.isAPositive()) {
s.append("(-oo, ").append(w.getX1());
s.append(") lub (");
s.append(w.getX2()).append(", +oo)");
} else {
s.append("(").append(w.getX2()).append(", ");
s.append(w.getX1()).append(")");
}
break;
case 0:
s.append("R\\{").append(w.getX1()).append("}");
else
s.append("{} (zbiór pusty)");
break;
case -1:
s.append("R (zbiór liczb rzeczywistych)");
else
break;
}
System.out.println("Zbiór rozwiza Z = "+s);
}
}

Podobnie jak w rozwizaniu zadania 23.12, mamy sze przypadków wyznaczonych
przez znaki wspóczynnika a i wyrónika '. W porównaniu z zadaniem 23.12 do zbioru
rozwiza doczamy dodatkowo miejsca zerowe trójmianu — w nierównoci opera-
tor jest wiksze od 0 (>) zosta zastpiony operatorem jest wiksze lub równe ( t ).
'>0 '=0 '<0

a>0 f, x 1
x2 , f f, f lub R f, f lub R
a<0 x2 , x1 ^x `
0

Zmiany w kodzie dotycz gównie sposobu budowania zbioru rozwiza nierównoci.

System.out.println("Nierówno "+w+" >= 0 ");

case 1:
if (w.isAPositive()) {
s.append("(-oo, ").append(w.getX1()).append("> lub <");
s.append(w.getX2()).append(", +oo)");
} else {
s.append("<").append(w.getX2()).append(", ");
s.append(w.getX1()).append(">");
}
break;
case 0:
else
s.append("{").append(w.getX1()).append("}");
break;
case -1:
else
break;
}
System.out.println("Zbiór rozwiza Z = "+s);

Do klasy doczamy metod mult(), która zwraca nowy obiekt QuadratPoly, bdcy
iloczynem obiektu wywoujcego t metod i liczby n.
public QuadratPoly mult(int n) {
if (n == 0)
throw new ArithmeticException("Niewaciwy parametr, n = 0");
return new QuadratPoly(n*this.a, n*this.b, n*this.c);
}
Przykad wykorzystania metody:

/** Zadanie Z23.14 */
QuadratPoly w = new QuadratPoly(2, -3, -1);
System.out.println("w(x) = "+w);
System.out.println("2·w(x) = "+w.mult(2));
System.out.println("-w(x) = "+w.mult(-1));
}
}

Zbiór rzeczywistych rozwiza równania kwadratowego jest zbiorem dwuelemento-
wym (' > 0), zbiorem jednoelementowym (' = 0) lub zbiorem pustym (' < 0). Do
klasy QuadratPoly doczamy metod:
public String solutionQE() {
StringBuilder s = new StringBuilder("{");
switch (sgnDelta()) {

case 1:
s.append(getX1()).append(", ").append(getX2()).append("}");
break;
case 0:
s.append(getX1()).append("}");
break;
case -1:
s.append("}");
break;
}
}
Dziaanie metody pokaemy, rozwizujc trzy róne równania kwadratowe:

/** Zadanie Z23.15 */
QuadratPoly w = new QuadratPoly(2, -3, -1);
System.out.println("Równanie kwadratowe "+w+
" = 0\nZbiór rozwiza Z ="+w.solutionQE()+"\n");
w = new QuadratPoly(1, -4, 4);
w = new QuadratPoly(4, 1, 3);
}
}

Na podstawie rozwizania 23.12 budujemy w klasie QuadratPoly prywatn metod
solutionQIe1() zwracajc w postaci acucha znaków rozwizanie nierównoci kwa-
dratowej ax 2 bx c ! 0, a z 0 .
private String solutionQIe1() {
case 1:
if (isAPositive()) {
s.append("(-oo, ").append(getX1());
s.append(") lub (");
s.append(getX2()).append(", +oo)");
} else {
s.append("(").append(getX2()).append(", ");
s.append(getX1()).append(")");
}
break;
case 0:
if (isAPositive())
s.append("R\\{").append(getX1()).append("}");
else
s.append("{}");
break;
case -1:

if (isAPositive())
s.append("R");
else
s.append("{}");
break;
}
}
Korzystajc z rozwizania zadania 23.13, budujemy w klasie QuadratPoly prywatn

metod solutionQIe2() zwracajc w postaci acucha znaków rozwizanie nierów-
noci kwadratowej ax 2 bx c t 0, a z 0 .
private String solutionQIe2() {
case 1:
if (isAPositive()) {
s.append("(-oo, ").append(getX1()).append("> lub <");
s.append(getX2()).append(", +oo)");
} else {
s.append("<").append(getX2()).append(", ");
s.append(getX1()).append(">");
}
break;
case 0:
if (isAPositive())
s.append("R");
else
s.append("{").append(getX1()).append("}");
break;
case -1:
if (isAPositive())
s.append("R");
else
s.append("{}");
break;
}
}
Publiczna metoda solutionQIe() wykorzystuje metody prywatne solutionQIe1()

i solutionQIe2() do rozwizywania nierównoci kwadratowej, której rodzaj jest okre-
lony parametrem typ, mogcym przyj jedn z czterech wartoci: ">", "<", ">="
i "<=". Nierównoci w zalenoci od typu s przekazywane do odpowiedniej metody
prywatnej. W dwóch przypadkach niezbdne jest przeksztacenie nierównoci na nie-
równo równowan przez pomnoenie obu jej stron przez liczb –1.
public String solutionQIe(String typ) {
if (typ.equals(">"))
return this.solutionQIe1();
else if (typ.equals(">="))
return this.solutionQIe2();
else if (typ.equals("<"))
return this.mult(-1).solutionQIe1();
else if (typ.equals("<="))

return this.mult(-1).solutionQIe2();
else
throw new IllegalArgumentException("Niewaciwy parametr "+typ);
}
W przykadowym rozwizaniu wykorzystamy tablic qp zawierajc kilka trójmianów

kwadratowych (rónicych si znakiem wyrónika) oraz tablic zawierajc wszystkie
typy nierównoci. Przegldanie tych tablic w dwóch zagniedonych ptlach for pozwala
nam na zbudowanie 12 zrónicowanych przykadów. Tablic qp mona rozbudowa.
/** Zadanie Z23.16 */
QuadratPoly[] qp = {new QuadratPoly(2, -3, -1),
new QuadratPoly(1, -4, 4), new QuadratPoly(4, 1, 3)};
String[] ie = {">", ">=", "<", "<="};
for(String typ: ie)
for(QuadratPoly w: qp) {
s.append("Nierówno kwadratowa ").append(w).append(" ");
s.append(typ).append(" 0\nZbiór rozwiza Z = ");
s.append(w.solutionQIe(typ)).append("\n");
}
}
}

Aby rozwiza równanie dwukwadratowe ax 4 bx 2 c 0, a z 0 , podstawiamy
y x 2 i otrzymujemy równanie kwadratowe ay 2 by c 0 . Jeli to równanie ma
nieujemne pierwiastki rzeczywiste y, to równanie wyjciowe ma pierwiastki o postaci
x r y.
Wspóczynniki równania wprowadzamy tak jak w rozwizaniu zadania 23.4. Proble-

mem jest wywietlenie równania dwukwadratowego. Wyjanijmy to na przykadzie.
Metoda toString() zwraca acuch o postaci "2x^2-3x+1", w tym acuchu odszuka-
my i zamienimy "x^2" na "x^4", nastpnie zamienimy "x" na "x^2". Po tych zamianach
otrzymamy "2x^4-3x^2+1".
StringBuilder str = new StringBuilder(w.toString());
int pos1 = str.indexOf("x");
str.replace(pos1+2, pos1+3, "4");
int pos2 = str.lastIndexOf("x");
if (pos2 != pos1)
str.replace(pos2, pos2+1, "x^2");
str.append(" = 0");
Równanie dwukwadratowe moe mie co najwyej 4 pierwiastki rzeczywiste. Dekla-

rujemy czteroelementow tablic x i licznik pierwiastków p. Rozwizujemy równanie
kwadratowe z niewiadom y i jeli rozwizanie y jest nieujemne, to do tablicy dopi-
sujemy dwa pierwiastki x y i x y (x[p++] = -Math.sqrt(y1); x[p++] =

Math.sqrt(y1);). Po wyjciu z instrukcji switch zmienna p zawiera liczb pierwiast-

ków rzeczywistych równania dwukwadratowego. Pozostaje jedynie wywietli te
pierwiastki.
/** Zadanie Z23.17 */
System.out.println("Podaj wspóczynniki równania ax^4+bx^2+c
= 0");
int a, b, c;
do {
} while (a == 0);
StringBuilder str = new StringBuilder(w.toString());
int pos1 = str.indexOf("x");
str.replace(pos1+2, pos1+3, "4");
int pos2 = str.lastIndexOf("x");
if (pos2 != pos1)
str.replace(pos2, pos2+1, "x^2");
str.append(" = 0");
System.out.println("Równanie "+str);
int p = 0; // liczba pierwiastków rzeczywistych
double[] x = new double[4];
case 1:
double y1 = w.getX1();
if (y1 >= 0) {
x[p++] = -Math.sqrt(y1);
x[p++] = Math.sqrt(y1);
}
double y2 = w.getX2();
if (y2 >= 0) {
x[p++] = -Math.sqrt(y2);
x[p++] = Math.sqrt(y2);
}
break;
case 0:
double y = w.getX1();
if (y >= 0) {
x[p++] = -Math.sqrt(y);
x[p++] = Math.sqrt(y);
}
break;
}
if (p == 0)
System.out.println("Nie ma pierwiastków rzeczywistych");
else if (p == 2) {
System.out.println("x1 = "+x[0]);

} else {
}
}
}

Do klasy QuadratPoly dodajemy metody realizujce dodawanie i odejmowanie trój-
mianów kwadratowych. Jeli suma (lub rónica w przypadku odejmowania) wspó-
czynników przy x 2 jest równa 0, to wynik nie jest trójmianem kwadratowym i meto-
da zgasza wyjtek.
public QuadratPoly add(QuadratPoly w) {
int s = this.a+w.a;
if (s == 0)
throw new ArithmeticException("Wynik nie jest trójmianem kwadratowym");
return new QuadratPoly(s, this.b+w.b, this.c+w.c);
}
public QuadratPoly sub(QuadratPoly w) {

int s = this.a-w.a;
if (s == 0)
throw new ArithmeticException("Wynik nie jest trójmianem kwadratowym");
return new QuadratPoly(s, this.b-w.b, this.c-w.c);
}
Metody przetestujemy, wykonujc dziaania na dwóch wybranych trójmianach.

/** Zadanie Z23.18 */
QuadratPoly w1 = new QuadratPoly(2, -3, 4);
QuadratPoly w2 = new QuadratPoly(-1, 4, 2);
System.out.println("w1 = "+w1);
System.out.println("w1+w2 = "+w1.add(w2));
System.out.println("w2+w1 = "+w2.add(w1));
System.out.println("w1-w2 = "+w1.sub(w2));
System.out.println("w2-w1 = "+w2.sub(w1));
System.out.println("w1+2·w2 = "+w1.add(w2.mult(2)));
}
}
Zadanie 23.19. Z23_19.java, FloatQP.java, DoubleQP.java

Wersje zmiennoprzecinkowe klasy QuadratPoly zbudujemy, przeksztacajc odpowied-
nio kod ródowy klasy.
a) Budujemy klas FloatQP:
1. Kopiujemy kod z pliku QuadratPoly.java do pliku FloatQP.java.

2. Usuwamy metod public int value(int n) { return (a*n+b)*n+c; }.

3. Zamieniamy w kodzie QuadratPoly na FloatQP (nazwa klasy, nazwy
konstruktorów i typów obiektowych).
4. Zamieniamy w kodzie typ int na typ float. Wyjtek stanowi metoda
sgnDelta(), któr pozostawiamy bez zmian:
public int sgnDelta() { return (delta > 0)?1:(delta < 0)?-1:0; }.
5. Usuwamy rzutowanie wyniku na typ double w metodach getP() i getQ().

6. Zamieniamy typ double na float.
7. Wyniki uzyskane przy uyciu metody Math.sqrt() rzutujemy na typ float.
8. W metodzie mult() moemy zmieni parametr n na x.
9. Do klasy dodajemy metod div():
public FloatQP div(float x) {
if (x == 0)
throw new ArithmeticException("Niewaciwy parametr, x = 0");
return new FloatQP(a/x, b/x, c/x);
}
b) Budujemy klas DoubleQP:

1. Kopiujemy kod z pliku QuadratPoly.java do pliku DoubleQP.java.
2. Usuwamy metod public int value(int n) { return (a*n+b)*n+c; }.
3. Zamieniamy w kodzie QuadratPoly na DoubleQP (nazwa klasy, nazwy
konstruktorów i typów obiektowych).
4. Zamieniamy w kodzie typ int na typ double. Wyjtek stanowi metoda
sgnDelta(), któr pozostawiamy bez zmian:
public int sgnDelta() { return (delta > 0)?1:(delta < 0)?-1:0; }.
5. Usuwamy rzutowanie wyniku na typ double w metodach getP() i getQ().

6. W metodzie mult() moemy zmieni parametr n na x.
7. Do klasy dodajemy metod div():
public DoubleQP div(float x) {
if (x == 0)
throw new ArithmeticException("Niewaciwy parametr, x = 0");
return new DoubleQP(a/x, b/x, c/x);
}
Wykorzystanie klas, dziaanie konstruktorów i metod pokaemy, rozwizujc przyka-

dowe równanie lub nierówno.
/** Zadanie Z23.19 */
FloatQP r1 = new FloatQP(1.0f, -4.5f, 0);
System.out.println("Równanie "+r1+" = 0");
System.out.println("Rozwizanie Z = "+r1.solutionQE());

DoubleQP r2 = new DoubleQP(-1.0, 2.7, 5.3);

System.out.println("Nierówno "+r2+" >= 0");
System.out.println("Rozwizanie Z = "+r2.solutionQIe(">="));
}
}
24. Rozwizania zada

— liczby zespolone
Zadanie 24.1. Z24_1.java, Complex.java
Klasa Complex zawiera dwa prywatne pola re (cz rzeczywista liczby, ang. real) i im
(cz urojona liczby, ang. imaginary) typu double.
public class Complex {
private double re, im;
}
Do klasy doczymy trzy podstawowe konstruktory. Pierwszy, bezparametrowy kon-

struktor zastpuje konstruktor domylny i buduje obiekt Complex odpowiadajcy licz-
bie 0+0i (re = 0; im = 0;).
public Complex() {}
Drugi konstruktor, z jednym parametrem x typu double, buduje obiekt (liczb zespo-
lon) odpowiadajcy liczbie rzeczywistej x (x+0i — z zerow czci urojon).
public Complex(double x) {
this.re = x;
this.im = 0;
}
Konstruktor z dwoma parametrami, x i y typu double, buduje obiekt odpowiadajcy

liczbie zespolonej x+yi.
public Complex(double x, double y) {
this.re = x;
this.im = y;
}
Metody setRe() i setIm() wywoane przez obiekt ustawiaj cz rzeczywist lub uro-
jon (stosownie do nazwy metody) liczby zespolonej reprezentowanej przez ten obiekt
na warto podan jako parametr (x typu double).
public void setRe(double x) {
this.re = x;
}
public void setIm(double x) {

this.im = x;
}

Metoda toString()utworzona w klasie Complex przesoni metod toString() dziedzi-

czon z klasy Object i zwróci liczb zespolon (reprezentowan przez obiekt Complex)
w postaci acucha znaków, np. –2.4+3i, 0–3i, 4.5 itp.
StringBuffer tmp = new StringBuffer();
tmp.append(re);
if (im > 0) {
tmp.append("+");
tmp.append(im);
tmp.append("i");
} else if (im < 0) {
tmp.append(im);
tmp.append("i");
}
}
W przykadzie pokazujcym dziaanie podstawowych konstruktorów i metod klasy

Complex niezbdne objanienia zawarto w komentarzach.
/* Konstruktor domylny */
Complex a = new Complex();
/* Zmiana czci rzeczywistej liczby zespolonej */
a.setRe(-7.2);
/* Zmiana czci urojonej liczby zespolonej */
a.setIm(4.5);
/* Liczba rzeczywista */
Complex b = new Complex(5.3);
/* Liczba zespolona */
Complex c = new Complex(2, -3);
/* Liczba urojona */
Complex d = new Complex(0, 4);
}
}

Jeli ' t 0 , to równanie ma pierwiastki rzeczywiste, które moemy zapisa w postaci
zespolonej x+0i. Gdy ' 0 , równanie kwadratowe az 2 bz c 0, a z 0 , ma dwa
b ' b '
pierwiastki zespolone: z i lub z i.
2a 2a 2a 2a
double a = 2.0, b = -1.0, c = 0.5;

if (delta < 0) {
double re = -b/(2*a);
double im = Math.sqrt(-delta)/(2*a);
Complex z1 = new Complex(re, -im);
System.out.println("z1 = "+z1);
Complex z2 = new Complex(re, im);
} else if (delta > 0) {
Complex z1 = new Complex((-b-Math.sqrt(delta))/(2*a));
Complex z2 = new Complex((-b+Math.sqrt(delta))/(2*a));
} else {
Complex z = new Complex(-b/(2*a));
System.out.println("Pierwiastek dwukrotny z = "+z);
}
}
}

Sum dwóch liczb zespolonych obliczamy ze wzoru a bi c di a c b d i .
public Complex add(Complex x) {
return new Complex(this.re+x.re, this.im+x.im);
}
Podobnie obliczymy rónic liczb zespolonych: a bi c di a c b d i .

public Complex sub(Complex x) {
return new Complex(this.re-x.re, this.im-x.im);
}
Kod metod add() i sub() doczamy do klasy Complex i sprawdzamy ich dziaanie, wy-
konujc kilka przykadowych oblicze.
Complex a = new Complex(4.5, 7);
Complex b = new Complex(-2, 3.3);
System.out.println("a+b = "+a.add(b));
System.out.println("b+a = "+b.add(a));
System.out.println("a-b = "+a.sub(b));
System.out.println("a-1 = "+a.sub(new Complex(1)));
}
}

Niech z oznacza liczb zespolon a bi . Liczb przeciwn (ang. opposite lub additive
inverse) do liczby z jest liczba z a bi . Jeli nie ma konfliktów pomidzy nazwa-
mi zmiennych i pól klasy, to moemy stosowa zapis skrócony: re zamiast this.re
oraz im zamiast this.im.

public Complex opp() {

return new Complex(-re, -im);
}
Liczb sprzon (ang. conjugate) do liczby zespolonej z nazywamy liczb z a bi .

public Complex conj() {
return new Complex(re, -im);
}
Liczb odwrotn (ang. reciprocal lub multiplicative inverse) moemy wyznaczy ze

1 z a bi a bi a b
wzoru z 1 2 i.
z z z a bi a bi a b
2 2
a b
2 2
a b2
public Complex rec() {
double sc = re*re+im*im;
return new Complex(re/sc, -im/sc);
}
Kilka prostych przykadów ilustruje dziaanie zdefiniowanych metod.

Complex a = new Complex(2, -3.5);
System.out.println("Liczba przeciwna: "+a.opp());
System.out.println("a+(-a) = "+a.add(a.opp()));
System.out.println("Liczba sprzona: "+a.conj());
System.out.println("Liczba odwrotna: "+a.rec());
}
}

Mnoenie liczb zespolonych wykonamy na podstawie wzoru:
a bi c di ac adi bci bdi 2 ac bd ad bc i .
public Complex mult(Complex x) {
return new Complex(re*x.re-im*x.im, re*x.im+im*x.re);
}
Dzielenie przez liczb zespolon zastpimy mnoeniem przez jej odwrotno (skorzy-
stamy z metody rec() podanej w rozwizaniu zadania 24.4).
public Complex div(Complex x) {
return this.mult(x.rec());
}
Dziaanie metod zademonstrujemy, obliczajc kwadrat liczby zespolonej (a.mult(a))

oraz iloraz dwóch liczb zespolonych.
Complex a = new Complex(0, 1);

System.out.println("a*a = "+a.mult(a));
Complex b = new Complex(3, 4);
}
}

Do klasy Complex dodajemy trzy stae odpowiadajce liczbom 0, 1 i jednostce urojonej i.
public static final Complex ZERO = new Complex(0);
public static final Complex ONE = new Complex(1);
public static final Complex I = new Complex(0, 1);
Wykonujc seri oblicze, pokaemy waciwoci zdefiniowanych staych w arytme-

tyce liczb zespolonych.
System.out.println("Wasnoci staych 0, 1 oraz i");
System.out.println("a = "+Complex.ZERO);
System.out.println("0+1 = "+Complex.ZERO.add(Complex.ONE));
System.out.println("0+i = "+Complex.ZERO.add(Complex.I));
Complex b = new Complex(2, -3);
System.out.println("b*0 = "+b.mult(Complex.ZERO));
System.out.println("b*1 = "+b.mult(Complex.ONE));
System.out.println("b*i = "+b.mult(Complex.I));
System.out.println("Potgi jednostki urojonej i");
System.out.println("i^1 = "+Complex.I);
System.out.println("i^2 = "+Complex.I.mult(Complex.I));
System.out.println("i^3 = "+Complex.I.mult(Complex.I).
mult(Complex.I));
System.out.println("i^4 = "+Complex.I.mult(Complex.I).
mult(Complex.I).mult(Complex.I));
}
}

Modu (bezwzgldn warto) liczby zespolonej z a bi moemy obliczy ze wzo-
ru z a2 b2 .
public double abs() {
return Math.sqrt(re*re+im*im);
}
Liczb zespolon z = a+bi (w postaci kanonicznej) interpretujemy geometrycznie ja-

ko punkt P o wspórzdnych (a, b) w prostoktnym (kartezjaskim) ukadzie wspó-
rzdnych. Argument liczby zespolonej (rónej od 0+0i) jest ktem (najczciej poda-
wanym w radianach) pomidzy promieniem PO (O — rodek ukadu wspórzdnych)
i osi OX. Zaleno pomidzy wspórzdnymi (a, b) i argumentem liczby zespolonej
z = a+bi przedstawia si nastpujco:

§b·
°arctan¨ a ¸, gdy a ! 0
° © ¹
° §b·
°arctan¨ ¸ S , gdy a 0 i b t 0
° ©a¹
°
°arctan§¨ b ·¸ S , gdy a 0 i b 0
Arg z ® ©a¹
°
° S , gdy a 0 i b ! 0
°2
°
° S , gdy a 0 i b ! 0
° 2
°0, gdy a 0 i b 0
¯
Korzystajc z metody Math.atan(), staej Math.PI oraz instrukcji warunkowych, moe-

my odpowiedni metod zbudowa. W klasie Math mamy zdefiniowan metod atan2(),
która nam to zadanie uatwia.
public double arg() {
return Math.atan2(im, re);
}
Naley doda, e pojcie argumentu nie jest jednoznaczne. Nasza metoda arg() wy-
znacza tzw. argument gówny liczby zespolonej. Pozostae argumenty tej liczby ró-
ni si od gównego o wielokrotno 2S . W przykadzie obliczymy modu i argument
dla dwóch wybranych liczb zespolonych 4–3i i 4+4i. Argument drugiej z tych liczb
podajemy w stopniach.
Complex a = new Complex(4, -3);
System.out.println("|a| = "+a.abs());
System.out.println("Arg(a) = "+a.arg());
a.setIm(4);
System.out.println("|a| = "+a.abs());
System.out.println("Arg(a) = "+Math.toDegrees(a.arg())+"°");
}
}

Metody getRe() i getIm() zwracaj warto pól obiektu, czyli cz rzeczywist (re)
i cz urojon (im) liczby zespolonej reprezentowanej przez obiekt.
public double getRe() {
return re;
}
public double getIm() {

return im;
}

Dziaanie metod pokaemy na przykadzie wybranej liczby zespolonej.

System.out.println("Cz rzeczywista liczby a: "+a.getRe());
System.out.println("Cz urojona liczby a: "+a.getIm());
}
}

Wywoanie metody print() spowoduje wywietlenie na standardowym wyjciu war-
toci obiektu w postaci acucha znaków.
public void print() {
System.out.print(this.toString());
}
Wiersz kodu System.out.print(this.toString()) moemy zapisa krócej: System.

out.print(this) lub System.out.print(toString()). Gdy w konsoli zostanie wypisana
liczba zespolona, kursor pozostanie w biecym wierszu. Jeli bdziemy potrzebowali,
aby kursor przeszed na pocztek nowego wiersza, to wystarczy uy drugiej metody:
public void println() {
System.out.println(this.toString());
}
Poniewa niejednokrotnie chcemy poprzedzi wywietlan warto dodatkowym tekstem,

to zbudujemy wersje tych metod z parametrem typu String (wypisywanym przed liczb).
public void print(String str) {
System.out.print(str+this);
}
public void println(String str) {

System.out.println(str+this);
}
Dysponujc tymi metodami, moemy w programach korzystajcych z obiektów klasy

Complex zamiast instrukcji System.out.println("a = "+a) pisa a.println("a = ")
— efekt bdzie taki sam.
Dokadniej ilustruje to przykad:

a.println();
a.println("a = ");
a.add(a).println("a+a = ");
}
}


Konstruktor kopiujcy odczytuje pola obiektu podanego jako parametr i tworzy nowy
obiekt z takimi samymi wartociami pól.
public Complex(Complex z) {
this.re = z.re;
this.im = z.im;
}
Dwie liczby zespolone s równe wtedy i tylko wtedy, gdy równe s ich czci rze-
czywiste i urojone. Porównanie wartoci obiektów moemy ograniczy wycznie do
obiektów klasy Complex:
public boolean equals(Complex z) {
return re == z.re && im == z.im;
}
lub wzorujc si na rozwizaniu zadania 20.18, zbudowa metod przesaniajc me-
tod Object.equals().
@Override public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || !(o instanceof Complex))
return false;
Complex c = (Complex) o;
if (this.re == c.re && this.im == c.im)
return true;
else
return false;
}
Przesaniajc metod equals(), powinnimy przedefiniowa metod hashCode()2:

@Override public int hashCode() {
int result = 17;
long tmp = Double.doubleToLongBits(re);
result = 31*result+(int)(tmp^(tmp>>>32));
tmp = Double.doubleToLongBits(im);
result = 31*result+(int)(tmp^(tmp>>>32));
return result;
}
Przykad przedstawia dziaanie konstruktora kopiujcego i metody equals(). Propo-

nujemy Czytelnikowi uruchomienie przykadowego kodu i jego dokadn analiz.
System.out.println("Dwa nowe obiekty a i b");
a.println("a = ");
Complex b = new Complex(a);
b.println("b = ");
2
Opracowane na podstawie: J. Bloch, Java. Efektywne programowanie. Wydanie II, Helion 2009.

System.out.print("Porównanie referencji a == b: ");

System.out.println(a == b);
System.out.print("Porównanie obiektów a.equals(b): ");
System.out.println(a.equals(b));
System.out.println("Nowy obiekt c i podstawienie c = a");
Complex c;
c = a;
c.println("c = ");
System.out.print("Porównanie referencji a == c: ");
System.out.println(a == c);
System.out.print("Porównanie obiektów a.equals(c): ");
System.out.println(a.equals(c));
System.out.println("Zmiana wartoci c zmienia warto a");
c.setRe(0);
c.println("c = ");
a.println("a = ");
System.out.println("Zmiana wartoci b nie zmienia wartoci a");
b.setRe(5);
b.println("b = ");
a.println("a = ");
System.out.println("Nowy obiekt d, kopia obiektu c");
Complex d = new Complex(c); // konstruktor kopiujcy
c.println("c = ");
d.println("d = ");
System.out.print("Porównanie referencji c == d: ");
System.out.println(c == d);
System.out.print("Porównanie obiektów c.equals(d): ");
System.out.println(c.equals(d));
}
}

Zaczniemy od sprawdzenia, czy w cigu znaków wystpuje symbol jednostki urojonej
(i). Jeli nie ma jednostki urojonej, to wprowadzony acuch znaków (s) moe by
liczb rzeczywist (re = Double.parseDouble(s); im = 0;), np. "–2.4". Bd podczas
parsowania tekstu sygnalizuje, e wprowadzona liczba nie jest poprawna (np. "2o3").
Gdy jednostka urojona i wystpuje w acuchu, powinna w nim by ostatnim zna-
kiem. Jeli tak nie jest, to acuch nie jest poprawn liczb zespolon (np. "2+i5" lub
"3.4–5ix").
Pozosta nam jeszcze do rozwaenia acuch typu „ r a r bi ”, gdzie znaki a i b ozna-

czaj cigi cyfr — liczby cakowite lub dziesitne. Usuwamy ostatni znak i do analizy
pozostaje nam cig znaków o postaci „ r a r b ”.
Moliwe s róne sytuacje opisane w komentarzach do kodu.

public Complex(String s) {
int n = s.indexOf("i");
if (n == -1) { // Nie ma jednostki urojonej - liczba rzeczywista.
re = Double.parseDouble(s);
im = 0;
} else {

// Jest jednostka urojona

if (n == s.length()-1) {
// i jest ostatnim znakiem.
s = s.substring(0, s.length()-1);
if (s.isEmpty() || s.equals("+")) {// liczba "i" lub "+i"
re = 0; im = 1; return;
}
if (s.equals("-")) { // liczba "-i"
re =0;
im = -1;
return;
}
int znakPlus = s.lastIndexOf("+");
if (znakPlus == s.length()-1) { // liczba "a+i" lub bd
re = Double.parseDouble(s.substring(0, znakPlus));
im = 1;
return;
}
int znakMinus = s.lastIndexOf("-");
if (znakMinus == s.length()-1) { // liczba "a-i" lub bd
re = Double.parseDouble(s.substring(0, znakMinus));
im = -1;
return;
}
if (znakPlus == -1 && znakMinus == -1) {// "bi" lub bd
re = 0;
im = Double.parseDouble(s);
return;
} else if (znakMinus > 0 || znakPlus > 0) {
if (znakMinus > 0) {
// liczba o postaci "-2-3i", "+2-3i", "2-3i" lub bd
re = Double.parseDouble(s.substring(0, znakMinus));
im = Double.parseDouble(s.substring(znakMinus));
return;
}
if (znakPlus > 0) {
// liczba o postaci "-2+3i", "+2+3i", "2+3i" lub bd
re = Double.parseDouble(s.substring(0, znakPlus));
im = Double.parseDouble(s.substring(znakPlus));
return;
}
}
} else // i nie jest ostatnim znakiem - bdne dane.
throw new ArithmeticException("Bdna liczba: "+s);
}
}
Dziaanie metody sprawdzimy dla kilku przykadowych cigów znaków, przedstawia-

jcych róne moliwe przypadki.
String[] test = {"1", "+2.5", "-3.5", "i", "+i", "-i", "2+3i",
"-2+3i", "2-3i", "-2+3i", "+2-3i", "+2+3i", "1+i", "2-i",
"-4e-02-2i", "2+4ix"};
for(String x: test) {

Complex z = new Complex(x);

System.out.println("\""+x+"\"\t --> "+z);
}
}
}

Do zbudowania metody statycznej parseComplex() zamieniajcej acuch znaków na
obiekt klasy Complex moemy wykorzysta (skopiowa) kod z rozwizania zadania
24.11 lub uy konstruktora.
static public Complex parseComplex(String s) {
return new Complex(s);
}
Dziaanie metody sprawdzimy dla kilku przykadowych cigów znaków (zapisanych

w tablicy test), podobnie jak w rozwizaniu zadania 24.11.
for(String x: test)
System.out.println("\""+x+"\"\t --> "+Complex.parseComplex(x));

Przyjmujemy warto pocztkow p = 1+0i. Dla wykadnika n > 0 w ptli powta-
rzamy obliczenie p = p.mult(a), co odpowiada wyraeniu a n 1 a n a . Dla n < 0
n
stosujemy wzór a n
1 § 1 · . Mnoenie przez 1 zastpujemy dzieleniem przez
n ¨ ¸
a ©a¹ a
a, czyli w ptli powtarzamy dziaanie p = p.div(a). Pozostaje przypadek wykadnika
równego 0 i wtedy zwracamy jako wynik pocztkow warto p = 1+0i.
public static Complex power(Complex a, int n) {
Complex p = Complex.ONE;
if (n > 0)
for(int i = 0; i < n; ++i)
p = p.mult(a);
else if (n < 0)
for(int i = 0; i < -n; ++i)
p = p.div(a);
return p;
}
Complex x = new Complex(1, -1);
for(int i = -5; i < 10; ++i) {
System.out.print("("+x.toString()+")^"+i+" = ");
power(x, i).println();
}
}
}
Demonstrujc dziaanie metody, obliczylimy kilka potg liczby 1–i.


Metod statyczn kopiujemy bezporednio z rozwizania zadania 24.13 do klasy
Complex:
public static Complex power(Complex a, int n) {
if (n > 0)
for(int i = 0; i < n; ++i)
p = p.mult(a);
else if (n < 0)
for(int i = 0; i < -n; ++i)
p = p.div(a);
return p;
}
Kopiujemy kod metody po raz drugi, usuwany sowo kluczowe static i parametr a
z nagówka funkcji. W ciele metody zmienn a zastpujemy sowem kluczowym this.
public Complex power(int n) {
if (n > 0)
for(int i = 0; i < n; ++i)
p = p.mult(this);
else if (n < 0)
for(int i = 0; i < -n; ++i)
p = p.div(this);
return p;
}
Obliczymy potgi jednostki urojonej i o wykadnikach od –4 do 9. Do oblicze wyko-

rzystamy obie metody.
Complex x = new Complex(0, 1);
for(int i = -4; i < 5; ++i)
System.out.println("("+x+")^"+i+" = "+Complex.power(x, i));
for(int i = 5; i < 10; ++i)
System.out.println("("+x+")^"+i+" = "+x.power(i));
}
}
Zadanie 24.15. Complex.java, DemoComplex_15.java

Zgodnie z definicj a 2 a a kwadrat liczby zespolonej reprezentowanej przez obiekt
a wyznaczymy, wykonujc mnoenie a.mult(a).
public Complex sqr() {
return this.mult(this);
}
Podobnie moemy zbudowa metod statyczn:

public static Complex sqr(Complex z) {

return z.mult(z);
}
lub:
public static Complex sqr(Complex z) {
return z.sqr();
}
Aby obliczy pierwiastek drugiego stopnia a bi , rozwiemy równanie kwadra-

° x 2 y 2
towe x yi 2 a bi . Po przeksztaceniu otrzymamy ukad równa: ®
a
.
°̄2 xy b
a2 b2 a a 2 b2 a
Z ukadu równa otrzymamy x i y H , gdzie H ozna-
2 2
cza znak czci urojonej liczby podpierwiastkowej (znak b: –1 lub 1). Std mamy dwa
pierwiastki r x yi . Przypadek b = 0 naley rozpatrywa osobno. Dla a t 0 otrzy-
mamy w wyniku liczb rzeczywist r a , a dla a 0 liczb urojon r i a .
public Complex sqrt() {
if (im == 0)
if (re >= 0)
return new Complex(Math.sqrt(re));
else
return new Complex(0.0, Math.sqrt(-re));
else
return new Complex(Math.sqrt((abs()+re)/2),
Math.signum(im)*Math.sqrt((abs()-re)/2));
}
Drugi (nastpny) pierwiastek jest liczb przeciwn (do poprzedniego):

public Complex nextSqrt() {
return this.sqrt().opp();
}
Po niewielkich poprawkach otrzymamy metody statyczne obliczajce pierwiastek dru-

giego stopnia z liczby zespolonej:
public static Complex sqrt(Complex z) {
if (z.im == 0)
if (z.re >= 0)
return new Complex(Math.sqrt(z.re));
else
return new Complex(0.0, Math.sqrt(-z.re));
else
return new Complex(Math.sqrt((z.abs()+z.re)/2),
Math.signum(z.im)*Math.sqrt((z.abs()-z.re)/2));
}
public static Complex nextSqrt(Complex z) {

return sqrt(z).opp();
}

W przykadzie sprawdzamy na wybranych wartociach liczb zespolonych zdefiniowa-

ne metody sqr() i sqrt(), skadajc te funkcje a 2 lub a .
2

/* Podnoszenie pierwiastka kwadratowego do kwadratu */
new Complex( 1, -2).sqrt().sqr().println();
new Complex( 1, 2).sqrt().sqr().println();
new Complex(-1, -2).sqrt().sqr().println();
new Complex(-1, 2).sqrt().sqr().println();
/* Pierwiastkowanie kwadratu liczby zespolonej */
new Complex( 1, -2).sqr().sqrt().println();
new Complex( 1, 2).sqr().sqrt().println();
new Complex(-1, -2).sqr().sqrt().println(); // liczba przeciwna
new Complex(-1, -2).sqr().nextSqrt().println();
new Complex(-1, 2).sqr().sqrt().println(); // liczba przeciwna
new Complex(-1, 2).sqr().nextSqrt().println();
/* Metody statyczne sqr i sqrt */
Complex x = new Complex(2.5, -4);
Complex y = Complex.sqr(x);
System.out.println("y = x^2 = "+y);
System.out.println("z = sqrt(y) = "+Complex.sqrt(y));
System.out.println("z = sqrt(y) = "+Complex.nextSqrt(y));
}
}

Aby wywietli cz rzeczywist i urojon liczby zespolonej w konsoli, uyjemy me-
tody System.out.printf(). Zwrómy uwag na specyfikator "%f%+fi". Wystpujcy
w acuchu znak plus (+) powoduje, e przed drug liczb (czci urojon) bdzie
wywietlany znak liczby — plus równie.
public void printf() {
System.out.printf("%f%+fi", this.re, this.im);
}
public void printf(String str) {

System.out.printf(str+"%f%+fi", this.re, this.im);
}
public void printlnf() {

System.out.printf("%f%+fi\n", this.re, this.im);
}
public void printlnf(String str) {

System.out.printf(str+"%f%+fi\n", this.re, this.im);
}
Czytelnik moe zmodyfikowa te metody, dodajc parametr okrelajcy precyzj (licz-

b miejsc po przecinku) lub przekazujc specyfikator. W przykadzie porównajmy spo-
sób dziaania metody println() (z zadania 24.9) i zdefiniowanej metody printf().

Complex a = new Complex(-5);

a.println("Metoda println: \ta = ");
a.printlnf("Metoda printlnf:\ta = ");
a.sqrt().println("Metoda println: \tsqrt(a) = ");
a.sqrt().printlnf("Metoda printlnf:\tsqrt(a) = ");
}
}

Rozwizywanie równania kwadratowego o wspóczynnikach zespolonych w zbiorze
liczb zespolonych sprowadza si do obliczenia wyrónika ( ' b 2 4ac ) i wyznacze-
b '
nia pierwiastków równania na podstawie wzoru z r .
2a
/* Wspóczynniki zespolone równania az^2+bz+c = 0 */
a.printlnf("a = ");
b.printlnf("b = ");
Complex c = new Complex(-1);
c.printlnf("c = ");
System.out.println("Równanie ("+a+")z^2+("+b+")z+"+a+" = 0");
/* Obliczenie pierwiastków kwadratowych */
Complex delta = b.sqr().sub(new Complex(4).mult(a).mult(c));
delta.printlnf("delta = ");
Complex z1 = b.opp().sub(delta.sqrt()).div(new Complex(2).
mult(a));
z1.printlnf("z1 = ");
Complex z2 = b.opp().add(delta.sqrt()).div(new Complex(2).
mult(a));
z2.printlnf("z2 = ");
System.out.println("Sprawdzenie:");
a.mult(z1.sqr()).add(b.mult(z1)).add(c).printlnf("w(z1) = ");
a.mult(z2.sqr()).add(b.mult(z2)).add(c).printlnf("w(z2) = ");
}
}
Zadanie 24.18.
Oznaczmy x a bi oraz y c di .
Suma: x y a bi c di a c b d i .
public static Complex sum(Complex x, Complex y) {
return new Complex(x.re+y.re, x.im+y.im);
}
Rónica: x y a bi c di a c b d i .
public static Complex diff(Complex x, Complex y) {
return new Complex(x.re-y.re, x.im-y.im);
}

Iloczyn: x y a bi c di ac bd ad bc i .
public static Complex prod(Complex x, Complex y) {
return new Complex(x.re*y.re-x.im*y.im, x.re*y.im+x.im*y.re);
}
Iloraz:
x a bi a bi c di ac bd bc ad i ac bd bc ad
i.
y c di c di c di c d2 2
c2 d 2 c2 d 2
public static Complex quot(Complex x, Complex y) {
double s = x.re*x.re+y.re*y.re;
return new Complex((x.re*y.re+x.im*y.im)/s, (x.im*y.re-x.re*y.im)/s);
}
Jak wykorzysta w programie zdefiniowane metody, pokazuje przykad:

a.printlnf("a = ");
b.printlnf("b = ");
Complex c = Complex.sum(a, b);
c.printlnf("a+b = ");
c = Complex.diff(a, b);
c.printlnf("a-b = ");
c = Complex.prod(a, b);
c.printlnf("a·b = ");
c = Complex.quot(a, b);
c.printlnf("a/b = ");
}
}
Zadanie 24.19. Z24_19.java, PolarComplex.java

Klasa PolarComplex zawiera dwa prywatne pola r (promie, modu liczby zespolonej,
r t 0 ) i fi (kt, argument liczby zespolonej) oraz domylny konstruktor (nadajcy
obiektowi warto 0).
public class PolarComplex {
private double r, fi;
public PolarComplex() {}
}
Do klasy doczmy konstruktor z parametrami r i fi:

public PolarComplex(double r, double fi) {
if (r < 0)
throw new ArithmeticException("Niewaciwy parametr: "+r);
this.r = r;
this.fi = fi;
}
oraz konstruktor z jednym parametrem r, przyjmujcy domylne M 0 (this.fi =

0.0) dla liczby rzeczywistej nieujemnej r, M S (this.fi = -Math.PI) dla liczby
ujemnej r.

public PolarComplex(double r) {
this.r = Math.abs(r);
if (r >= 0.0)
this.fi = 0.0;
else
this.fi = -Math.PI;
}
Zamian wspórzdnych biegunowych na kartezjaskie zrealizujemy za pomoc wzo-

x r cos M
ru ® :
¯ y r sin M
public Complex toComplex() {
return new Complex(r*Math.cos(fi), r*Math.sin(fi));
}
Wartoci pól obiektu (r i fi) typu double zamienimy na acuchy znaków reprezen-
tujce liczby z szecioma miejscami po przecinku, z których nastpnie budujemy wy-
nik (acuch wyjciowy). Do formatowania liczby uywamy obiektu formatter klasy
DecimalFormat (dziedziczcej z klasy java.text.NumberFormat — niezbdne jest im-
portowanie odpowiednich klas w klasie PolarComplex):
import java.text.DecimalFormat;
import java.text.NumberFormat;
Przesaniamy metod toString() z klasy Object:

NumberFormat formatter = new DecimalFormat("#0.000000");
String s1 = formatter.format(this.r);
String s2 = formatter.format(this.fi);
return "[r="+s1+"; fi="+s2+"]";
}
Dziaanie konstruktorów i metody toComplex() pokaemy dla kilku wybranych wartoci.

/** Zadanie Z24.19 */
PolarComplex a = new PolarComplex();
System.out.println("a = "+a.toComplex()+" = "+a);
PolarComplex b = new PolarComplex(5.4);
System.out.println("b = "+b.toComplex()+" = "+b);
PolarComplex c = new PolarComplex(-1);
System.out.println("c = "+c.toComplex()+" = "+c);
c.toComplex().printlnf("c = ");
PolarComplex d = new PolarComplex(Math.sqrt(2), Math.PI/4);
System.out.println("d = "+d.toComplex()+" = "+d);
d.toComplex().printlnf("d = ");
}
}


Do klasy PolarComplex dodajemy konstruktor kopiujcy, który tworzy nowy obiekt
PolarComplex, reprezentujcy t sam warto zespolon co obiekt przekazany jako
parametr (efektem porównania tych obiektów metod equals() powinna by warto
true, natomiast porównanie referencji (==) da wynik false).
public PolarComplex(PolarComplex z) {
r = z.r;
fi = z.fi;
}
Drugi konstruktor tworzy nowy obiekt PolarComplex, reprezentujcy liczb zespolon

podan jako parametr typu Complex ( r z i M arg z ).
public PolarComplex(Complex z) {
r = z.abs();
fi = z.arg();
}
W przykadowym programie tworzymy obiekt a klasy PolarComplex, reprezentujcy

liczb zespolon i (jednostk urojon) — w postaci kanonicznej 0+i, w postaci biegu-
S
nowej §¨1, ·¸ . Obiekt b jest utworzony przez konstruktor kopiujcy z obiektu a. Za-
© 2¹
mieniajc te obiekty na obiekty klasy Complex (metoda toComplex()), zauwaymy roz-
bienoci na dalszych miejscach po przecinku (rzdu 10–16). Podobn precyzj uzyskamy
podczas konwersji liczby 3–4i i innych liczb zespolonych.
/** Zadanie Z24.20 */
PolarComplex a = new PolarComplex(1, Math.PI/2);
System.out.println("a = "+a.toComplex());
PolarComplex b = new PolarComplex(a);
System.out.println("b = "+b.toComplex());
PolarComplex c = new PolarComplex(new Complex(3, -4));
System.out.println("c = "+c.toComplex());
}
}

W klasie Complex dodajemy konstruktor budujcy nowy obiekt Complex, odpowiadajcy
liczbie zespolonej przekazanej jako parametr typu PolarComplex. Do zmiany typu wy-
korzystamy metod toComplex() z klasy PolarComplex (Complex tmp = z.toComplex()).
Nastpnie wartoci pól obiektu tmp skopiujemy do pól nowego obiektu.
public Complex(PolarComplex z) {
Complex tmp = z.toComplex();
this.re = tmp.re;
this.im = tmp.im;
}

Do konwersji obiektu Complex na obiekt PolarComplex zbudujemy metod toPolar

Complex() ( r z i M arg z ).
public PolarComplex toPolarComplex() {

return new PolarComplex(this.abs(), this.arg());
}
Podobnie jak w rozwizaniu zadania 24.20, pokazujemy konwersj pomidzy obiek-

tami klasy PolarComplex i Complex.
/** Zadanie Z24.21 */
System.out.println("a = "+a.toComplex());
Complex b = new Complex(a);
Complex c = new Complex(3, -4);
c.toPolarComplex().toComplex().println("c = ");
}
}

Iloczyn dwóch liczb zespolonych zapisanych w postaci trygonometrycznej:
x x sin M i cos M i y y sin\ i cos\
wyraa si wzorem:
xy x y sinM \ i sin M \
Na tej podstawie moemy zbudowa metod obliczajc iloczyn liczb zespolonych —

obiektów klasy PolarComplex.
public PolarComplex mult(PolarComplex z) {
return new PolarComplex(this.r*z.r, this.fi+z.fi);
}
W przykadzie obliczymy iloczyn dwóch liczb zespolonych podanych w postaci bie-

gunowej (obiektów klasy PolarComplex) i wywietlimy wyniki w postaci kanonicznej
(po zamianie wyniku na obiekt Complex) z dokadnoci do 6 miejsc po przecinku
(metoda printlnf() z zadania 24.16) oraz w postaci biegunowej (stosujc metod
toString() dla obiektu klasy PolarComplex — wywoywan podczas czenia tekstów
w parametrze metody, np. System.out.println("a = "+a)).
/** Zadanie Z24.22 */
a.toComplex().printlnf("a = ");
PolarComplex b = new PolarComplex(-2, Math.PI/2);
b.toComplex().printlnf("b = ");
a.mult(b).toComplex().printlnf("a·b = ");
b.mult(a).toComplex().printlnf("b·a = ");

System.out.println("a·b = "+a.mult(b));
}
}

Zapiszmy liczby zespolone w postaci trygonometrycznej:
x x sin M i cos M i y y sin\ i cos\
Iloraz tych liczb wyraa si wzorem:
x
xy sin M \ i sin M \
y
który wykorzystamy do zbudowania metody obliczajcej iloraz liczb zespolonych.

public PolarComplex div(PolarComplex z) {
return new PolarComplex(this.r/z.r, this.fi-z.fi);
}
Obliczymy iloraz dwóch liczb i podobnie jak w rozwizaniu zadania 24.22, wywie-
tlimy wyniki w postaci kanonicznej oraz w postaci biegunowej.
/** Zadanie Z24.23 */
PolarComplex b = new PolarComplex(-2, Math.PI/2);
b.toComplex().printlnf("b = ");
Complex x = a.div(b).toComplex();
x.printlnf("x = a/b = ");
Complex y = b.div(a).toComplex();
y.printlnf("y = b/a = ");
x.mult(y).printlnf("x·y = ");
System.out.println("a/b = "+a.div(b));
}
}

Stosujc wzór na iloczyn liczb zespolonych, podany w rozwizaniu zadania 24.22,
obliczymy kwadrat i szecian liczby zespolonej (podanej w postaci biegunowej).
public PolarComplex sqr() {
return new PolarComplex(r*r, 2*fi);
}
public PolarComplex cube() {

return new PolarComplex(r*r*r, 3*fi);
}

Skadajc w przykadowym programie odpowiednio metody sqr(), cube() oraz mult(a),

obliczymy potgi (o wykadnikach od 1 do 6) liczby zespolonej reprezentowanej przez
1 i 3
obiekt a. Obliczenia wykonamy dla liczby (w postaci biegunowej r 1 ,
2
S
M rad 60q ).
3
/** Zadanie Z24.24 */

a.toComplex().printf("a^1 = ");
System.out.println(" = "+a);
a.sqr().toComplex().printf("a^2 = ");
System.out.println(" = "+a.sqr());
a.cube().toComplex().printf("a^3 = ");
System.out.println(" = "+a.cube());
a.sqr().sqr().toComplex().printf("a^4 = ");
System.out.println(" = "+a.sqr().sqr());
a.sqr().sqr().mult(a).toComplex().printf("a^5 = ");
System.out.println(" = "+a.sqr().sqr().mult(a));
a.sqr().cube().toComplex().printf("a^6 = ");
System.out.println(" = "+a.sqr().cube());
}
}

Potgowanie liczb zapisanych w postaci trygonometrycznej z z cos M i sin M (bie-
gunowej) jest atwe przy wykorzystaniu wzoru de Moivre’a: z n z
n
cos nM i sin nM .
public PolarComplex power(int n) {
return new PolarComplex(Math.pow(r, n), n*fi);
}
Aby zilustrowa zastosowanie metody power(), obliczymy potgi (o wykadnikach od

0 do 12) liczby zespolonej reprezentowanej przez obiekt a. Obliczenia wykonamy dla
3 i S
liczby (w postaci biegunowej r 1 , M rad 30q .
2 6
/** Zadanie Z24.25 */
for(int i = 0; i < 13; ++i) {
a.power(i).toComplex().printf("a^"+i+" = ");
System.out.println(" = "+a.power(i));
}
}
}


Niezerowa liczba zespolona z ma n rónych zespolonych pierwiastków n-tego stopnia,
które mona obliczy, korzystajc ze wzoru de Moivre’a:
§ M 2kS M 2kS ·
zk n z ¨ cos i sin ¸ dla k = 0, 1, …, n–1.
© n n ¹
Dla n = 2 otrzymujemy:
§ M 2kS M 2kS · § §M · §M ··
zk z ¨ cos i sin ¸ z ¨¨ cos¨ kS ¸ i sin ¨ kS ¸ ¸¸ dla k = 0, 1.
© 2 2 ¹ © © 2 ¹ © 2 ¹¹
public PolarComplex sqrt(int k) {
k %= 2;
return new PolarComplex(Math.sqrt(r), fi/2+k*Math.PI);
}
Jako przykad dziaania metody obliczymy pierwiastki stopnia drugiego z liczby urojonej 2i.
/** Zadanie Z24.26 */
System.out.print("a = "+a+" = ");
a.toComplex().printlnf();
System.out.println("Pierwiastki drugiego stopnia");
PolarComplex x1 = a.sqrt(0);
System.out.print("x1 = "+x1+" = ");
x1.toComplex().printlnf();
PolarComplex x2 = a.sqrt(1);
}
}

Na podstawie wzoru de Moivre’a (zob. rozwizanie zadania 24.26) dla n = 3 otrzymu-
§ M 2kS M 2kS ·
jemy z k 3 z ¨ cos i sin ¸ dla k = 0, 1, 2.
© 3 3 ¹
public PolarComplex cbrt(int k) {
k %= 3;
return new PolarComplex(Math.cbrt(r), (fi+2*k*Math.PI)/3);
}
Podajc przykad dziaania metody, obliczymy pierwiastki stopnia trzeciego z liczby

–8 (w tym jeden pierwiastek rzeczywisty –2).
/** Zadanie Z24.27 */
PolarComplex a = new PolarComplex(8, -Math.PI);
System.out.print("a = "+a+" = ");
a.toComplex().printlnf();

System.out.println("Pierwiastki trzeciego stopnia");

PolarComplex x1 = a.cbrt(0);
}
}

Na podstawie rozwizania zadania 24.26 budujemy bezparametrow metod sqrt()
zwracajc tablic obiektów Complex z dwoma pierwiastkami drugiego stopnia z licz-
by zespolonej reprezentowanej przez obiekt PolarComplex wywoujcy metod.
public Complex[] sqrt() {
Complex[] tmp = new Complex[2];
tmp[0] = new PolarComplex(Math.sqrt(r), fi/2).toComplex();
tmp[1] = new PolarComplex(Math.sqrt(r), fi/2+Math.PI).toComplex();
return tmp;
}
Podobnie (zob. rozwizanie zadania 24.27) budujemy bezparametrow metod cbrt()

zwracajc tablic obiektów Complex z trzema pierwiastkami trzeciego stopnia z licz-
by zespolonej.
public Complex[] cbrt() {
Complex[] tmp = new Complex[3];
tmp[0] = new PolarComplex(Math.sqrt(r), fi/3).toComplex();
tmp[1] = new PolarComplex(Math.sqrt(r), (fi+2*Math.PI)/3).
toComplex();
tmp[2] = new PolarComplex(Math.sqrt(r), (fi+4*Math.PI)/3).
toComplex();
return tmp;
}
W przykadowym programie obliczymy pierwiastki drugiego stopnia z –4 i pierwiast-

ki trzeciego stopnia z 8i.
/** Zadanie Z24.28 */
PolarComplex a = new PolarComplex(new Complex(4));
System.out.println("Pierwiastki kwadratowe z liczby 4:");
for(Complex x: a.sqrt()) {
x.printf("x = ");
System.out.println(" = "+x.toPolarComplex());
}
a = new PolarComplex(new Complex(-4));
System.out.println("Pierwiastki kwadratowe z liczby -4:");
for(Complex x: a.sqrt()) {
x.printf("x = ");

}
a = new PolarComplex(new Complex(0, 8));
System.out.println("Pierwiastki szecienne z liczby 8i:");
for(Complex x: a.cbrt()) {
x.printf("x = ");
}
}
}
Poniewa bezparametrowe metody sqrt() i cbrt() zwracaj pierwiastki zebrane w ta-

blicy, to do wywietlania wartoci moemy uy statycznej metody toString() z kla-
sy Arrays.
/** Zadanie Z24.28 */
PolarComplex a = new PolarComplex(new Complex(4));
System.out.println(Arrays.toString(a.sqrt()));
a = new PolarComplex(new Complex(-4));
System.out.println(Arrays.toString(a.sqrt()));
a = new PolarComplex(new Complex(0, 8));
System.out.println("Pierwiastki szecienne z liczby 8i:");
System.out.println(Arrays.toString(a.cbrt()));
}
}
Zadanie 24.29. Z24_29a.java, Z24_29b.java

c
a) Jeli a z 0 , równanie az 2 c 0 jest równowane równaniu z 2 .
a
c
Równanie to ma dwa pierwiastki zespolone z (rzeczywiste
a
c c
z , gdy ! 0 ) lub pierwiastek dwukrotny z 0 dla c 0 .
r
a a
Do wyznaczenia pierwiastków najwygodniej bdzie uy metody sqrt()
z jednym parametrem (zob. rozwizanie zadania 24.26).
/** Zadanie Z24.29a */
System.out.println("Równanie az^2+c = 0 o wspóczynnikach
rzeczywistych");
if (a != 0) {
PolarComplex x = new Complex(-c/a).toPolarComplex();
x.sqrt(0).toComplex().printlnf("z1 = ");

} else
System.out.println("Równanie sprzeczne lub nieoznaczone.");
}
}
b) Równanie z a a . Równanie to ma
3
0 jest równowane równaniu z 3
trzy pierwiastki zespolone z a (w tym jeden jest zawsze rzeczywisty)
3
lub pierwiastek trzykrotny z 0 dla a 0 . Pierwiastki obliczymy, stosujc

metod cbrt() z jednym parametrem (zob. rozwizanie zadania 24.27).
/** Zadanie Z24.29b */
System.out.println("Równanie z^3+a = 0 o wspóczynnikach
rzeczywistych");
PolarComplex x = new Complex(-a).toPolarComplex();
x.cbrt(0).toComplex().printlnf("z1 = ");
}
}
Zadanie 24.30. Z24_30a.java, Z2430b.java

a) Rozwizujc równanie az 2 c 0 o wspóczynnikach zespolonych,
postpujemy podobnie jak w rozwizaniu zadania 24_29a. Rónica polega
na innym sposobie wprowadzania danych, wykonywaniu porówna i dziaa
(w sposób specyficzny dla liczb zespolonych). Oto podstawowe rónice:
Wspóczynniki rzeczywiste Wspóczynniki zespolone

Wczytywanie danych Wczytywanie danych
System.out.print("a = "); System.out.print("a.re = ");
double a = input.nextDouble(); double re = input.nextDouble();
System.out.print("a.im = ");
double im = input.nextDouble();
Complex a = new Complex(re, im);
Porównywanie a z zerem Porównywanie a z zerem
if(a != 0)... if(!a.equals(Complex.ZERO))...
Obliczenie prawej strony równania (–c/a) Obliczenie prawej strony równania (–c/a)
(i zamiana na liczb zespolon) PolarComplex x =
PolarComplex x = new Complex c.opp().div(a).toPolarComplex();
(-c/a).toPolarComplex();
Obliczenie i wywietlenie pierwiastków zespolonych

/** Zadanie Z24.30a */
System.out.println("Równanie az^2+c = 0 o wspóczynnikach
zespolonych");
System.out.print("a.re = ");
double re = input.nextDouble();
a.printlnf("a = ");
System.out.print("c.re = ");
re = input.nextDouble();
System.out.print("c.im = ");
im = input.nextDouble();
Complex c = new Complex(re, im);
c.printlnf("c = ");
if (!a.equals(Complex.ZERO)) {
PolarComplex x = c.opp().div(a).toPolarComplex();
} else
System.out.println("Równanie sprzeczne lub nieoznaczone.");
}
}
b) Równanie z a a (a.opp()), a to
3
0 jest równowane równaniu z 3
równanie ma trzy (róne) pierwiastki zespolone z a lub pierwiastek
3
trzykrotny z 0 0i dla a 0 0i (porównaj z rozwizaniem zadania 24.29b).

/** Zadanie Z24.30b */
System.out.println("Równanie z^3+a = 0 o wspóczynnikach
zespolonych");
System.out.print("a.re = ");
double re = input.nextDouble();
a.printlnf("a = ");
PolarComplex x = a.opp().toPolarComplex();
}
}


Metoda root() jest realizacj wzoru de Moivre’a:
§ § M 2kS · § M 2kS ··
n
z n
r ¨¨ cos¨ ¸ i sin ¨ ¸ ¸¸ , k = 0, 1, 2… n-1.
© © n ¹ © n ¹¹
public PolarComplex root(int n, int k) {

k %= n;
return new PolarComplex(Math.pow(r, 1.0/n), (fi+2*k*Math.PI)/n);
}
Testujc dziaanie metody, wyznaczymy pierwiastki zespolone pitego stopnia z 32,

wród nich jest jedna warto rzeczywista (liczba 2).
/** Zadanie Z24.31 */
System.out.println("Pierwiastki zespolone 5 stopnia z 32");
PolarComplex a = new Complex(32).toPolarComplex();
for(int i = 0; i < 5; ++i) {
PolarComplex x = a.root(5, i);
System.out.print("x"+i+" = ");
x.toComplex().printf();
System.out.println(" = "+x);
}
}
}

Na podstawie rozwizania zadania 24.31 budujemy tablic obiektów Complex zawiera-
jc n pierwiastków n-tego stopnia z liczby zespolonej reprezentowanej przez obiekt
PolarComplex wywoujcy metod.
public Complex[] root(int n) {
Complex[] tmp = new Complex[n];
for(int k = 0; k < n; ++k) {
tmp[k] = new PolarComplex(Math.pow(r, 1.0/n), (fi+2*k*Math.PI)/n).
toComplex();
}
return tmp;
}
Testujc dziaanie metody, wyznaczymy pierwiastki ósmego stopnia z 1, w tym dwie

liczby rzeczywiste 1 i –1.
/** Zadanie Z24.32 */
System.out.println("Pierwiastki zespolone 8 stopnia z 1");
PolarComplex a = new Complex(1).toPolarComplex();

for(Complex x: a.root(8)) {
x.printf();
}
}
}

a) Rozwizanie równania z 1
n
0 w zbiorze liczb zespolonych, równowanego
równaniu z 1 , sprowadza si do obliczenia pierwiastków zespolonych
n
n-tego stopnia z liczby –1. Liczb rzeczywist –1 zamieniamy na liczb

zespolon –1+0i, a nastpnie na jej posta biegunow PolarComplex a = new
Complex(-1).toPolarComplex();. Wywoanie metody a.root(n) zwraca nam
n-elementow tablic obiektów klasy Complex, pierwiastków zespolonych
obiektu a (odpowiadajcego liczbie –1) — rozwizanie naszego równania.
/** Zadanie Z24.33 */
System.out.println("Pierwiastki równania z^n+1 = 0");
PolarComplex a = new Complex(-1).toPolarComplex();
int i = 1;
for(Complex x: a.root(n)) {
System.out.print("z"+i+" = ");
++i;
x.printf();
}
}
}
Przedstawione rozwizanie moemy uogólni dla wszystkich równa

o postaci z n a 0 .
b) W rozwizaniu zadania 24.33a zmieniamy dwa wiersze programu
na nastpujce:
System.out.println("Pierwiastki równania z^n+i = 0");
oraz
PolarComplex a = new Complex(0, -1).toPolarComplex();
c) Rozwizujemy w zbiorze liczb zespolonych równanie kwadratowe

x 2 ix 1 0 (zob. rozwizanie zadania 24.17) i otrzymujemy dwa
pierwiastki zespolone x1 i x2 .

/* Równanie kwadratowe ax^2+bx+c = 0, a = 1, b = i, c = 1 */

Complex a = new Complex(1);
Complex c = new Complex(1);
Complex delta = b.sqr().sub(new Complex(4).mult(a).mult(c));
Complex x1 = b.opp().sub(delta.sqrt()).div(new Complex(2).mult(a));
Complex x2 = b.opp().add(delta.sqrt()).div(new Complex(2).mult(a));
Nastpnie rozwizujemy dwa równania: z n x1 i z n x2 , wzorujc

si na rozwizaniu zadania 24.33a (24.33b). Najpierw obliczymy seri
n pierwiastków pierwszego równania ( z n x1 ).
int i = 1;
/* Równanie z^n = x1 */
PolarComplex z = x1.toPolarComplex();
for(Complex x: z.root(n)) {
System.out.print("z"+i+" = ");
++i;
x.printf();
}
Kolejne pierwiastki wyznaczymy w ten sam sposób, na podstawie drugiego

równania ( z n x2 ).

Rozdzia 8.
Rozwizania zada
25. Operacje na plikach tekstowych
Z pakietu java.io importujemy dwie klasy IOException i FileWriter.
W nagówku metody main() umieszczamy sowo kluczowe throws i nazw klasy

IOException — uyte metody mog zgosi wyjtki tej klasy, a metoda main() nie b-
dzie ich przechwytywa i obsugiwa. Jeli wyjtek zostanie zgoszony, to dziaanie
programu zostanie przerwane i maszyna wirtualna Javy wywietli stosowny komuni-
kat (np. mówicy o próbie uycia nazwy pliku ?.txt):
Exception in thread "main" java.io.FileNotFoundException: ?.txt (Nazwa pliku, nazwa
katalogu lub skadnia etykiety woluminu jest niepoprawna)
at java.io.FileOutputStream.open(Native Method)
at java.io.FileOutputStream.<init>(FileOutputStream.java:194)
at java.io.FileOutputStream.<init>(FileOutputStream.java:84)
at java.io.FileWriter.<init>(FileWriter.java:46)
at Z25_1.main(Z25_1.java:6)
Tworzymy obiekt fout klasy FileWriter skojarzony z plikiem tekst.txt w biecym

folderze. Jeli plik wczeniej nie istnia, to zostanie utworzony, natomiast w przypad-
ku pliku istniejcego jego dotychczasowa zawarto zostanie usunita.
Metoda write() wpisuje do pliku acuch znaków. Na koniec musimy pamita o za-
mkniciu pliku (metoda close()).
import java.io.FileWriter;
FileWriter fout = new FileWriter("tekst.txt");
fout.write("Programowanie obiektowe");
fout.close();
}
}

Wszelkie sytuacje bdne, zwizane z otwarciem pliku lub zapisem do pliku, wygene-
ruj wyjtek, który przerwie prac programu. Wyjtki moemy przechwyci i obsuy.
try {
FileWriter fout = new FileWriter("tekst.txt");
fout.write("Programowanie obiektowe");
fout.close();
} catch (IOException e) {
System.err.println("Bd "+e);
}
}

Uwagi przekazane w rozwizaniu zadania 25.1 pozostaj aktualne; istotn rónic jest
sposób tworzenia obiektu FileWriter fout = new FileWriter("tekst.txt", true);
— warto true drugiego parametru w konstruktorze oznacza otwarcie pliku w trybie
dopisywania na kocu pliku (podanie wartoci false spowoduje, e dotychczasowa
zawarto pliku zostanie usunita — jest to warto przyjmowana domylnie, gdy po-
miniemy drugi parametr).
Koniec wiersza uzyskamy, wpisujc do strumienia acuch zawierajcy znaki CR+LF

fout.write("\r\n") lub kady znak osobno: fout.write('\r') (CR, kod ASCII 13),
fout.write('\n') (LF, kod ASCII 10).
try {
FileWriter fout = new FileWriter("tekst.txt", true);
fout.write(" w jzyku Java\r\n");
fout.write("jest bardzo interesujce.");
fout.close();
}
}
}
Po jednokrotnym wykonaniu programu z zadania 25.1 i 25.2 plik tekstowy tekst.txt

powinien zawiera nastpujcy tekst:
Programowanie obiektowe w jzyku Java
jest bardzo interesujce.
Do tego pliku odwoamy si w dalszych zadaniach.

Podobnie jak w rozwizaniu zadania 25.1, otwieramy plik tekstowy silnia.txt do zapi-
sywania. W ptli obliczamy wartoci silni i zapisujemy wyniki do pliku. Argumentem

metody write() moe by pojedynczy znak (liczba typu int traktowana jako kod zna-
ku), tablica znaków lub acuch znaków (String). Z dwóch liczb i tekstu, wykorzystujc
waciwoci operatora konkatenacji tekstów, budujemy wiersz odpowiedzi i zapisu-
jemy go do pliku fout.write(i+"! = "+silnia). Koniec linii wpisujemy warunkowo
we wszystkich wierszach odpowiedzi z wyjtkiem ostatniego (dwunastego wiersza)
if (i < 12) fout.write("\r\n"). Na koniec zamykamy plik (fout.close()).
try {
FileWriter fout = new FileWriter("silnia.txt");
int silnia = 1;
for(int i = 1; i < 13; ++i) {
silnia *= i;
fout.write(i+"! = "+silnia);
if (i < 12)
fout.write("\r\n");
}
fout.close();
}
}
}

Zadanie to rozwizujemy podobnie jak zadanie 25.3. Liczby zamieniamy na sforma-
towane acuchy znaków przy uyciu metody format() z klasy String:
String.format("%2d\t", n) — liczba cakowita n zostanie umieszczona w dwóch
pierwszych znakach acucha, trzecim znakiem bdzie znak tabulatora '\t'.
String.format("%.12f\t", Math.sqrt(n)) — liczba zmiennoprzecinkowa,
pierwiastek kwadratowy z n, zostanie umieszczona na pocztku acucha
z dwunastoma miejscami po przecinku; za liczb bdzie dodany znak
tabulatora '\t'.
String.format("%.12f\t", Math.cbrt(n)) — liczba zmiennoprzecinkowa,
pierwiastek szecienny z n, zostanie umieszczona w acuchu z dwunastoma
miejscami po przecinku.
Znak koca linii (fout.write("\r\n")) wpisywany jest warunkowo we wszystkich

wierszach z wyjtkiem wiersza ostatniego.
try {
FileWriter fout = new FileWriter("pierwiastki.txt");
for(int n = 2; n <= 15; ++n) {

fout.write(String.format("%2d\t", n));
fout.write(String.format("%.12f\t", Math.sqrt(n)));
fout.write(String.format("%.12f", Math.cbrt(n)));
if (n < 15)
fout.write("\r\n");
}
fout.close();
}
}
}

Utworzenie pliku moemy zrealizowa podobnie jak w zadaniu 25.3 (lub 25.4). Licz-
by losujemy w ptli powtarzajcej si sto razy, korzystajc z metody random() z klasy
Math. Wylosowan liczb n zamieniamy na acuch znaków, wykonujc dodawanie
(konkatenacj) odstpu do liczby n+" ". Wynik tego dodawania zapisujemy w pliku
fout.write(n+" ") — ten odstp bdzie oddziela kolejne liczby i pojawi si na ko-
cu pliku, za ostatni liczb. Moemy sytuacj odwróci (fout.write(" "+n)) i wtedy
dodatkowy odstp pojawi si na pocztku pliku, przed pierwsz liczb. Ta sytuacja
moe by korzystniejsza podczas odczytywania liczb z pliku.
try {
FileWriter fout = new FileWriter("100.txt");
for(int i = 0; i <= 100; ++i) {
fout.write(n+" ");
}
fout.close();
}
}
}
Zadanie to moemy równie rozwiza, stosujc obiekty i metody klasy PrintWriter.

import java.io.PrintWriter;
try {
PrintWriter fout = new PrintWriter("100.txt");
for(int i = 0; i <= 100; ++i) {
fout.print(" "+n);
}
fout.close();

}
}
}
W klasie PrintWriter mamy do dyspozycji metody print(), println(), printf()

i format(), dziaajce w taki sam sposób jak wymieniane ju metody obiektu out
klasy System. Dostpna jest równie metoda write() znana z klasy FileWriter.
Uatwia to zapisywanie rónych danych do plików tekstowych.

Plik zapiszemy, uywajc metod z klasy PrintWriter (zob. rozwizanie zadania 25.5).
Zmienna x = 10*Math.random() przyjmuje wartoci z przedziau 0, 10 . Losowanie
odbywa si w ptli (typu do {...} while (x < 0.01)), wic dla wartoci mniejszych
od 0,01 losowanie jest powtarzane. Zmienna n = (int)(2+7*Math.random()) przyjmuje
wartoci cakowite od 2 do 8.
Metoda printf() formatuje par liczb i zapisuje je do pliku (fout.printf("%.2f %d",

x, n)). Przejcie do nowego wiersza jest realizowane przy uyciu metody println(),
pod warunkiem e nie jest to ostatni wiersz pliku.
try {
PrintWriter fout = new PrintWriter("dane.txt");
for(int i = 0; i < 50; ++i) {
double x;
int n;
do {
x = 10*Math.random();
} while (x < 0.01);
n = (int)(2+7*Math.random());
fout.printf("%.2f %d", x, n);
if (i < 49)
fout.println();
}
fout.close();
}
}
}

Z pakietu java.io importujemy dwie klasy: IOException i FileWriter. Tworzymy obiekt
fin klasy FileReader skojarzony z plikiem, np. silnia.txt, w biecym folderze. Jeli
plik nie istnieje, to zostanie zgoszony wyjtek FileNotFoundException.

Tworzymy zmienn typu int do przechowywania kodu odczytanego znaku (int i).
W ptli odczytujemy kod znaku i = fin.read() i jeli znak zosta odczytany (i nie
jest równe –1), to wywietlamy znak w konsoli System.out.print((char)i). Niezbdne
jest rzutowanie kodu znaku na typ char. Odczytana warto zmiennej i równa –1 oznacza
koniec pliku (nie ma dalszych znaków do odczytywania). Na koniec naley zamkn
plik (fin.close()).
import java.io.FileReader;
try {
FileReader fin = new FileReader("silnia.txt");
int i;
do {
i = fin.read();
if (i != -1) System.out.print((char)i);
} while (i != -1);
fin.close();
}
}
}
Korzystajc z metody ready(), odczytywanie i wywietlanie zawartoci pliku teksto-

wego moemy zrealizowa w nastpujcy sposób:
while (fin.ready())
System.out.print((char)fin.read());
fin.close();

Wywoujc metod readLine(), przekazujemy jako parametr f obiekt klasy FileReader
reprezentujcy otwarty plik tekstowy. Metoda readLine() odczytuje z pliku kolejne
znaki, a do chwili, gdy zostanie osignity koniec linii (CR+LF, zob. rozwizanie
zadania 25.2) lub koniec pliku (metoda read() zwróci –1). Odczytywanie znaków
odbywa si w nieskoczonej ptli. Z odczytywanych znaków budowany jest acuch
znaków, który bdzie zwrócony jako odczytany wiersz pliku tekstowego.
private static String readLine(FileReader f) throws IOException {
int c;
while (true){
c = f.read();//System.out.println(c);
if (c == 13) continue;
if (c == 10 || c == -1)
s.append((char) c);
}
}

Przeanalizujmy dziaanie ptli. Gdy nastpuje wywoanie metody read(), zmienna c

przyjmuje warto kodu odczytanego znaku lub –1. Jeli kod ma warto 13 (CR), to
przechodzimy do kolejnego cyklu (instrukcja continue), spodziewajc si znaku (LF,
kod 10). Jeli kod ma warto 10 (LF), to przerywamy dziaanie metody, zwracajc
acuch znaków (return s.toString()) — odczytany wiersz z pliku. Podobnie post-
pimy, gdy osigniemy koniec pliku (c == –1). W pozostaych przypadkach dodajemy
do acucha s odczytany znak s.append((char) c).
Obsuga wyjtków wygenerowanych podczas dziaania metody readLine() zostanie

przekazana do metody wywoujcej (w tym przypadku do metody main()).
Analiza kodu reszty programu nie wymaga szerszego komentarza — podobna sytuacja
zostaa omówiona w rozwizaniu zadania 25.7.
/* Tu wstaw kod metody readLine(). */

try {
while (fin.ready())
System.out.println(readLine(fin));
fin.close();
}
}
}

W klasie BufferdReader zdefiniowano metod readLine(), któr wykorzystamy do
odczytywania wiersza tekstu (z konsoli i z pliku).
Tworzymy obiekt isr klasy InputStreamReader bdcy poczeniem bajtowego stru-

mienia danych (np. System.in — standardowe wejcie) ze strumieniem znakowym:
InputStreamReader isr = new InputStreamReader(System.in);
Nastpnie tworzymy obiekt br klasy BuffeeredReader opakowujcy obiekt isr:

BufferedReader br = new BufferedReader(isr);
Moemy ten zapis uj w jednym wierszu programu (bez tworzenia zmiennej obiek-
towej isr):
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Teraz moemy odczytywa wiersze tekstu z konsoli — w ten sposób wprowadzimy

nazw pliku String filename = br.readLine(). Zamykamy utworzone strumienie

(metod close()) i tworzymy obiekt File file = new File(filename+".java"). Metoda

exists() z klasy File umoliwi nam sprawdzenie, czy plik o podanej nazwie istnieje.
Jeli plik istnieje, to moemy przystpi do odczytywania go wierszami i wywietla-

nia tych wierszy w konsoli wraz z ich numerami.
FileReader fr = new FileReader(file);
br = new BufferedReader(fr);
String s;
int n = 0; // licznik wierszy
while((s = br.readLine()) != null) {
System.out.printf("%3d. %s\n", ++n, s);
}
fr.close();
Zwrómy uwag na sposób utworzenia obiektu fr — w konstruktorze parametrem jest

obiekt file (dotychczas, w zadaniach 25.7 i 25.8, parametrem tym bya nazwa pliku).
Obiekt br klasy BufferedReader opakowuje obiekt fr (klasy FileReader) i umoliwia
odczytywanie wierszy z pliku.
Do wywietlania numeru wiersza (n) i zawartoci wiersza (s) uyjemy metody printf()
umoliwiajcej sformatowanie wyniku: System.out.printf("%3d. %s\n", ++n, s).
import java.io.InputStreamReader;
import java.io.BufferedReader;
class Z25_9 {
public static void main(String args[]) throws Exception {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
System.out.print("Podaj nazw pliku bez rozszerzenia: ");
String filename = br.readLine();
br.close();
isr.close();
File file = new File(filename+".java");
if (file.exists()) {
FileReader fr = new FileReader(file);
br = new BufferedReader(fr);
String s;
int n = 0;
while((s = br.readLine()) != null)
System.out.printf("%3d. %s\r\n", ++n, s);
fr.close();
} else
System.out.println("Nie znaleziono pliku: "+filename
+".java");
}
}
Do wczytywania danych z konsoli i wierszy z pliku moemy uy obiektów klasy

Scanner. Przedstawimy to w rozwizaniu kolejnego zadania (25.10).


Do odczytywania danych z konsoli uyjemy obiektu (skanera) klasy Scanner skojarzo-
nego ze strumieniem System.in (Scanner cin = new Scanner(System.in)) i metody
nextLine(). Z konsoli odczytamy nazw pliku: String filename = cin.nextLine().
Po sprawdzeniu, czy plik istnieje, tworzymy plik wyjciowy o tej samej nazwie i roz-
szerzeniu .txt oraz obiekt fout klasy PrintWriter, umoliwiajcy zapisywanie danych
do tego pliku:
PrintWriter fout = new PrintWriter(new File(filename+".txt"));
Tworzymy skaner skojarzony z plikiem danych (Scanner fin = new Scanner(file)),

sucy do odczytywania danych z tego pliku.
Odczytywanie wierszy z pliku zorganizujemy w ptli (while) ze sprawdzaniem wa-

runku na pocztku — metoda hasNextLine() zwraca warto true, gdy w pliku jest
kolejna linia do odczytania. Odczytany z pliku wiersz (s = fin.nextLine()) wraz
z poprzedzajcym go numerem (fout.printf("%3d. %s\r\n", ++n, s)) zapisujemy
w pliku wyjciowym.
/** Zadanie Z25.10 */
class Z25_10 {
Scanner cin = new Scanner(System.in);
System.out.print("Podaj nazw pliku bez rozszerzenia: ");
String filename = cin.nextLine();
cin.close();
File file = new File(filename+".java");
if (file.exists()) {
PrintWriter fout
= new PrintWriter(new File(filename+".txt"));
Scanner fin = new Scanner(file);
String s;
int n = 0;
while(fin.hasNextLine()) {
s = fin.nextLine();
System.out.printf("%3d. %s\r\n", ++n, s);
fout.printf("%3d. %s\r\n", ++n, s);
}
fin.close();
fout.close();
} else
System.out.println("Nie znaleziono pliku: "+filename+".java");
}
}

Do odczytywania danych z pliku uyjemy obiektu i metod z klasy Scanner (zob. roz-
wizanie zadania 25.10). Metoda hasNextInt() sprawdza, czy nastpnym tokenem
w strumieniu jest liczba cakowita, a metoda nextInt() odczytuje liczb cakowit ze

strumienia. Jeli w strumieniu znajdzie si token róny od liczby cakowitej, to wczy-
tywanie i sumowanie danych zostanie zakoczone. W przypadku poprawnie zbudowa-
nego pliku zakoczenie sumowania nastpi po odczytaniu z niego wszystkich liczb.
/** Zadanie Z25.11 */
class Z25_11 {
File file = new File("sto.txt");
int suma = 0, n;
while(fin.hasNextInt()) {
n = fin.nextInt();
suma += n;
System.out.printf("%d ", n);
}
fin.close();
System.out.println("Suma liczb: "+suma);
}
}
Nieznaczna modyfikacja kodu pozwoli na pomijanie tych tokenów, które nie s licz-
bami cakowitymi:
while(fin.hasNext()) {
if (fin.hasNextInt()) {
n = fin.nextInt();
suma += n;
System.out.printf("%d ", n);
} else
fin.next();
}
Po tej zmianie moemy sprawdzi dziaanie programu dla plików silnia.txt (zsumo-
wane zostan tylko wartoci silni, tokeny o postaci 5! lub = bd pominite), pierwia-
stek.txt (suma liczb z pierwszej kolumny), tekst.txt (otrzymamy sum równ zeru, bo
ten plik nie zawiera adnej liczby) itp.

Zakadamy, e plik wejciowy jest zbudowany poprawnie. Wczytywanie danych zre-
alizujemy tak jak w rozwizaniu zadania 25.11. Wprowadzimy trzy zmienne cakowite:
min — do przechowywania wartoci minimalnej, cmin — licznik wystpie wartoci
minimalnej, n — aktualnie odczytywana liczba.
Pierwsz odczytan liczb uznajemy za minimaln, licznik wartoci minimalnych usta-

wiamy na 1. Nastpnie odczytujemy kolejne liczby. Wartoci wiksze od minimalnej
pomijamy; gdy napotkamy warto równ minimalnej, to zwikszamy licznik (cmin)
o 1. Jeli odczytana liczba jest mniejsza od minimalnej, to staje si now wartoci
minimaln i w tym przypadku ponownie ustawiamy licznik (cmin) na 1.

/** Zadanie Z25.12 */

class Z25_12 {
File file = new File("sto.txt");
int min = 0, cmin = 0;
if (fin.hasNextInt()) {
min = fin.nextInt();
cmin = 1;
}
while(fin.hasNextInt()) {
int n = fin.nextInt();
if (n > min)
continue;
else if (n == min)
++cmin;
else {
min = n;
cmin = 1;
}
}
fin.close();
System.out.println("Warto minimalna: "+min);
System.out.println("Liczba wystpie : "+cmin);
}
}
Instrukcja warunkowa wewntrz ptli zostaa utworzona zgodnie z wczeniejszym opi-

sem. Moemy ten fragment kodu zrealizowa inaczej (bez uycia instrukcji continue).
if (n == min)
++cmin;
else if (n < min) {
min = n;
cmin = 1;
}

Plik dane.txt zawiera pewn liczb wierszy tekstu, a w kadym wierszu zapisane s
dwie liczby oddzielone biaym znakiem (np. odstpem). Pierwsza z tych liczb jest liczb
zmiennoprzecinkow, a druga — liczb cakowit. Zakadamy, e budowa pliku jest
poprawna. Do odczytywania liczb z pliku wykorzystamy obiekt fin klasy Scanner
i metody nextDouble() (do odczytania pierwszej liczby w wierszu) oraz nextInt() (do
odczytania kolejnej liczby w wierszu).
Deklarujemy i inicjujemy zmienn suma, suc do obliczania sumy iloczynów par

liczb zapisanych w pliku (double suma = 0.0). Dopóki w pliku s kolejne tokeny do
odczytania (fin.hasNext() zwraca warto true), w ptli typu while odczytujemy
z pliku liczb zmiennoprzecinkow (double x = fin.nextDouble();) i liczb cakowit
(int n = fin.nextInt()), obliczamy iloczyn odczytanych liczb i dodajemy wynik do
sumy (suma += x*n). Po odczytaniu wszystkich liczb zamykamy plik (fin.close()).

Otwieramy ponownie plik dane.txt, tym razem w trybie do dopisywania (FileWriter

fout = new FileWriter(file, true)) i dopisujemy na kocu pliku odpowied .
/** Zadanie Z25.13 */
class Z25_13 {
File file = new File("dane.txt");
double suma = 0.0;
while(fin.hasNext()) {
double x = fin.nextDouble();
int n = fin.nextInt();
suma += x*n;
}
fin.close();
System.out.printf("Suma iloczynów: %.2f\r\n", suma);
/* Dopisanie wyniku do pliku */
FileWriter fout = new FileWriter(file, true);
fout.write("\r\nSuma iloczynów: ");
fout.write(String.format("%.2f", suma));
fout.close();
}
}
26. Tablice jednowymiarowe

i wielomiany
Korzystajc z obiektu cin klasy Scanner, wczytujemy stopie wielomianu (n) i two-
rzymy tablic n+1-elementow do przechowywania wspóczynników wielomianu
(double[] w = new double[n+1]). W ptli (typu for — znamy liczb wspóczynników)
odczytujemy z konsoli wartoci wspóczynników wielomianu w[i], zaczynajc od wy-
razu wolnego. Ostatni wspóczynnik (w[n]) powinien by róny od zera (sprawdzenie
tego faktu w przykadzie pominito). W takim przypadku moemy przerwa dziaanie
programu lub zmniejszy stopie wielomianu i zwizany z tym rozmiar tablicy, odci-
najc kocowe wyrazy o wartoci 0 (powrócimy do tego w kolejnych zadaniach).
Obliczenia wartoci wielomianu zrealizujemy w ptli ze sprawdzaniem warunku na

kocu (argument x = 0 powoduje przerwanie ptli). Do oblicze zastosujemy pry-
wat metod horner() z dwoma parametrami — tablic wspóczynników wielomianu
w i argumentem x (typu double).
Metoda Hornera obliczania wartoci wielomianu polega na nastpujcym spostrzeeniu:

w( x) an x n an1 x n 1 ... a1 x a0 ...a x a x a x ...x a x a
n n 1 n2 1 0 .

Aby uproci zapis algorytmu, wprowadzimy ma modyfikacj wzoru:

w( x) an x n an1 x n1 ... a1 x a0 ...0 x a x a x a x ...x a x a
n n 1 n2 1 0 .
Pocztkowo przyjmujemy wart = 0. W pierwszym cyklu obliczamy wyraenia (wart

*= x; wart += w[i];) 0 x an an — zmienna wart zawiera warto wspóczynnika
an — w drugim cyklu liczymy an x an 1 , w trzecim an x an1 x an2 itd. Po sko-
czonym cyklu oblicze zmienna wart zawiera obliczon warto wielomianu. Zauwa-
my, e wspóczynniki odczytujemy od koca tablicy do pocztku (od wspóczynnika
przy jednomianie najwyszego stopnia do wyrazu wolnego).
private static double horner (double[] w, double x) {
int st = w.length-1;
double wart = 0;
for(int i = st; i >= 0; --i) {
wart *= x;
wart += w[i];
}
return wart;
}
Scanner cin = new Scanner(System.in);
System.out.print("Podaj stopie wielomianu, n = ");
int n = cin.nextInt();
double[] w = new double[n+1];
System.out.println("Wprowad
wspóczynniki wielomianu: ");
for(int i = 0; i <= n; ++i) {
System.out.print("w["+i+"] = ");
w[i] = cin.nextDouble();
}
System.out.println("Obliczanie wartoci wielomianu w(x):");
System.out.println("(argument x=0 - zako czenie oblicze )");
double x;
do {
x = cin.nextDouble();
System.out.printf("w(%.2f) = %.4f\r\n", x, horner(w,x));
} while (x != 0);
}
}
W kolejnych zadaniach obliczenia wykonamy dla ustalonych wielomianów. Czytelnik moe

zmodyfikowa kod programów tak, aby wspóczynniki wielomianów mona byo wprowadza
z konsoli (zob. rozwizanie zadania 26.1).
W przykadach podajemy wspóczynniki cakowite, ale dopuszczalne jest równie uycie wspó-
czynników uamkowych.


Do obliczania wartoci wielomianu zastosujemy metod horner() omówion w roz-
wizaniu zadania 26.1. Dane i wyniki zapiszemy w pliku, uywajc metod z klasy
PrintWriter. Komentarze w kodzie ródowym objaniaj kolejne etapy rozwizywa-
nia zadania.
/* Tu wstaw kod metody horner z zadania 26.1. */

/* Wielomian 2x^3+5x^2-x+3 */
double[] w = {3, -1, 5, 2};
/* Przedzia i krok oblicze */
double a = -2.0;
double b = 3.0;
double h = 0.125;
/* Zapisywanie do pliku */
PrintWriter fout = new PrintWriter("wielomian.txt");
/* Stopie wielomianu */
fout.printf("%d", w.length-1);
fout.println();
/* Wspóczynniki wielomianu */
for(int i = 0; i < w.length; ++i)
fout.printf("%.2f ", w[i]);
fout.println();
/* Przedzia i krok oblicze */
fout.printf("%.2f %.2f %.3f", a, b, h);
fout.println();
/* Zapisywanie wartoci wielomianu */
double x = a;
do {
fout.printf("%.3f %.4f", x, horner(w,x));
fout.println();
x += h;
} while (x < b);
/* Zamknicie pliku */
fout.close();
}
}

Jeli dodajemy dwa wielomiany stopni m i n, to otrzymujemy wielomian co najwyej
stopnia max(m, n), np.
3x 2
2 x 4 ( x 3 x 5) x 3 3x 2 x 1 .
W przypadku m = n suma wielomianów moe mie niszy stopie (gdy wspóczynni-

ki przy x w najwyszej potdze s liczbami przeciwnymi), np.
3x 2
2 x 4 (3 x 2 x 5) 0x2 x 1 x 1.

Wspóczynniki wielomianów moemy wprowadzi z klawiatury, tak jak w rozwiza-

niu zadania 26.1. W przykadzie ograniczymy si do dwóch wielomianów, których
wspóczynniki umiecimy bezporednio w kodzie programu (tablice a i b). Podczas
wypisywania wielomianu w konsoli (a waciwie jego wspóczynników) wykorzy-
stamy statyczn metod toString() z klasy Arrays, która zamienia tablic na acuch
znaków zawierajcy elementy tablicy oddzielone przecinkami, umieszczone w nawia-
sie prostoktnym.
Tworzymy tablic s do przechowywania wyniku (sumy), o wymiarze takim, jaki ma

tablica przechowujca wielomian wyszego stopnia (max(a.length, b.length)). Z obu
tablic bierzemy kolejno elementy o indeksach od 0 do min(a.length, b.length), do-
dajemy je i sum wpisujemy w odpowiednim miejscu tablicy przechowujcej wynik.
Nastpnie z tej tablicy, która ma wikszy rozmiar, przepisujemy reszt elementów do
tablicy s.
Jeli ostatni wyraz tablicy s ma warto 0, co moe zdarzy si wycznie wtedy, gdy
dugoci tablic a i b (stopnie dodawanych wielomianów) s równe, usuwamy ten wy-
raz z tablicy (postpowanie bdzie prowadzone do chwili uzyskania ostatniego wspó-
czynnika w tablicy rónego od zera lub uzyskania wielomianu stopnia zerowego):
if(s[s.length-1] == 0) {
int n = s.length;
while (s[n-1] == 0 && n > 1) --n;
s = Arrays.copyOf(s, n);
}
Skrócenie tablicy moemy zrealizowa, uywajc statycznej metody copyOf() z klasy

Arrays — pierwszy parametr jest kopiowan tablic, a drugi liczb kopiowanych ele-
mentów. Wynik kopiowania przypisujemy do tablicy s.
double[] a = {-1, 4, 3, 5, 2, 1};
System.out.println("a = "+Arrays.toString(a));
double[] b = {3, -4, 2, 1};
System.out.println("b = "+Arrays.toString(b));
double[] s = new double[Math.max(a.length, b.length)];
int i = 0;
for(i = 0; i < Math.min(a.length, b.length); ++i)
s[i] = a[i]+b[i];
if (a.length > b.length)
while (i < a.length) {
s[i] = a[i];
++i;
}
else if (a.length < b.length)
while (i < b.length) {
s[i] = b[i];
++i;
}
else if(s[s.length-1] == 0) {
int n = s.length;

while (s[n-1] == 0 && n > 1) --n;

s = Arrays.copyOf(s, n);
}
System.out.println("Suma wielomianów: ");
System.out.println("a+b = "+Arrays.toString(s));
}
}
Moemy zbudowa metod korekta(), która usunie z koca tablicy wszystkie elementy
o wartoci 0 (elementy zerowe wewntrz tablicy musz bezwzgldnie pozosta).
private static double[] korekta(double[] w) {
int n = w.length;
while (w[n-1] == 0 && n > 1) --n;
return Arrays.copyOf(w, n);
}
W szczególnym przypadku zwracana tablica moe zawiera tylko jeden element odpo-
wiadajcy wielomianowi zerowego stopnia. Metod t moemy wykorzysta do skory-
gowania ostatecznego wyniku (if(s[s.length-1] == 0) s = korekta(s);) lub danych
wejciowych (np. a = korekta(a)) wprowadzonych przez uytkownika programu.

Zadanie to rozwiemy podobnie jak zadanie 26.3. Naley zwróci uwag na przypadek,
gdy odejmowany wielomian ma wyszy stopie ni wielomian, od którego odejmujemy.
for(i = 0; i < Math.min(a.length, b.length); ++i)
s[i] = a[i]-b[i]; // obliczanie rónicy
if (a.length > b.length)
while (i < a.length) {
s[i] = a[i];
++i;
}
else if (a.length < b.length)
while (i < b.length) {
s[i] = -b[i]; // zmiana znaku wspóczynników
++i;
}
else if(s[s.length-1] == 0)
s = korekta(s);
Zmiany zaznaczono dodatkowymi komentarzami.

Mnoenie wielomianu przez liczb rón od zera (liczby przez wielomian — dziaa-
nie jest przemienne) polega na pomnoeniu wszystkich wspóczynników wielomianu
przez t liczb, np. 2 3 x 2 2 x 4 6 x 2 4 x 8 . Stopie wielomianu nie ulega
przy tym zmianie. Jeli liczba równa jest 0, to w wyniku mnoenia otrzymamy wie-
lomian zerowy.


double[] a = {-1, 4, 2, 1};
double b = -2;
/* Iloczyn wielomianu przez liczb (rón od zera) */
double[] w = new double[a.length];
for(int i = 0; i < a.length; ++i)
w[i] = a[i]*b;
System.out.println("Iloczyn wielomianu a przez liczb b: ");
System.out.println("a*b = "+Arrays.toString(w));
}
}

Mnoc dwa niezerowe wielomiany stopnia m i n, otrzymujemy niezerowy wielomian
stopnia m+n. Mnoymy kady wyraz jednego wielomianu przez kady wyraz drugie-
go wielomianu i otrzymane jednomiany dodajemy (po uporzdkowaniu jednomianów
wzgldem ich stopnia — postpujemy tak, wykonujc obliczenia na kartce). W pro-
gramie wygodnie bdzie dodawa jednomiany na bieco, zaraz po ich obliczeniu
(w[i+j] += a[i]*b[j]).
double[] a = {-1, 4, 2, 1};
double[] b = {3, -4, 2, 1, 2};
System.out.println("b = "+Arrays.toString(b));
/* Iloczyn wielomianów */
double[] w = new double[a.length+b.length-1];
for(int j = 0; j < b.length; ++j)
w[i+j] += a[i]*b[j];
System.out.println("Iloczyn wielomianów: ");
System.out.println("a*b = "+Arrays.toString(w));
}
}
Stopie wielomianu a jest równy a.length-1, stopie wielomianu b jest równy

b.length-1, wic stopie iloczynu wielomianów wynosi a.length+b.length-2. Std
wynika deklaracja double[] w = new double[a.length+b.length-1] — rozmiar
tablicy jest o 1 wikszy od stopnia wielomianu.

Pochodna wielomianu jest wielomianem (stopnia o 1 niszego)
c
a x n
n
an1 x n 1 ... a1 x a0 nan x n1 (n 1)an 1 x n ... a1 .


double[] a = {-1, 4, 2, 1};
/* Pochodna wielomianu */
double[] w = new double[a.length-1];
w[i] = a[i+1]*(i+1);
System.out.println("Pochodna wielomianu: ");
System.out.println("a\' = "+Arrays.toString(w));
}
}

Caka nieoznaczona (funkcja pierwotna) wielomianu jest wielomianem (stopnia o 1
wyszego) an x n an1 x n 1 ... a1 x a0 dx
an n1 an1 n
³ n 1
x
n
x ... a0 c , gdzie
c jest dowoln sta. W programie przyjmiemy c = 0.
double[] a = {-1, 4, 2, 1};
/* Caka wielomianu (funkcja pierwotna) */
double[] w = new double[a.length+1];
w[i+1] = a[i]/(i+1);
w[0] = 0; // moe by dowolna staa c
System.out.println("Caka (funkcja pierwotna) wielomianu: ");
System.out.println("A = "+Arrays.toString(w));
}
}
Zadanie 26.9. Polynomial.java, Z26_9.java

Na pocztek w klasie Polynomial umiecimy konstruktor z jednym parametrem, tabli-
c liczb typu double. Poniewa uytkownik moe wskaza jako parametr tablic za-
wierajc warto 0 bdc ostatnim elementem (lub nawet kilka kocowych elemen-
tów bdzie miao warto 0), wic w konstruktorze wykorzystamy metod korekta(),
zdefiniowan w rozwizaniu zadania 26.4 (metod t wczamy do klasy).
W klasie Polynomial przesaniamy dziedziczon z klasy java.lang.Object metod

toString(); zwracany acuch znaków jest zgodny ze wskazówk z zadania 26.3.
public class Polynomial {
private double[] w;
private static double[] korekta(double[] a) {
int n = a.length;
while (a[n-1] == 0 && n > 1) --n;

return Arrays.copyOf(a, n);

}
public Polynomial(double[] a) {
a = korekta(a);
w = new double[a.length];
this.w[i] = a[i];
}
return Arrays.toString(this.w);
}
}
Do klasy doczymy kilka metod. Na podstawie rozwizania zadania 26.1 budujemy

publiczn metod horner(), obliczajc warto wielomianu reprezentowanego przez
obiekt dla argumentu podanego jako parametr wywoania metody.
public double horner(double x) {
double y = 0.0;
for(int i = w.length-1; i >= 0; --i) {
y *= x;
y += this.w[i];
}
return y;
}
Metod add(), która do wielomianu reprezentowanego przez wywoujcy j obiekt

bdzie dodawa wielomian reprezentowany przez parametr a, konstruujemy na pod-
stawie rozwizania zadania 26.3. Dziaanie wykonujemy na dwóch tablicach: this.w
(wstawiamy w miejsce tablicy a) i a.w (w miejsce b).
public Polynomial add(Polynomial a) {
double[] s = new double[Math.max(this.w.length, a.w.length)];
int i = 0;
for(i = 0; i < Math.min(this.w.length, a.w.length); ++i)
s[i] = this.w[i]+a.w[i];
if (this.w.length > a.w.length)
while (i < this.w.length) {
s[i] = this.w[i];
++i;
}
else if (this.w.length < a.w.length)
while (i < a.w.length) {
s[i] = a.w[i];
++i;
}
korekta(s);
return new Polynomial(s);
}
Podobnie skonstruujemy metod sub(), która od wielomianu reprezentowanego przez

wywoujcy j obiekt bdzie odejmowa wielomian reprezentowany przez parametr
a. Pamitajmy o uwadze (o zmianie znaków) z rozwizania zadania 26.4.

public Polynomial sub(Polynomial a) {

double[] s = new double[Math.max(this.w.length, a.w.length)];
int i = 0;
for(i = 0; i < Math.min(this.w.length, a.w.length); ++i)
s[i] = this.w[i]-a.w[i];
if (this.w.length > a.w.length)
while (i < this.w.length) {
s[i] = this.w[i];
++i;
}
else if (this.w.length < a.w.length)
while (i < a.w.length) {
s[i] = -a.w[i];
++i;
}
korekta(s);
return new Polynomial(s);
}
Na podstawie rozwizania zadania 26.5 zbudujemy metod mult(), która wielomian

reprezentowany przez wywoujcy j obiekt bdzie mnoy przez liczb typu double
podan jako parametr.
public Polynomial mult(double a) {
double[] tmp = new double[w.length];
tmp[i] = this.w[i]*a;
return new Polynomial(tmp);
}
Przeciajc metod mult(), zrealizujemy mnoenie wielomianu przez wielomian (na

podstawie rozwizania zadania 26.6).
public Polynomial mult(Polynomial a) {
double[] tmp = new double[this.w.length+a.w.length-1];
for(int i = 0; i < this.w.length; ++i)
for(int j = 0; j < a.w.length; ++j)
tmp[i+j] += this.w[i]*a.w[j];
}
Na podstawie rozwizania zadania 26.7 zbudujemy metod derivative() (ang. deri-

vative — pochodna), wyznaczajc pochodn wielomianu reprezentowanego przez
obiekt wywoujcy metod.
public Polynomial derivative() {
double[] tmp = new double[this.w.length-1];
for(int i = 0; i < tmp.length; ++i)
tmp[i] = this.w[i+1]*(i+1);;
}
Natomiast wzorujc si na rozwizaniu zadania 26.8, utworzymy metod integral()

(ang. integral — caka), wyznaczajc funkcj pierwotn wielomianu reprezentowa-
nego przez obiekt.

public Polynomial integral() {

double[] tmp = new double[this.w.length+1];
for(int i = 0; i < this.w.length; ++i)
tmp[i+1] = this.w[i]/(i+1);
tmp[0] = 0;
}
Analiz wierszy programu demonstrujcego moliwoci klasy Polynomial pozostawia-

my Czytelnikowi.
import java.util.*;
double[] a = {-1, 4, 2, 1, 0};
Polynomial w1 = new Polynomial(a);
System.out.println(Arrays.toString(a));
System.out.println("Wartoci wielomianu w1(x) dla x z przedziau
<0,5; 2,0> z krokiem 0,25.");
double x = 0.5;
while (x <= 2.0) {
System.out.printf("w1(%4.2f) = %8.4f\n", x, w1.horner(x));
x += 0.25;
}
double[] b = {2, -4, 3, -3, 5, 1};
Polynomial w2 = new Polynomial(b);
System.out.println("Suma w1+w2 = "+w1.add(w2));
System.out.println("Suma w2+w1 = "+w2.add(w1));
System.out.println("Rónica w1-w2 = "+w1.sub(w2));
System.out.println("Rónica w2-w1 = "+w2.sub(w1));
System.out.println("Iloczyn w1*2 = 2*w1 = "+w1.mult(2));
System.out.println("Iloczyn w2*(-1) = (-1)*w2 = "+w2.mult(-1));
System.out.println("Iloczyn w1*w2 = "+w1.mult(w2));
System.out.println("Iloczyn w2*w1 = "+w2.mult(w1));
System.out.println("Pochodna (w1)\' = "+w1.derivative());
System.out.println("Pochodna (w2)\' = "+w2.derivative());
System.out.println("Funkcja pierwotna dla w1: "+w1.integral());
System.out.println("Funkcja pierwotna dla w2: "+w2.integral());
System.out.println("Wielomian w1 = "+w1);
System.out.println("Pochodna z funkcji pierwotnej (dla w1): "+
w1.integral().derivative());
System.out.println("Funkcja pierwotna z pochodnej (dla w1): "+
w1.derivative().integral());
}
}

Wielomian w( x ) an x n an 1 x n 1 ... a1 x a0 moemy przedstawi w postaci
w( x )
( x c) bn 1 x n 1 bn 2 x n 2 ... b0 r
.
bn 1 x bn 2 cbn 1 x
n n 1
bn 3 cbn 2 x n 2 ... b0 cb1 x r cb0

Porównujc obie postacie wielomianu, uzyskamy:

bn 1 an , bn 2 cb n 1 an 1 , bn 3 cbn 2 an 2 , ..., b0 cb1 a1 , r cb0 a0 .
Po uporzdkowaniu wyrae otrzymamy ostateczn posta serii wzorów
opisujcych wspóczynniki wielomianu b i reszt z dzielenia r:
bn 1 an , bn 2 an 1 cbn 1 , bn 3 an 2 cbn 2 , ..., b0 a1 cb1 , r a0 cb0 .
Podany algorytm dzielenia wielomianu przez dwumian (x–c) nazywamy
schematem Hornera (dzielenia wielomianu przez dwumian).
/** Zadanie Z26.10 */
double[] a = {-1, 4, 2, 1};
System.out.println("Wielomian a = "+Arrays.toString(a));
double c = -2;
System.out.printf("Dwumian (x-c) = (x%+.2f)\n",(-c));
/* Dzielenie wielomianu przez dwumian x-c */
double[] w = new double[a.length-1];
double r;
int i = w.length-1;
w[i] = a[i+1];
while (i > 0) {
w[i-1] = a[i]+w[i]*c;
--i;
}
r = a[i]+w[i]*c;
System.out.println("a:(x-c) = "+Arrays.toString(w)+", r = "+r);
}
}

Na podstawie rozwizania zadania 26.10 moemy utworzy metod division(), obli-
czajc iloraz wielomianu przez dwumian (x–c) i zwracajc wynik w postaci nowego
obiektu Polynomial. Powsta reszt z dzielenia w tym przypadku pomijamy.
public Polynomial division(int c) {
int i = tmp.length-1;
tmp[i] = this.w[i+1];
while (i > 0) {
tmp[i-1] = this.w[i]+tmp[i]*c;
--i;
}
}
Reszt z dzielenia wielomianu przez dwumian (x–c) zwróci nam metoda remainder().
Tym razem pomijamy uzyskany w trakcie oblicze iloraz (wielomian tmp) i zwraca-
my jedynie reszt (liczb typu double).
public double remainder(int c) {

int i = tmp.length-1;
tmp[i] = this.w[i+1];
while (i > 0) {
tmp[i-1] = this.w[i]+tmp[i]*c;
--i;
}
return this.w[i]+tmp[i]*c;
}
Stosujc obie zdefiniowane metody, moemy wykonywa dzielenie z reszt wielomia-

nu przez dwumian o postaci (x–c). Przedstawia to nastpujcy przykad:
/** Zadanie Z26.11 */
double[] a = {1, 0, 0, 1};
Polynomial w = new Polynomial(a);
System.out.println("Wielomian w = "+w);
double c = -1;
System.out.println("w:(x-c) = "+w.division(-1));
System.out.println("r = "+w.remainder(-1));
}
}

Zadanie zostao rozwizane dla danych przykadowych. Kod potrzebny do wprowa-
dzenia danych z klawiatury (stopnia wielomianu, tablicy wspóczynników t i granic
cakowania a i b) pozostawiamy do napisania Czytelnikowi.
W rozwizaniu zadania istotne s trzy kroki: utworzenie obiektu reprezentujcego

wielomian Polynomial w = new Polynomial(t), wyznaczenie funkcji pierwotnej dla
wielomianu Polynomial f = w.integral() i obliczenie wartoci caki oznaczonej
double s = f.horner(b)-f.horner(a).
/** Zadanie Z26.12 */
/* Dane przykadowe */
double[] t = {1, -3, 3, -2, 1};
double a = -2;
double b = 3;
/* Tworzenie obiektów i obliczenia */
Polynomial w = new Polynomial(t);
System.out.println("Wielomian w = "+w);
System.out.printf("Granice cakowania\na = %.2f\nb = %.2f\n",
a, b);
Polynomial f = w.integral(); // funkcja pierwotna
double s = f.horner(b)-f.horner(a); // caka oznaczona
System.out.printf("Caka oznaczona s = %.4f\n", s);
}
}


Jeli liczby x1 , x2 , ..., xn s jedynymi pierwiastkami wielomianu, to wielomian moe-
my przedstawi w postaci iloczynu w( x ) ( x x1 ) ( x x2 ) ... ( x xn ) . Wykorzy-
stamy ten wzór do wyznaczenia wspóczynników wielomianu w przypadku, gdy zna-
ne s jego pierwiastki.
Zaczniemy od zbudowania wielomianu w( x ) 1 :

double[] tmp = {1};
Polynomial w = new Polynomial(tmp);
Nastpnie bdziemy mnoy ten wielomian przez dwumiany o postaci ( x xi ) dla i =

1, 2, …, n. Tworzymy tablic dwuelementow tmp, która posuy nam do budowania
dwumianów o postaci (x–c). Ustalamy wspóczynnik stojcy przy x (tmp[1] = 1). Wpro-
wadzamy z konsoli liczb pierwiastków n. W ptli (for(int i = 0; i < n; ++i)) wczy-
tujemy kolejne pierwiastki (tmp[0] = -input.nextDouble() — zwrómy uwag na
zmian znaku wczytanej wartoci) i wykorzystujemy je do zbudowania obiektu
Polynomial reprezentujcego dwumian (new Polynomial(tmp)). Mnoymy wielomian w
przez dwumian i podstawiamy wynik do zmiennej w (w = w.mult(new Polyno-
mial(tmp)).
Po wyjciu z ptli wywietlamy wynik.

/** Zadanie Z26.13 */
double[] tmp = {1};
Polynomial w = new Polynomial(tmp);
tmp = new double[2];
tmp[1] = 1;
System.out.print("Liczba pierwiastków, n = ");
for(int i = 0; i < n; ++i) {
System.out.print("Pierwiastek, x = ");
tmp[0] = -input.nextDouble();
w = w.mult(new Polynomial(tmp));
}
System.out.println("w = "+w);
}
}
27. Obliczenia statystyczne

Zadanie 27.1. 27_1.java
Wyznaczamy element maksymalny i element minimalny, a nastpnie obliczamy ró-
nic midzy nimi.

System.out.println("Próbka:");
double[] x = {1.35, 2.45, 2.05, 1.20, 2.15, 1.70, 1.45, 1.95,
2.00, 1.65, 1.65, 2.05, 1.75, 1.25, 2.25, 1.40};
System.out.println(Arrays.toString(x));
/* Element minimalny */
double minX = x[0];
for (double xi: x)
if (xi < minX)
minX = xi;
System.out.println("Element minimalny: "+minX);
/* Element maksymalny */
double maxX = x[0];
for (double xi: x)
if (xi > maxX)
maxX = xi;
System.out.println("Element maksymalny: "+maxX);
/* Rozstp badanej cechy */
double r = maxX-minX;
System.out.println("Rozstp badanej cechy: "+r);
}
}
Element maksymalny i minimalny moemy wyznaczy w jednej ptli. Zamiast instruk-

cji warunkowych i porównywania mona zastosowa metody klasy Math.
double minX = x[0];
double maxX = x[0];
for (double xi: x) {
minX = Math.min(minX, xi);
maxX = Math.max(maxX, xi);
}
Moemy równie posortowa tablic w porzdku niemalejcym i wtedy pierwszy ele-

ment bdzie elementem minimalnym, a ostatni maksymalnym.
Arrays.sort(x); // sortowanie tablicy
System.out.println("Element minimalny: "+x[0]);
System.out.println("Element maksymalny: "+x[x.length-1]);
System.out.println("Rozstp badanej cechy: "+(x[x.length-1]-x[0]));

Ustalamy warto pocztkow sumy elementów (double sa = 0.0) i w ptli dodaje-
my do sumy kolejne elementy próbki. Po zakoczeniu sumowania dzielimy sum przez
liczb elementów próbki i otrzymujemy warto redniej arytmetycznej badanej próbki.
Wynik zaokrglamy do dwóch miejsc po przecinku.
double sa = 0.0;
for(double xi: x)
sa += xi;
sa /= n;
System.out.println("rednia arytmetyczna: "+zaokr(sa));

Rozwizania zada 27.2 – 27.19 bd zbudowane wedug schematu (XX — oznacza jedno-
lub dwucyfrowy numer zadania):
public class Z27_XX {
public static double zaokr(double x) {
double prec = 100.0;
return (int)(x*prec+0.5)/prec;
}

double[] x = {1.35, 2.45, 2.05, 1.20, 2.15, 1.70, 1.45, 1.95,
2.00, 1.65, 1.65, 2.05, 1.75, 1.25, 2.25, 1.40};
int n = x.length; // liczba elementów
/* Tu wstawimy rozwizanie zadania. */
}
}
W odpowiedziach do zada podamy wycznie fragmenty kodu odpowiedzialne za rozwizanie
problemu zawartego w zadaniu.
Zaokrglenie wyniku w tym i kolejnych zadaniach wykonujemy przy uyciu statycz-

nej metody zaokr():
}
Algorytm zaokrglania liczb przedstawimy na dwóch przykadach:
x x*100 x*100+0.5 (int)(x*100+0.5) (int)(x*100+0.5)/100

2,7136 271,36 271,86 271 2,71
3,5481 354,81 355,31 355 3,55

Najpierw obliczamy iloczyn wszystkich n elementów próbki — ustalamy pocztkow
warto iloczynu (double sg = 1.0) i nastpnie w ptli mnoymy t warto przez
kolejne elementy (xi) próbki, przechowujc w zmiennej sg kolejne obliczone iloczy-
ny (sg *= xi). Wartoci elementów próbki musz by nieujemne.
Z iloczynu wszystkich elementów próbki obliczamy pierwiastek n-tego stopnia (sg =

n
Math.pow(sg, 1.0/n)) i uzyskujemy redni geometryczn próbki ( g n xi ).
i 1
/* rednia geometryczna - wzór nr 1 */

double sg = 1.0;

for(double xi: x)
sg *= xi;
sg = Math.pow(sg, 1.0/n);
System.out.println("rednia geometryczna: "+zaokr(sg));
Jeli wartoci elementów próbki s dodatnie, to moemy zastosowa wasnoci loga-

n n
1 1 n
rytmów log g log n xi
n
log xi ¦ log xi , czyli rednia geometryczna
ni 1
i 1 i 1
1 n
¦ log x i
ni 1
g e .
/* rednia geometryczna - wzór nr 2 */
double lnsg = 0;
for(double xi: x)
lnsg += Math.log(xi);
lnsg /= n;
double sg = Math.exp(lnsg);
System.out.println("rednia geometryczna: "+zaokr(sg));

rednia harmoniczna cigu liczb jest odwrotnoci redniej arytmetycznej odwrotno-
ci tych liczb. Wszystkie liczby musz by róne od zera. Suma odwrotnoci równie
musi by róna od zera. Najpierw obliczamy sum odwrotnoci tych liczb (sh), potem
wyraenie sh/n (redni arytmetyczn odwrotnoci) i jego odwrotno n/sh, która
jest ostatecznym wynikiem (sh = n/sh). Zwrómy przy tym uwag na wykorzystanie
zmiennej sh, która ma w czasie oblicze róne interpretacje.
double sh = 0.0;
for(double xi: x)
sh += 1/xi;
sh = n/sh;
System.out.println("rednia harmoniczna: "+zaokr(sh));

/* rednia potgowa rzdu 2. */
double sp2 = 0.0;
for(double xi: x)
sp2 += Math.pow(xi, 2);
sp2 = Math.pow(sp2/n, 1.0/2);
System.out.println("rednia potgowa rzdu 2.: "+zaokr(sp2));
Podstawienie sp2 = Math.pow(sp2/n, 1.0/2); mona zastpi równowanym wzorem

sp2 = Math.sqrt(sp2/n); (obliczanie pierwiastka kwadratowego).
/* rednia potgowa rzdu 3. */
double sp3 = 0.0;
for(double xi: x)
sp3 += Math.pow(xi, 3);
sp3 = Math.pow(sp3/n, 1.0/3);
System.out.println("rednia potgowa rzdu 3.: "+zaokr(sp3));

W tym przykadzie równie wyraenie Math.pow(sp3/n, 1.0/3) mona zastpi wy-

raeniem Math.cbrt(sp3/n) (obliczanie pierwiastka trzeciego stopnia). W ogólnym
przypadku jest to wyraenie o postaci Math.pow(sp/n, 1.0/r), gdzie r oznacza rzd
redniej potgowej, a sp — jej warto. Warto jednak (przy duej iloci oblicze) za-
stanowi si nad zastpieniem metody obliczajcej potgi (Math.pow()) szybszym
mnoeniem lub wasn metod — obliczajc potgi o wykadniku cakowitym —
o postaci:
static double power(double a, int n) {
double p = 1.0;
for(int i = 0; i< n; ++i)
p *= a;
return p;
}

Median moemy wyznaczy po posortowaniu próbki.
/* Sortowanie próbki */
Arrays.sort(x);
System.out.println("Posortowane:\n"+Arrays.toString(x));
Przy wyborze elementu rodkowego naley pamita o rozbienoci pomidzy indek-

sowaniem elementów próbki (od 1 do n) a indeksowaniem tablicy, rozpoczynajcym
si od 0.
double me;
if (n%2 == 1)
me = x[(n-1)/2]; // n jest nieparzyste, rodek posortowanej próbki
else
me = (x[n/2-1]+x[n/2])/2; // n parzyste, rednia wartoci rodkowych
System.out.println("Mediana: "+me);

Zacznijmy od zdefiniowania struktury, która pozwoli nam na przechowywanie próbki
w postaci szeregu rozdzielczego punktowego. W klasie Dane s dwa publiczne pola:
double x, do przechowywania wartoci elementu próbki, oraz int n, zawierajce liczb
powtórze tej wartoci.
class Dane {
public
double x;
int n;
}
Próbk wprowadzamy do tablicy:

double[] x = {1.35, 2.45, 2.05,1.35, 1.2, 1.35, 1.20, 2.15, 1.70, 1.45,
1.95, 2.00, 1.65, 1.65, 2.05, 1.75, 1.35, 2.25, 1.65};
Tablic sortujemy (naley importowa klas java.util.Arrays):

Arrays.sort(x);

Nastpnie musimy policzy, ile rónych wartoci zawiera próbka. Zewntrzna ptla
typu while pozwala na przejrzenie wszystkich wartoci próbki (tablicy x), natomiast
wewntrzna ptla pomija kolejne, powtarzajce si wartoci (tablica x jest posortowa-
na w kolejnoci niemalejcej). Licznik (zmienna licznik) jest inkrementowany tylko
wtedy, gdy nastpny element jest róny od biecego.
int n = x.length;
int i = 0;
int licznik = 0;
while (i < n) {
while (i < n-1 && x[i+1] == x[i])
++i;
++licznik;
++i;
}
Teraz zmienna licznik zawiera liczb rónych wartoci w badanej próbce. Moemy
utworzy tablic o odpowiednim rozmiarze i zbudowa szereg rozdzielczy punktowy.
Dane[] y = new Dane[licznik];
i = 0;
int j = 0;
while (i < n) {
/* przechowanie kolejnej wartoci próbki w szeregu rozdzielczym */
y[j] = new Dane();
y[j].x = x[i];
/* liczenie powtórze tej wartoci */
y[j].n = 1;
while (i < n-1 && x[i+1] == x[i]) {
++i;
++y[j].n;
}
/* nastpna warto */
++j;
++i;
}
W tablicy y mamy uporzdkowany niemalejco, ze wzgldu na warto, szereg roz-

dzielczy. Pozostaje nam poszukiwanie dominanty. Zmienna boolean jest na koniec
bdzie zawieraa informacj, czy w szeregu jest dominanta (na pocztek zakadamy
jest = true). Zmienna dominanta (typu Dane) bdzie zawieraa warto dominanty
(pole x), o ile ona istnieje, i liczb jej wystpie (pole n).
Dane dominanta = new Dane();
/* warto pocztkowa, mniejsza od wszystkich wartoci próbki */
dominanta.x = y[0].x - 1;
dominanta.n = 0;
boolean jest = true;
/* W pierwszym cyklu poniszej ptli, pierwszy element tablicy y
zostanie uznany za dominant. */
for(Dane w: y) {
/* Jeli liczba wystpie kolejnej wartoci jest równa liczbie
wystpie wartoci uznawanej za dominant, to dominanta nie
istnieje. */
if (w.n == dominanta.n)

jest = false;
/* Znaleziono kolejn warto , która moe by dominant. */
else if (w.n > dominanta.n) {
dominanta.x = w.x;
dominanta.n = w.n;
jest = true;
}
}
Pozostaje sformuowanie ostatecznej odpowiedzi:

if (jest) {
System.out.println("Dominanta D = "+dominanta.x);
System.out.println("Liczba wystpie dominanty: "+dominanta.n);
} else
System.out.println("W próbce nie ma dominanty");

redni arytmetyczn sa badanej próbki obliczymy w sposób przedstawiony w zada-
niu 27.2. Do obliczenia wariancji (dyspersji) zastosujemy kolejno podane wzory:
System.out.println("Obliczenie wariancji wedug wzoru:");
System.out.print("Wzór nr 1: ");
double s2 = 0.0;
for(double xi: x)
s2 += Math.pow(xi-sa, 2);
s2 /= n;
System.out.println(s2);
s2 = 0.0;
for (double xi: x)
s2 += Math.pow(xi, 2);
s2 /= n;
s2 -= sa*sa;
double a = 2.0; // dowolna liczba, np. 2.0
s2 = 0.0;
for(double xi: x)
s2 += Math.pow(xi-a, 2);
s2 /= n;
s2 -= Math.pow(sa-a, 2);
Wykorzystan do obliczania kwadratów liczb metod Math.pow() warto zastpi mno-

eniem lub metod sqr() zbudowan samodzielnie:
static double sqr(double x) {
return x*x;
}


Obliczymy redni arytmetyczn próbki i wariancj s2 (zmienna s2) na podstawie roz-
wizania zada 27.2 i 27.8 (jeden wybrany wzór) oraz odchylenie standardowe (pier-
wiastek kwadratowy z wariancji):
double s = Math.sqrt(s2);
System.out.println("Odchylenie standardowe: "+zaokr(s));

Odchylenie przecitne od staej a obliczymy, sumujc bezwzgldne wartoci odchy-
le xi (elementów tablicy) od staej wartoci a i dzielc otrzyman sum przez liczb
elementów próbki x.length (rozmiar tablicy).
double a = 2.0; // warto staej a
double d = 0.0;
for(double xi: x)
d += Math.abs(xi-a);
d /= x.length;
System.out.print("Odchylenie przecitne od staej a = "+a);
System.out.println(" jest równe "+zaokr(d));
Poniewa odchylenie przecitne próbki (od rónych wartoci) jest czsto obliczane, to
zdefiniujemy metod:
static double odchyleniePrzec(double[] x, double a) {
double d = 0.0;
for(double xi: x)
d += Math.abs(xi-a);
return d/x.length;
}
i zastosujemy j do wykonania oblicze.

System.out.print("Odchylenie przecitne od staej a = "+a);
System.out.println(" jest równe "+zaokr(odchyleniePrzec(x, a)));
Metod t moemy wykorzysta równie w rozwizywaniu kolejnych zada — 27.11

i 27.12.

Obliczymy redni arytmetyczn sa próbki na podstawie rozwizania zadania 27.2,
a nastpnie odchylenie przecitne d1 od redniej arytmetycznej:
double d1 = 0.0;
for(double xi: x)
d1 += Math.abs(xi-sa);
d1 /= n;
System.out.print("Odchylenie przecitne od redniej arytmetycznej: ");
System.out.println(zaokr(d1));
Moemy te zastosowa metod odchyleniePrzec(), zbudowan w rozwizaniu za-

dania 27.10:

System.out.print("Odchylenie przecitne od redniej arytmetycznej: ");

System.out.println(zaokr(odchyleniePrzec(x, sa)));

Obliczymy median me próbki na podstawie rozwizania zadania 27.6, a nastpnie od-
chylenie przecitne d2 od mediany:
double d2 = 0.0;
for(double xi: x)
d2 += Math.abs(xi-me);
d2 /= n;
System.out.print("Odchylenie przecitne od mediany: ");
System.out.println(zaokr(d2));
Moemy te zastosowa metod odchyleniePrzec(), zbudowan w rozwizaniu za-

dania 27.10:
System.out.print("Odchylenie przecitne od mediany: ");
System.out.println(zaokr(odchyleniePrzec(x, me)));

Zaczniemy od posortowania próbki. Rozwaajc róne warianty dugoci próbki, wy-
znaczymy pooenie mediany (drugiego kwartyla Q2) lub indeksów elementów su-
cych do jej wyznaczenia. Dzielimy próbk na dwie czci: elementy mniejsze od me-
diany i median oraz median i elementy wiksze od mediany. Dla pierwszej czci
wyznaczamy median — to bdzie dolny kwartyl (inaczej: pierwszy kwartyl) Q1. Gór-
nym (trzecim) kwartylem Q3 jest mediana drugiej czci.
Zwizek pomidzy kwartylami i wartociami próbki w posortowanej tablicy przedsta-

wiono w tabeli.
Liczebno próbki Q1 Q2 Q3
ªn º ªnº
ªnº x « 1» x « » ª 3n º
n = 4k x« » ¬2 ¼ ¬2¼ x « 1»
¬4¼ ¬4 ¼
2
ª n 1º ª n 1º ª 3n 3 º
n = 4k+1 x« x« x«
¬ 4 »¼ ¬ 2 »¼ ¬ 4 »¼
ªn 2º ªn 2º ªn º ªnº ª 3n 6 º ª 3n 2 º
x« x x « 1» x « » x« x
n = 4k+2 ¬ 4 »¼ «¬ 4 »¼ ¬2 ¼ ¬2¼ ¬ 4 »¼ «¬ 4 »¼
2 2 2
ª n 3 º ª n 1º ª 3n 5 º ª 3n 1º
x« x ª n 1º x« x
n = 4k+3 ¬ 4 »¼ «¬ 4 »¼ x« ¬ 4 »¼ «¬ 4 »¼
¬ 2 »¼
2 2
static double zaokr(double x) {


}

double[] x = {1.35, 2.45, 2.35, 1.20, 2.15, 1.70, 1.45, 1.95,
2.00, 1.65, 1.85, 2.05, 1.75, 1.25, 2.25, 2.05};
System.out.println("Próbka: \n"+Arrays.toString(x));
/* Sortowanie */
Arrays.sort(x);
System.out.println("Próbka posortowana: \n"+Arrays.toString(x));
int n = x.length;
double Q1 = 0.0, Q3 = 0.0;
switch (n%4) {
case 0:
Q1 = x[n/4];
Q3 = x[3*n/4-1];
break;
case 1:
Q1 = x[(n-1)/4];
Q3 = x[(3*n-3)/4];
break;
case 2:
Q1 = (x[(n-2)/4]+x[(n+2)/4])/2;
Q3 = (x[(3*n-6)/4]+x[(3*n-2)/4])/2;
break;
case 3:
Q1 = (x[(n-3)/4]+x[(n+1)/4])/2;
Q3 = (x[(3*n-5)/4]+x[(3*n-1)/4])/2;
break;
}
double Q = (Q3-Q1)/2;
System.out.println("Kwartyl dolny Q1: "+Q1);
System.out.println("Kwartyl górny Q3: "+Q3);
System.out.println("Odchylenie wiartkowe: "+Q);
}
}

Ze wzgldu na du liczb obliczanych potg o wykadniku naturalnym wykorzysta-
my metod power() z rozwizania zadania 27.6.
/* Moment zwyky m2 rzdu 2. */
double m2 = 0.0;
for(double xi: x)
m2 += power(xi, 2);
m2 /= n;
System.out.print("Moment zwyky m2 rzdu 2.");
System.out.println(" jest równy: "+zaokr(m2));
Powyszy fragment kodu moemy skopiowa i zmodyfikowa w celu obliczenia mo-

mentu zwykego m3 (trzeciego rzdu) i m4 (czwartego rzdu). Wygodniej jednak bdzie
na podstawie tego kodu zbudowa metod obliczajc moment zwyky rzdu podane-
go jako drugi parametr:

static double momentZw(double[] x, int rz) {

double m = 0.0;
for(double xi: x)
m += power(xi, rz);
return m/x.length;
}
i w ptli obliczy dane momenty zwyke:

/* Momenty zwyke 2., 3. i 4. rzdu */
for(int r=2; r < 5; ++r) {
System.out.printf("Moment zwyky rzdu "+r);
System.out.println(" jest równy "+zaokr(momentZw(x, r)));
}

W sposób znany z poprzednich zada najpierw obliczamy redni arytmetyczn sa
badanej próbki, a nastpnie moment centralny zwyky. W obliczeniach wykorzystamy
metod power() z zadania 27.6.
/* Moment centralny M2 rzdu 2. */
double M2 = 0.0;
for(double xi: x)
M2 += power(xi-sa, 2);
M2 /= n;
System.out.print("Moment centralny M2 rzdu 2.");
System.out.println(" jest równy: "+zaokr(M2));
W podobny sposób obliczymy momenty centralne M3 (trzeciego rzdu) i M4 (czwarte-

go rzdu).
Zamiast takiego rozwizania proponujemy metod:

static double momentCent(double[] x, int rz, double sa) {
double m = 0.0;
for(double xi: x)
m += power(xi-sa, rz);
return m/x.length;
}
i obliczenia w ptli:
/* Momenty centralne 2., 3. i 4. rzdu */
for(int r=2; r < 5; ++r) {
System.out.printf("Moment centralny rzdu "+r);
System.out.println(" jest równy "+zaokr(momentCent(x, r, sa)));
}
Ostatni (trzeci) parametr metody momentCent() jest redni arytmetyczn próbki. Mo-
emy zbudowa metod bez tego parametru, która obliczy najpierw redni arytme-
tyczn, a potem moment centralny zwyky.
static double momentCent(double[] x, int rz) {
double sa = 0.0; // rednia arytmetyczna
for(double xi: x)
sa += xi;
sa /= x.length;

double m = 0.0; // moment centralny zwyky

for(double xi: x)
return m/x.length;
}
W tym przypadku nie bdzie potrzebne wczeniejsze liczenie redniej arytmetycznej

w programie.
for(int r=2; r < 5; ++r) {
System.out.printf("Moment centralny rzdu "+r);
System.out.println(" jest równy "+zaokr(momentCent(x, r)));
}
Obie metody (z dwoma i trzema parametrami) mog istnie w tej samej klasie, pod
jedn (przecion) nazw momentCent.

Zadanie rozwizujemy w sposób analogiczny do zadania 27.14. Porównujc wzór na
1 n l
moment zwyky rzdu l ml
n i1 ¦
xi , l N ze wzorem na moment absolutny zwyky
n
¦| x | ,
1
rzdu l al i
l
l N , dostrzeemy rónic, któr naley uwzgldni w kodzie:
n i 1
for(double xi: x)
a += power(Math.abs(xi), rz);

Zadanie rozwizujemy w sposób analogiczny do zadania 27.15. Porównujc wzór na
1 n
moment centralny rzdu l M l
n i1 ¦
( xi x ) l , l N ze wzorem na moment abso-
1 n
lutny centralny rzdu l bl
n i1 ¦
| xi x |l , l N , dostrzeemy rónic, któr naley
uwzgldni w kodzie. Zamiast:

for(double xi: x)
napiszemy:
for(double xi: x)
a += power(Math.abs(xi-sa), rz);

Obliczamy kolejno redni arytmetyczn sa (27.2), wariancj s2 (27.8) i odchylenie
standardowe s (27.9). Na tej podstawie wyznaczymy:
/* Wspóczynnik zmiennoci v */
double v = s/sa*100;
System.out.println("Wspóczynnik zmiennoci: "+zaokr(v)+"%");


Obliczamy redni arytmetyczn sa i odchylenie przecitne od redniej arytmetycznej d1.
/* Wspóczynnik nierównomiernoci H */
double h = d1/sa*100;
System.out.println("Wspóczynnik nierównomiernoci: "+zaokr(h)+"%");
Zadanie 27.20. Stat.java, Z27_20.java

W klasie Stat (public class Stat {...}) umiecimy zestaw metod statycznych wy-
konujcych obliczenia na elementach tablicy jednowymiarowej double[] x (próbki)
przekazanej jako parametr.
Zaczniemy od metody zaokr() z jednym parametrem x, zaokrglajcej przekazany

argument do dwóch miejsc po przecinku i zwracajcej zaokrglony wynik.
}
Przeciajc metod zaokr(), dodamy drugi parametr n — liczb cakowit wyraaj-

c liczb miejsc po przecinku w wyniku.
public static double zaokr(double x, int n) {
double prec = Math.pow(10, n);
}
Na podstawie rozwizania zadania 27.1 zbudujemy metody minX() i maxX() wyzna-

czajce warto minimaln i maksymaln z badanej próbki (tablicy).
public static double minX(double[] x) {
double min = x[0];
for(double xi: x)
if (xi < min) min = xi;
return min;
}
public static double maxX(double[] x) {
double max = x[0];
for(double xi: x)
if (xi > max) max = xi;
return max;
}
Majc warto minimaln i maksymaln, moemy wyznaczy rozstp.

public static double rozstX(double[] x) {
return maxX(x)-minX(x);
}
Kolejna metoda oblicza redni arytmetyczn (zob. zadanie 27.2).

public static double srednArytm(double[] x) {
double sa = 0.0;
for(double xi: x)

sa += xi;
return sa/x.length;
}
W ten sposób na podstawie rozwizanych zada od 27.3 do 27.19 zbudujemy kolejne

metody statyczne. Zredagowanie komentarzy dokumentacyjnych i utworzenie doku-
mentacji klasy pozostawiamy Czytelnikowi (zob. rozdzia 19., „Dokumentacja klasy”).
W przykadzie pokazano rozwizania zada 27.1 i 27.2 wykorzystujce statyczne me-

tody z klasy Stat.
double[] x = {1.35, 2.45, 2.05, 1.20, 2.15, 1.70, 1.45, 1.95,
2.00, 2.10, 1.50, 2.05};
System.out.println("Warto minimalna: "+Stat.minX(x));
System.out.println("Warto maksymalna: "+Stat.maxX(x));
System.out.print("Rozstp badanej cechy w próbce: ");
System.out.println(Stat.zaokr(Stat.rozstX(x)));
System.out.print("rednia arytmetyczna: ");
System.out.println(Stat.zaokr(Stat.srednArytm(x)));
}
}
Zadanie 27.21. Statpr.java, Z27_21.java

Klasa Statpr zawiera jedno prywatne pole pr bdce referencj do tablicy double[]
zawierajcej badan próbk i konstruktor.
public class Statpr {
private
double[] pr;
public Statpr(double[] x) {
pr = new double[x.length];
pr = Arrays.copyOf(x, x.length);
}
}
Konstruktor tworzy obiekt zawierajcy tablic o rozmiarze identycznym z rozmiarem

tablicy przekazanej jako parametr (badana próbka) i kopiuje zawarto parametru do
obiektu.
Do klasy kopiujemy kody metod zaokr() (zob. rozwizanie zadania 27.20).

}
public static double zaokr(double x, int n) {
double prec = Math.pow(10, n);
}

Metody statyczne z klasy Stat (zob. rozwizanie zadania 27.20 lub rozwizania zada
od 27.1 do 27.19) przeksztacamy na metody dziaajce na polu pr obiektu klasy Statpr.
public double minX() {
double min = pr[0];
for(double xi: pr)
if (xi < min) min = xi;
return min;
}
public double maxX() {

double max = pr[0];
for(double xi: pr)
if (xi > max) max = xi;
return max;
}
public double rozstX() {

return this.maxX()-this.minX();
}
public double srednArytm() {

double sa = 0.0;
for(double xi: pr)
sa += xi;
return sa/pr.length;
}
W ten sam sposób budujemy dalsze metody. Nie naley zapomnie o przesoniciu
metody toString() z klasy Object (metoda ta uatwi wywietlanie danych w konsoli):
return Arrays.toString(pr);
}
Komentarze dokumentacyjne i opracowanie dokumentacji pozostawiamy Czytelniko-

wi (zob. rozdzia 19.).
W przykadzie pokazano rozwizania zada 27.1 i 27.2 wykorzystujce obiekt a kla-

sy Stat.
static double[] x = {1.35, 2.45, 2.05, 1.20, 2.15, 1.70, 1.45, 1.95,
2.00, 2.10, 1.50, 2.05};
Statpr a = new Statpr(x);
System.out.println("Próbka:\n"+a);
System.out.println("Warto minimalna: "+a.minX());
System.out.println("Warto maksymalna: "+a.maxX());
System.out.print("Rozstp badanej cechy w próbce: ");
System.out.println(Statpr.zaokr(a.rozstX()));
System.out.print("rednia arytmetyczna: ");
System.out.println(Statpr.zaokr(a.srednArytm()));
}
}

28. Tablice wielowymiarowe i macierze

Deklarujemy tablic liczb cakowitych o trzech wierszach i dziesiciu kolumnach
(int[][] a = new int[3][10]). Wiersze maj indeksy 0, 1 i 2, a kolumny 0, 1, 2, …,
9. W ptli for indeks i zmienia si od 0 do 9, co daje nam kolejno dostp do kolumn
tablicy. W pierwszym wierszu podstawiamy a[0][i] = i+1 (liczby o 1 wiksze od
indeksu, czyli 1, 2, …, 10), w drugim a[1][i] = a[0][i]*a[0][i] (kwadraty liczb
z pierwszego wiersza) i w trzecim a[2][i] = a[1][i]*a[0][i] (iloczyn pierwszego
i drugiego wiersza, czyli szecian pierwszego wiersza).
Tablica dwuwymiarowa jest po prostu tablic tablic (tablic trzech wierszy, a kady
wiersz jest tablic dziesiciu liczb cakowitych). Przekonamy si o tym podczas wy-
wietlania zawartoci tablicy dwuwymiarowej na ekranie:
for(int[] x: a)
W ptli for pobieramy z tablicy a jednowymiarowe tablice x (typu int[]), które wy-
wietlamy w konsoli po ich zamianie na acuch znaków (Arrays.toString(x)).
int[][] a = new int[3][10];
for(int i = 0; i < 10; ++i) {
a[0][i] = i+1;
a[1][i] = a[0][i]*a[0][i];
a[2][i] = a[1][i]*a[0][i];
}
for(int[] x: a)
}
}
Wynik wywietlany jest w postaci:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
Zamiast zamienia tablic x na acuch znaków, moemy ponownie zastosowa ptl

for i uzyska dostp do jej elementów. Zagniedone ptle for i metoda printf() po-
zwol na przejrzyste wywietlenie tablicy dwuwymiarowej.
for(int[] x: a) {
for(int n: x)
System.out.printf("%5d", n);
}

Inn moliwoci, chyba najbardziej rozpowszechnion, jest wykorzystanie dostpu

do elementów tablicy przy uyciu indeksów:
for(int i = 0; i < a.length; ++i) {
for(int j = 0; j < a[i].length; ++j)
System.out.printf("%5d", a[i][j]);
}
Tablica jest obiektem i pole length zawiera rozmiar tablicy:

a.length — liczba wierszy tablicy dwuwymiarowej a,
a[i].length — liczba elementów i-tego wiersza tablicy a (liczba kolumn).
W tych dwóch przypadkach otrzymany rezultat przedstawia si nastpujco:

1 2 3 4 5 6 7 8 9 10
1 4 9 16 25 36 49 64 81 100
1 8 27 64 125 216 343 512 729 1000

Deklarujemy tablic dwuwymiarow o dziesiciu wierszach, nie podajc liczby kolumn
(int[][] a = new int[10][]). W ptli deklarujemy kady wiersz oddzielnie, ustalajc
rozmiar (liczb kolumn) o 1 wikszy od indeksu wiersza (a[i] = new int[i+1]). Po
zadeklarowaniu wiersza wypeniamy go kolejnymi liczbami naturalnymi (for(int j
= 0; j <= i; ++j) a[i][j] = n++;).
Wywietlanie tablicy zrealizujemy przy wykorzystaniu dwóch zagniedonych ptli

for i metody printf(). Do obliczenia sum uyjemy równie dwóch ptli; w wewntrz-
nej ptli bdziemy sumowa liczby w wierszu, a w zewntrznej obliczymy sum wier-
szy, czyli sum wszystkich liczb z tablicy.
/* Deklaracja i wypenienie tablicy */
int[][] a = new int[10][];
int n = 1;
for(int i = 0; i < 10; ++i) {
a[i] = new int[i+1];
for(int j = 0; j <= i; ++j)
a[i][j] = n++;
}
/* Wywietlanie tablicy */
System.out.printf("%5d", a[i][j]);
}
/* Sumowanie liczb */
int suma = 0;
int wiersz = 0;

wiersz += a[i][j];
System.out.printf("Suma liczb w %d. wierszu : %d\n",
i, wiersz);
suma += wiersz;
}
System.out.printf("Suma liczb w tablicy: %d\n", suma);
}
}

W klasie TInt do wprowadzania danych do tablicy wykorzystamy obiekt cin (ang.
console input) klasy Scanner. Obiekt cin zdefiniowano w klasie jako prywatne i sta-
tyczne pole; jest on dostpny dla wszystkich metod tej klasy.
W wersji podstawowej metoda input() posiada jeden parametr — dwuwymiarow

tablic liczb cakowitych (int[][] x). Zewntrzna ptla for wskazuje kolejne wiersze
tablicy, ptla wewntrzna wskazuje elementy w wierszu. W konsoli jest wywietlany
znak zachty w postaci acucha ?[i][j] = (gdzie i — numer wiersza, j — numer
kolumny wprowadzanego elementu tablicy) i uytkownik moe wprowadzi warto
elementu tablicy (x[i][j] = cin.nextInt()).
Metoda print() równie ma jeden parametr — dwuwymiarow tablic liczb cako-

witych. W zagniedonych ptlach for pobieramy i wywietlamy elementy tablicy
oddzielone odstpami. Po wywietleniu ostatniego elementu w wierszu przechodzimy
na pocztek nowej linii.
public class TInt {
private static Scanner cin = new Scanner(System.in);
public static void input(int[][] x) {

for(int i = 0; i < x.length; ++i)
for(int j = 0; j < x[i].length; ++j) {
System.out.printf("?[%d][%d] = ", i, j);
x[i][j] = cin.nextInt();
}
}
public static void print(int[][] x) {

for(int i = 0; i < x.length; ++i) {
for(int j = 0; j < x[i].length; ++j)
System.out.printf("%d ", x[i][j]);
}
}
}
Na podstawie metody input() z jednym parametrem warto zbudowa metody z dwo-

ma parametrami — pierwszy parametr jest znakiem (char) lub acuchem znaków
(String), drugi parametr jest wczytywan tablic. W pierwszym parametrze przeka-
zujemy nazw tablicy (znak lub acuch znaków). Ta informacja bdzie wywietlana
podczas wprowadzania danych, np. a[0][1] = lub tablica[2][3] =. Poprawi to czy-
telno programu.

public static void input(char name, int[][] x) {

System.out.printf("%c[%d][%d] = ", name, i, j);
}
}
public static void input(String name, int[][] x) {

System.out.printf("%s[%d][%d] = ", name, i, j);
}
}
Modyfikacja kodu metod input() pozwoli na zastosowanie ich do wczytywania tablic

jednowymiarowych.
public static void input(int[] x) {
System.out.printf("?[%d] = ", i);
x[i] = cin.nextInt();
}
}
public static void input(char name, int[] x) {

System.out.printf("%c[%d] = ", name, i);
}
}
public static void input(String name, int[] x) {

System.out.printf("%s[%d] = ", name, i);
}
}
Równie metod print() dostosujemy do wywietlania tablic jednowymiarowych.

public static void print(int[] x) {
System.out.printf("%d ", x[i]);
}
W przykadowej aplikacji wczytujemy i wywietlamy zawarto dwuwymiarowych

tablic a i b oraz tablicy jednowymiarowej, bdcej czci (wierszem) tablicy dwu-
wymiarowej.
int[][] a = new int[2][3];
TInt.input(a);
TInt.print(a);

int[][] b = new int[2][2];

TInt.input('b', b);
TInt.print(b);
TInt.input("a[1]", a[1]);
TInt.print(a[1]);
}
}

W klasie Tint importujemy dodatkowo klas Random (import java.util.Random;)
oraz tworzymy prywatny statyczny obiekt rnd (private static Random rnd = new
Random();). Obiekt rnd i metod nextInt() z klasy Random wykorzystamy do losowa-
nia wartoci elementów tablicy.
public static void setRandom(int[][] x, int n) {
x[i][j] = rnd.nextInt(n+1);
}
Wylosowane liczby cakowite s nieujemne i mniejsze od n+1, czyli nale do prze-

dziau 0, n . Podobnie budujemy metod wypeniajc wylosowanymi liczbami ta-
blic jednowymiarow.
public static void setRandom(int[] x, int n) {
x[i] = rnd.nextInt(n+1);
}
W przykadowym programie wypeniamy liczbami cakowitymi pseudolosowymi z za-

kresu od 0 do 100 tablic dwuwymiarow a. Tablic jednowymiarow b wypeniamy
liczbami z zakresu od 0 do 5.
int[][] a = new int[5][4];
TInt.setRandom(a, 100);
TInt.print(a);
int[] b = new int[10];
TInt.setRandom(b, 5);
TInt.print(b);
}
}

Podczas wywietlania tablic wielowymiarowych korzystne bdzie wypisywanie liczb
w kolumnach o ustalonej szerokoci. Format wywietlanych liczb przekazujemy jako
pierwszy parametr, np. "%d " (liczba znaków zaley od wartoci wywietlanej liczby;
po liczbie dodajemy jeden odstp), "%10d" (staa szeroko pola, 10 znaków).
public static void printf(String format, int[][] x) {

System.out.printf(format, x[i][j]);
}
}
public static void printf(String format, int[] x) {

System.out.printf(format, x[i]);
}
Demonstrujc dziaanie metody printf(), wywietlamy w kolumnach o szerokoci

piciu znaków tablic dwuwymiarow o piciu wierszach i czterech kolumnach, wy-
penion pseudolosowymi wartociami z zakresu od 0 do 100.
int[][] a = new int[5][4];
TInt.printf("%5d", a);
}
}

Skopiujemy zawarto pliku TInt.java do pliku TDouble.java. Poprawimy nazw klasy
TInt na TDouble. W nagówkach metod zamienimy typ parametru int[][] na double[][]
(oraz int[] na double[]). W kodzie metod input zmienimy cin.nextInt() na cin.next-
Double(). W metodach setRandom() zmienimy drugi parametr int n na double y oraz
wyraenie losujce rnd.nextInt(n+1) na y*rnd.nextDouble(). W ten sposób przekszta-
cilimy klas TInt na klas TDouble, uatwiajc pobieranie i wypisywanie danych oraz
losowe ustawianie wartoci w jedno- i dwuwymiarowych tablicach liczb typu double.
Demonstrujc moliwoci klasy, wypenimy liczbami z przedziau 0; 10,0 tablic

dwuwymiarow i wywietlimy jej zawarto w kolumnach, które bd miay szeroko
omiu znaków i bd zawiera liczby z trzema miejscami po przecinku.
double[][] a = new double[5][4];
TDouble.setRandom(a, 10.0);
TDouble.printf("%8.3f", a);
}
}

Zdefiniujemy metod sum() dodajc dwie macierze (tablice dwuwymiarowe) i zwra-
cajc wynik w takiej samej postaci. Sprawdzamy zgodno wymiarów macierzy. Jeli
wymiary nie s identyczne, to metoda rzuca wyjtek ("Niezgodne wymiary macierzy").
Tworzymy tablic tmp o wymiarach takich samych jak parametry x i y. W zagnie-
donych ptlach for dodajemy elementy tablic (tmp[i][j] = x[i][j]+y[i][j]). Jako
wynik zwracamy tablic tmp.

public static double[][] sum (double[][] x, double[][] y) {

if (x.length != y.length || x[0].length != y[0].length)
throw new ArithmeticException("Niezgodne wymiary macierzy");
double[][] tmp = new double[x.length][x[0].length];
tmp[i][j] = x[i][j]+y[i][j];
return tmp;
}
Demonstrujc dziaanie metody sum(), dodamy dwie macierze wypenione wyloso-

wanymi wartociami typu double.
/* Tu wstaw kod metody sum(). */
double[][] b = new double[5][4];
TDouble.setRandom(b, 10.0);
double[][] c = sum(a, b);
System.out.println("Macierz A");
System.out.println("Macierz B");
TDouble.printf("%8.3f", b);
System.out.println("Suma macierzy C = A+B");
TDouble.printf("%8.3f", c);
}
}
Na podstawie zdefiniowanej metody sum() moemy zbudowa podobn metod dla

tablic dwuwymiarowych z elementami cakowitymi lub dla tablic jednowymiarowych.

Odejmowanie macierzy przedstawimy na przykadzie macierzy o elementach cako-
witych. Wzorujc si na rozwizaniu zadania 28.7, utworzymy metod difference()
obliczajc rónic macierzy.
public static int[][] difference (int[][] x, int[][] y) {
if (x.length != y.length || x[0].length != y[0].length)
int[][] tmp = new int[x.length][x[0].length];
tmp[i][j] = x[i][j]-y[i][j];
return tmp;
}
Testujc dziaanie metody difference(), obliczymy rónic dwóch macierzy o ele-

mentach cakowitych, ustalonych w sposób losowy. Metod setRandom() z klasy TInt
moemy zastpi metod input() i wprowadzi wyrazy macierzy z konsoli.


/* Tu wstaw kod metody difference(). */
int[][] a = new int[3][6];
int[][] b = new int[3][6];
int[][] c = difference(a, b);
TInt.printf("%5d", b);
System.out.println("Rónica macierzy C = A-B");
TInt.printf("%5d", c);
}
}

Iloczyn dwóch macierzy moemy policzy tylko wtedy, gdy liczba kolumn pierwszej
macierzy (x[0].length) jest równa liczbie wierszy drugiej macierzy (y.length), w prze-
ciwnym wypadku metoda powinna zgosi wyjtek. Wynik jest macierz o liczbie
wierszy równej liczbie wierszy pierwszej macierzy (x.length) i liczbie kolumn równej
liczbie kolumn drugiej macierzy (y[0].length):
int[][] tmp = new int[x.length][y[0].length];
W dwóch zagniedonych ptlach obliczymy wszystkie elementy macierzy (tablicy)

m
bdcej iloczynem. Zgodnie ze wzorem cij ¦ aik bkj obliczamy w kolejnej ptli su-
k 1
m m (y.length) iloczynów elementów z wiersza i pierwszej macierzy przez elementy
kolumny j drugiej macierzy.
for(int k = 0; k < y.length; ++k)
tmp[i][j] += x[i][k]*y[k][j];
Oto kompletny kod metody mnocej dwie macierze:

public static int[][] product (int[][] x, int[][] y) {
if (x[0].length != y.length)
int[][] tmp = new int[x.length][y[0].length];
for(int j = 0; j < y[0].length; ++j)
tmp[i][j] += x[i][k]*y[k][j];
return tmp;
}
Dla macierzy (tablic) typu double wystarczy w kodzie zamieni typ tablic z int na
double. Demonstrujc dziaanie metody, pomnoymy dwie przykadowe macierze (wy-
penione losowymi wartociami).
/* Tu wstaw kod metody product(). */


int[][] a = new int[2][3];
int[][] b = new int[3][6];
int[][] c = product(a, b);
TInt.printf("%3d", b);
System.out.println("Iloczyn macierzy C = A*B");
TInt.printf("%4d", c);
}
}

Mnoenie macierzy przez liczb (skalar) jest bardzo prostym dziaaniem i polega na
mnoeniu kadego elementu macierzy przez t liczb.
public static double[][] product (double k, double[][] x) {
for(int j = 0; j < x[0].length; ++j)
tmp[i][j] = k*x[i][j];
return tmp;
}
Dziaanie metody pokaemy, wykonujc przykadowe mnoenie.

double[][] b = product(2.5, a);
System.out.println("Macierz B = k*A");
}
}

Transpozycja macierzy polega na zamianie wierszy macierzy na kolumny i kolumn na
wiersze. Nastpuje przy tym zmiana wymiaru macierzy (nie dotyczy tzw. macierzy
kwadratowych). Wystarczy zatem odczytywa macierz wierszami i zapisywa j ko-
lumnami (wystarczy zamiana indeksów tmp[j][i] = x[i][j]).
public static double[][] transp (double[][] x) {
double[][] tmp = new double[x[0].length][x.length];
tmp[j][i] = x[i][j];
return tmp;
}

W wyniku transponowania macierzy 2×3 (dwa wiersze, trzy kolumny) powstanie ma-
cierz 3×2 (trzy wiersze, dwie kolumny).
/* Tu wstaw kod metody transp(). */
TDouble.setRandom(a, 100);
double[][] b = transp(a);
System.out.println("Macierz transponowana");
}
}
Zadanie 28.12. Z28_12.java, TInt.java

Tworzymy tablic (macierz) liczb zmiennoprzecinkowych, której wymiary bd iden-
tyczne z wymiarami podanego parametru (tablicy liczb cakowitych). W podwójnej
ptli przepisujemy elementy z jednej tablicy do drugiej, rzutujc warto cakowit na
zmiennoprzecinkow (tmp[i][j] = (double)x[i][j]).
private static double[][] toDouble (int[][] x) {
tmp[i][j] = (double)x[i][j];
return tmp;
}
int[][] a = new int[4][3];
double[][] b = toDouble(a);
System.out.println("Macierz o elementach cakowitych A");
System.out.println("Macierz o elementach rzeczywistych B");
}
}
W przykadzie zdefiniowalimy metod toDouble() jako prywatn. Przenoszc kod

metody do klasy TInt, zmienimy specyfikator dostpu private na public. W przyka-
dowym kodzie wystarczy zamieni wiersz double[][] b = toDouble(a); na wiersz
double[][] b = TInt.toDouble(a); i mona usun kod prywatnej metody toDouble().
Zadanie 28.13. Z28_13.java, TDouble.java

Metoda valueOf() w klasie TDouble zamienia tablic typu int[][] na tablic typu
double[][], wic jej kod jest identyczny z metod TInt.toDouble() (rozwizanie za-
dania 28.12).
public static double[][] valueOf (int[][] x) {


tmp[i][j] = (double)x[i][j];
return tmp;
}
Program demonstrujcy dziaanie metody jest równie podobny do programu z roz-

wizania zadania 28.12. Rónica polega na zastpieniu metody TInt.toDouble() me-
tod TDouble.valueOf().
Zadanie 28.14. Z28_14.java, TDouble.java

Wzorujc si na rozwizaniu zadania 28.12, utworzymy metod toInt() i doczymy
j do klasy TDouble.
public static int[][] toInt (double[][] x) {
int[][] tmp = new int[x.length][x[0].length];
tmp[i][j] = (int)x[i][j];
return tmp;
}
Przykad dziaania metody moemy zbudowa podobnie jak w rozwizaniu zadania

28.12.
Zadanie 28.15. Z28_15.java, TInt.java

Wzorujc si na rozwizaniu zadania 28.13 (metoda valueOf() umieszczona w klasie
TDouble), zbudujemy metod valueOf() w klasie TInt.
public static int[][] valueOf (double[][] x) {
int[][] tmp = new double[x.length][x[0].length];
tmp[i][j] = (int)x[i][j];
return tmp;
}
Przykad dziaania metody moemy zbudowa, wzorujc si na rozwizaniu jednego

z powyszych zada.

lad macierzy (pojcie z algebry liniowej) jest sum elementów na gównej przektnej
macierzy kwadratowej.
private static double trace (double[][] x) {
if (x.length != x[0].length)
throw new ArithmeticException("Macierz nie jest kwadratowa");
double tr = 0.0;
tr += x[i][i];
return tr;
}


TDouble.setRandom(a, 100);
System.out.printf("lad macierzy tr(A) = %.3f\n", trace(a));
}
}

Metoda getI() zwraca macierz jednostkow rzdu n, gdzie n jest parametrem wywo-
ania metody. Macierz jednostkow lub identycznociow nazywamy macierz kwa-
dratow, która na przektnej gównej ma wartoci 1 (dla i j ), a pozostae wartoci
s równe 0 (dla i z j ). Poniewa po utworzeniu (double[][] tmp = new double[n][n];)
tablica jest wypeniona zerami, to wystarczy wstawi na gównej przektnej warto 1
(for(int i = 0; i < n; ++i) tmp[i][i] = 1.0;).
private static double[][] getI (int n) {
if (n < 1)
throw new ArithmeticException("Niewaciwy wymiar macierzy");
double[][] tmp = new double[n][n];
for(int i = 0; i < n; ++i)
tmp[i][i] = 1.0;
return tmp;
}
double[][] a = getI(5);
System.out.println("Macierz jednostkowa 5 stopnia");
}
}
Program wywietla macierz jednostkow 5. rzdu. Czytelnik moe do programu doczy

metod mnoc macierze i pokaza (na przykadach) równoci I A A i B I B .

Poniewa macierz x, przekazana jako parametr wywoania metody setI(), moe za-
wiera jakie wartoci, musimy na gównej przektnej wstawi liczby 1 (dla i j ),
a inne wartoci pozostawi równe 0 (dla i z j ).
private static void setI (double[][] x) {
throw new ArithmeticException("Niewaciwy wymiar macierzy");
if (i == j)
x[i][j] = 1.0;
else
x[i][j] = 0.0;
}


setI(a);
System.out.println("Macierz jednostkowa");
}
}

Wyznacznik obliczymy z rozwinicia Laplace’a wzgldem pierwszego wiersza (wier-
sza o indeksie 0). Wzór wynikajcy z tego rozwinicia jest rekurencyjny1 i oblicze-
nie wyznacznika macierzy n-tego rzdu sprowadzi si do obliczenia n wyznaczników
rzdu n–1.
private static double det(double[][] x) {
throw new ArithmeticException("To nie jest macierz kwadratowa");
int st = x.length;
double d = 0;
if (st == 1)
d = x[0][0];
else {
int zn = 1;
double[][] n = new double[st-1][st-1];
for(int i = 0; i < st; ++i) {
for(int j = 0; j < st-1; ++j) {
for(int k = 0; k < st-1; ++k) {
if (k < i) n[j][k] = x[j+1][k];
else n[j][k] = x[j+1][k+1];
}
}
d += zn*x[0][i]*det(n);
zn = -zn;
}
}
return d;
}

/* Tu wstaw kod metody det(). */
System.out.printf("Wyznacznik det A = %6.2f\n", det(a));
}
}
1
Rekurencja polega na odwoywaniu si metody (funkcji, definicji) do samej siebie. W rozdziale 29.
Czytelnik znajdzie wicej zada, których rozwizania zawieraj metody rekurencyjne.


Macierz trójktna górna to macierz kwadratowa, w której wszystkie elementy znaj-
dujce si poniej gównej przektnej maj warto równ 0. Moemy przyj jedno
z dwóch rozwiza: przeksztacenia wykonujemy na macierzy przekazanej jako pa-
rametr wywoania metody, przeksztacenia wykonujemy na kopii parametru wywoa-
nia i zwracamy przeksztacon kopi jako wynik dziaania metody (przyjmiemy ten
drugi wariant).
Jeli podana macierz nie jest kwadratowa, to zgaszany jest wyjtek. Po utworzeniu
kopii (tmp) przeksztacanej macierzy w ptli (for(int i = 0; i < n-1; ++i)) pobie-
ramy elementy z gównej przektnej (tmp[i][i]) — od pierwszego do przedostatniego.
Dla wszystkich wierszy o indeksie j > i odejmujemy od wiersza o indeksie j wiersz
o indeksie i pomnoony przez wspóczynnik p = tmp[j][i]/tmp[i][i]. Operacj mo-
emy wykona, gdy element tmp[i][i] jest róny od zera (elementy tmp[j][i] przyj-
muj warto 0).
if (tmp[i][i] != 0.0) {
double p = tmp[j][i]/tmp[i][i];
for(int k = 0; k < n; ++k)
tmp[j][k] -= tmp[i][k]*p;
}
Ta operacja nie zmienia wyznacznika macierzy. Natomiast elementy macierzy znaj-

dujce si poniej elementu tmp[i][i] w kolumnie i przyjmuj warto 0.
Jeli element t[i][i] jest zerem, to szukamy w wierszach poniej najbliszego wier-
sza k takiego, e element tmp[k][i] jest róny od zera. Przestawiamy te wiersze i w ten
sposób na przektnej (w tmp[i][i]) znajdzie si element róny od zera. Przestawianie
wierszy (lub kolumn) macierzy powoduje zmian znaku wyznacznika. Aby temu za-
pobiec, mnoymy przestawiony wiersz przez –1 (realizuje to zmiana znaku temp w ope-
racji przestawiania elementów tmp[k][m] = -temp). Po przestawieniu wierszy konty-
nuujemy dziaanie ptli ze zmienn j (odejmujemy od wiersza o indeksie j wiersz
o indeksie i pomnoony przez wspóczynnik p). Gdyby si okazao, e dla k > i nie
ma wiersza z elementem tmp[k][i] rónym od zera, to warto 0 pozostanie na gównej
przektnej.
private static double[][] upperTriangular(double[][] x) {
/* Kopia macierzy */
int n = x.length;
for(int i = 0; i < n; ++i)
for(int j = 0; j < n; ++j)
tmp[i][j] = x[i][j];
/* Tworzenie macierzy trójktnej górnej */
for(int i = 0; i < n-1; ++i)
for(int j = i+1; j < n; ++j) {
if (tmp[i][i] != 0.0) {

for(int k = 0; k < n; ++k)

} else {
for(int k = i+1; k < n; ++k) {
if (tmp[k][i] != 0.0) {
for(int m = 0; m < n; ++m) {
double temp = tmp[i][m];
tmp[i][m] = tmp[k][m];
tmp[k][m] = -temp;
}
break;
}
}
}
}
return tmp;
}
Jak ju wspomnielimy, przedstawiony algorytm zamiany macierzy kwadratowej na

macierz trójktn górn nie zmienia wartoci wyznacznika macierzy. Wyznacznik
macierzy trójktnej jest natomiast równy iloczynowi elementów nalecych do gów-
nej przektnej, zatem przedstawiona metoda moe by wykorzystana do obliczenia
wyznacznika.
/* Tu wstaw kod metody upperTriangular. */
double[][] b = upperTriangular(a);
System.out.println("Macierz trójktna górna B");
/* Wyznacznik macierzy trójktnej */
double det = 1.0;
for(int i = 0; i < b.length; ++i)
det *= b[i][i];
System.out.printf("det A = det B = %.2f\n", det);
}
}

Macierz trójktna dolna to macierz kwadratowa, w której wszystkie elementy znaj-
dujce si ponad gówn przektn maj warto równ 0.
Sposób tworzenia macierzy trójktnej dolnej jest podobny do sposobu tworzenia ma-
cierzy trójktnej górnej (zob. rozwizanie zadania 28.20). Rónica polega na kolejno-
ci pobierania elementów z gównej przektnej macierzy — elementy pobieramy od
ostatniego do drugiego (for(int i = n-1; i > 0; --i)). Wykonujemy odejmowanie
wierszy (for(int j = i-1; j >= 0; --j)) i poszukiwanie wiersza z niezerowym ele-
mentem (for(int k = i-1; k >= 0; --k)) „od dou do góry”.

private static double[][] lowerTriangular(double[][] x) {

int n = x.length;
for(int i = 0; i < n; ++i)
for(int j = 0; j < n; ++j)
for(int i = n-1; i > 0; --i)
for(int j = i-1; j >= 0; --j) {
if (tmp[i][i] != 0.0) {
for(int k = 0; k < n; ++k)
} else {
for(int k = i-1; k >= 0; --k) {
if (tmp[k][i] != 0.0) {
for(int m = 0; m < n; ++m) {
tmp[k][m] = -temp;
}
break;
}
}
}
}
return tmp;
}
Przedstawiony algorytm zamiany macierzy kwadratowej na macierz trójktn doln

nie zmienia wartoci wyznacznika macierzy. Wyznacznik macierzy trójktnej jest rów-
ny iloczynowi elementów nalecych do gównej przektnej.

Macierz diagonalna to macierz kwadratowa, której wszystkie wspóczynniki lece
poza gówn przektn s zerowe (jest to macierz trójktna górna i zarazem macierz
trójktna dolna). Moemy zatem zastosowa kolejno metody upperTriangular() (za-
danie 28.20) i lowerTriangular() (zadanie 28.21) — otrzymamy macierz diagonaln.
W metodzie upperTriangular() moemy dokona kilku poprawek i uzyskamy meto-

d wyznaczajc macierz diagonaln:
zmiana nazwy metody upperTriangular na diagonal,
zastpienie ptli for(int j = i+1; j < n; ++j) ptl for(int j = 0; j < n;
++j), co spowoduje odejmowanie od wszystkich wierszy macierzy wiersza
o indeksie i pomnoonego przez wspóczynnik p = tmp[j][i]/tmp[i][i],
w powyszym odejmowaniu naley pomin odejmowanie wiersza od siebie
samego (j = i), wic operacj wykonujemy warunkowo:
if (j != i) {

for(int k = 0; k < n; ++k)

}
Po tych zmianach otrzymamy nastpujcy kod metody:

private static double[][] diagonal(double[][] x) {
/* Kopia macierzy */
int n = x.length;
for(int i = 0; i < n; ++i)
for(int j = 0; j < n; ++j)
/* Wyznaczenie macierzy diagonalnej */
for(int i = 0; i < n; ++i)
for(int j = 0; j < n; ++j) {
if (tmp[i][i] != 0.0) {
if (j != i) {
for(int k = 0; k < n; ++k)
}
} else {
for(int k = i+1; k < n; ++k) {
if (tmp[k][i] != 0.0) {
for(int m = 0; m < n; ++m) {
double p = tmp[i][m];
tmp[k][m] = -p;
}
break;
}
}
}
}
return tmp;
}
Program demonstrujcy dziaanie moe by podobny jak w zadaniu 28.20 lub 28.21.

Do wyznaczenia macierzy odwrotnej zastosujemy nastpujcy algorytm:
Bierzemy dan macierz kwadratow (A) i macierz jednostkow (I) tego
samego rzdu.
Stosujc te same przeksztacenia dla obu macierzy jednoczenie (mnoenie
wierszy przez liczb rón od zera, dodawanie do wiersza macierzy kombinacji
liniowej innych wierszy), doprowadzamy macierz A do postaci macierzy
diagonalnej z wartociami 1 na gównej przektnej. Macierz powstaa w wyniku
przeksztace macierzy I jest macierz odwrotn do macierzy A (A–1).

Jeli w wyniku przeksztace macierzy A otrzymamy macierz o elemencie 0 na gów-

nej przektnej, to macierz A jest macierz osobliw (zdegenerowan); nie istniej wy-
znacznik det A = 0 i macierz odwrotna.
W kodzie metody diagonal() (z rozwizania zadania 28.22) zmieniono nazw na

inverse i dodano fragmenty dziaa (wykonywanych równolegle) na macierzy jed-
nostkowej I (na listingu zmiany i uzupenienia w kodzie zaznaczono pogrubieniem).
Po sprowadzeniu macierzy tmp do postaci diagonalnej sprawdzamy, czy nie jest to
macierz osobliwa (0 na gównej przektnej, rzucamy wyjtek). W trakcie tej operacji
odpowiednie wiersze obu macierzy dzielimy przez tmp[i][i], co doprowadza macierz
tmp do macierzy jednostkowej, a macierz I do macierzy odwrotnej do wyjciowej po-
staci macierzy tmp. Zwracamy wynik znajdujcy si w macierzy I.
private static double[][] inverse(double[][] x) {
int n = x.length;

for(int i = 0; i < n; ++i)
for(int j = 0; j < n; ++j)
double[][] I = new double[n][n];

for(int i = 0; i < n; ++i)
I[i][i] = 1.0;
for(int i = 0; i < n; ++i)

for(int j = 0; j < n; ++j) {
if (tmp[i][i] != 0.0) {
if (j != i) {
for(int k = 0; k < n; ++k) {
I[j][k] -= I[i][k]*p;
}
}
} else {
for(int k = i+1; k < n; ++k) {
if (tmp[k][i] != 0.0) {
for(int m = 0; m < n; ++m) {
tmp[k][m] = -temp;
temp = I[i][m];
I[i][m] = I[k][m];
I[k][m] = -temp;
}
break;
}
}
}
}
for(int i = 0; i < n; ++i)
if (tmp[i][i] != 0.0)

for(int j = 0; j < n; ++j)

I[i][j] /= tmp[i][i];
else
throw new ArithmeticException("Macierz odwrotna nie
istnieje");
return I;
}
Spróbujemy uproci uzyskan metod. Oto istotny fragment kodu:

for(int i = 0; i < n; ++i) {
for(int j = 0; j < n; ++j) {
if (tmp[i][i] != 0.0) {
if (j != i) {
for(int k = 0; k < n; ++k) {
I[j][k] -= I[i][k]*p;
}
}
} else {
for(int k = i+1; k < n; ++k) {
if (tmp[k][i] != 0.0) {
for(int m = 0; m < n; ++m) {
tmp[k][m] = -temp;
temp = I[i][m];
I[i][m] = I[k][m];
I[k][m] = -temp;
}
break;
}
}
istnieje");// 0 na przektnej macierzy diagonalnej
}
}
double q = tmp[i][i];
for(int k = 0; k < n; ++k) {
I[i][k] /= q;
tmp[i][k] /= q;
}
}
return I;
Analiz zmian pozostawiamy Czytelnikowi.
Demonstrujc dziaanie metody, sprawdzimy, czy uzyskana macierz jest odwrotna.

W tym celu pomnoymy macierz wyjciow przez macierz odwrotn. W rozwizaniu
zadania 28.9 zbudowalimy metod product(), obliczajc iloczyn macierzy o ele-
mentach cakowitych. Na podstawie tej metody zbudujemy metod mnoc macierze
o elementach rzeczywistych:
public static double[][] product (double[][] x, double[][] y) {
if (x[0].length != y.length)

double[][] tmp = new double[x.length][y[0].length];

for(int j = 0; j < y[0].length; ++j)
tmp[i][j] += x[i][k]*y[k][j];
return tmp;
}
Uywajc metody product(), moemy sprawdzi na przykadach dziaanie metody

inverse():
/* Tu wstaw kod metody inverse(). */
double[][] b = inverse(a);
System.out.println("Macierz odwrotna B");
System.out.println("Sprawdzenie A·B");
TDouble.printf("%8.2f", product(a, b));
System.out.println("Sprawdzenie B·A");
TDouble.printf("%8.2f", product(b, a));
double[][] c = {{1, 1, 1},{1, 1, 1}, {2, 2, 2}};
System.out.println("Macierz C");
TDouble.printf("%8.2f", c);
System.out.println("Macierz odwrotna D");
double[][] d = inverse(c);
TDouble.printf("%8.2f", d);;
}
}

Rozwiemy ukad n równa liniowych o n niewiadomych:
a11 x1 a12 x2 a1n xn b1
°a21 x1 a22 x2 a2 n xn b 2
°
®...............................................
°
°¯an1 x1 an 2 x2 ann xn b n
Na pocztku programu wprowadzimy liczb równa ukadu (n). Wspóczynniki uka-

du równa wprowadzimy do tablicy o n wierszach i n+1 kolumnach. W pierwszych n
kolumnach umiecimy macierz podstawow ukadu wspórzdnych, a w ostatniej ko-
lumnie umiecimy wyrazy wolne. Do wprowadzania danych uyjemy metody input()
(z rozwizania zadania 28.3) z niewielkimi poprawkami:
private static void input(double[][] x) {
int n = x.length;
for(int i = 0; i < n; ++i) {
System.out.println("Podaj wspóczynniki równania");
for(int j = 0; j < n; ++j) {

System.out.printf("a[%d][%d] = ", i+1, j+1);

x[i][j] = cin.nextDouble();
}
System.out.printf("b[%d] = ", i+1);
x[i][n] = cin.nextDouble();
}
}
Do obliczania wyznaczników uyjemy metody rekurencyjnej det() z rozwizania za-

dania 28.19. Poniewa tablica przechowujca wspóczynniki ukadu równa nie jest
tablic kwadratow (liczba kolumn jest o jeden wiksza od liczby wierszy), to z me-
tody det() usuwamy kontrol wymiaru. Wyznacznik bdzie liczony z pierwszych n
kolumn macierzy, a n+1 kolumna (zawierajca wyrazy wolne) zostanie pominita.
W ten sposób obliczymy gówny wyznacznik ukadu wspórzdnych (w).
private static double det (double[][] x) {
int st = x.length;
double d = 0;
if (st == 1)
d = x[0][0];
else {
int zn = 1;
double[][] n = new double[st-1][st-1];
for (int i = 0; i < st; ++i) {
for (int j = 0; j < st-1; ++j) {
for (int k = 0; k < st-1; ++k) {
if (k < i) n[j][k] = x[j+1][k];
else n[j][k] = x[j+1][k+1];
}
}
d += zn*x[0][i]*det(n);
zn = -zn;
}
}
return d;
}
Pozostae wyznaczniki obliczymy (w ptli) w ten sam sposób, ale przed liczeniem wy-
znacznika w miejsce i-tej kolumny podstawimy (ostatni) kolumn wyrazów wolnych.
Do tego celu utworzymy metod swapLast():
private static void swapLast(double[][] x, int col) {
int n = x.length;
for(int row = 0; row < n; ++row) {
double tmp = x[row][col];
x[row][col] = x[row][n];
x[row][n] = tmp;
}
}
Po obliczeniu wyznacznika ponownie wywoamy metod swapLast(), przywracajc

pierwotn posta macierzy.
Po obliczeniu wyznaczników moemy poda rozwizanie ukadu równa. Moliwe s

trzy przypadki:

1. Wyznacznik gówny (w) jest róny od zera, wic ukad równa jest oznaczony
wi
xi dla i = 1, 2, …, n.
w
2. Wyznacznik gówny jest równy 0 i wszystkie pozostae wyznaczniki s równe
0 (suma s bezwzgldnych wartoci tych wyznaczników jest równa zero), wic
ukad równa jest nieoznaczony.
3. Wyznacznik gówny jest równy 0 i co najmniej jeden z pozostaych
wyznaczników nie jest równy 0 (suma s bezwzgldnych wartoci tych
wyznaczników nie jest zerem), zatem ukad równa jest sprzeczny.
/* Tu wstaw kod metody det(). */
/* Tu wstaw kod metody swapLast(). */
/* Tu wstaw kod metody input(). */

/* Liczba równa */
int n;
do {
System.out.print("Podaj liczb równa ukadu (2..9), n = ");
n = cin.nextInt();
} while (n < 2 || n > 9);
/* Wprowadzenie wspóczynników ukadu równa */
double[][] ur = new double[n][n+1];
input(ur);
/* Obliczanie wyznaczników */
double w = det(ur);
System.out.printf("Wyznacznik gówny W = %f\n", w);
double[] wx = new double[n];
for(int i = 0; i < n; ++i) {
swapLast(ur, i);
wx[i] = det(ur);
swapLast(ur, i);
System.out.printf("Wyznacznik Wx[%d] = %f\n", i+1, wx[i]);
}
if (w != 0) {
System.out.println("Ukad równa jest oznaczony");
for(int i = 0; i < n; ++i)
System.out.printf("x[%d] = %f\n", i+1, wx[i]/w);
} else {
double s = 0.0;
for(int i = 0; i < n; ++i)
s += Math.abs(wx[i]);
if (s == 0.0)
System.out.println("Ukad równa jest nieoznaczony");
else
System.out.println("Ukad równa jest sprzeczny");
}
}
}


Na pocztku programu wprowadzimy liczb równa ukadu (n). Wspóczynniki uka-
du równa
a11 x1 a12 x2 a1n xn b1
°a21 x1 a22 x2 a2 n xn b 2
°
®...............................................
°
¯°an1 x1 an 2 x2 ann xn b n
wprowadzimy do dwóch tablic (macierzy) — kwadratowej macierzy podstawowej
ukadu o wymiarze n×n i prostoktnej o wymiarze n×1 (kolumna wyrazów wolnych).
Do wprowadzania danych uyjemy metody input() (z rozwizania zadania 28.24)
z poprawkami uwzgldniajcymi przechowywanie danych w dwóch macierzach:
private static void input(double[][] x, double[][] y) {
int n = x.length;
for(int i = 0; i < n; ++i) {
System.out.println("Podaj wspóczynniki równania");
for(int j = 0; j < n; ++j) {
System.out.printf("a[%d][%d] = ", i+1, j+1);
x[i][j] = cin.nextDouble();
}
System.out.printf("b[%d] = ", i+1);
y[i][0] = cin.nextDouble();
}
}
Z rozwizania zadania 28.23 we miemy metod inverse() obliczajc macierz od-

wrotn oraz metod product() mnoc dwie macierze. Jeli macierz odwrotna ist-
nieje, to ukad jest oznaczony, w przeciwnym wypadku (metoda inverse() rzuci wy-
jtek) mamy do czynienia z ukadem sprzecznym lub nieoznaczonym.

/* Tu wstaw kod metody inverse() - zadanie 28.23. */
/* Tu wstaw kod metody product() - zadanie 28.23 */

/* Liczba równa */
int n;
do {
System.out.print("Podaj liczb równa ukadu, n = ");
n = cin.nextInt();
} while (n < 2);
double[][] a = new double[n][n];
double[][] b = new double[n][1];
input(a, b);
/* Obliczanie macierzy odwrotnej i rozwizanie ukadu */
try {
double[][] x = product(inverse(a), b);

System.out.println("Ukad równa jest oznaczony");

for(int i = 0; i < n; ++i)
System.out.printf("x[%d] = %f\n", i+1, x[i][0]);
System.out.println("Ukad sprzeczny lub nieoznaczony");
}
}
}

Na pocztku programu wprowadzimy liczb równa ukadu (n). Wspóczynniki ukadu
równa wprowadzimy do tablicy o n wierszach i n+1 kolumnach (tak jak w rozwi-
zaniu zadania 28.24). W pierwszych n kolumnach umiecimy macierz podstawow
ukadu wspórzdnych, a w ostatniej kolumnie — wyrazy wolne. Do wprowadzania
danych uyjemy metody input() z rozwizania zadania 28.4. Nastpnie bdziemy
przeksztacali macierz zawierajc wspóczynniki równa ukadu w taki sposób, aby
macierz podstawowa staa si macierz jednostkow. W ostatniej kolumnie otrzyma-
my rozwizanie ukadu.
Jeli na gównej przektnej macierzy podstawowej pojawi si warto 0, to ukad jest
sprzeczny lub nieoznaczony (moemy to rozstrzygn, porównujc zerowe wartoci
z przektnej macierzy podstawowej z wartociami z kolumny wyrazów wolnych).
Metoda solve(), rozwizujca ukad, jest modyfikacj metody inverse(), obliczaj-

cej macierz odwrotn (zob. rozwizanie zadania 28.23). Metoda solve() nie sprawdza
wymiaru macierzy (powinien by równy n×n+1). Najpierw macierz jest przekszta-
cana tak, aby macierz podstawowa staa si macierz diagonaln; te same operacje s
wykonywane na kolumnie wyrazów wolnych. W tym momencie otrzymujemy n rów-
na o postaci ax = b (gdzie a jest elementem przektnej macierzy podstawowej, b od-
powiadajcym mu wyrazem wolnym). W ostatniej ptli rozwizujemy te równania
(x = b/a) lub stwierdzamy, e a = 0 i równanie jest sprzeczne (b róne od 0) lub nie-
oznaczone (b = 0) — zwracamy wyjtek, nie informujc o powodach. Czytelnik mo-
e ten fragment kodu rozwin. Jeli co najmniej jedno równanie jest sprzeczne, to
cay ukad te jest sprzeczny.
private static void solve(double[][] x) {
int n = x.length;
/* Sprowadzamy macierz podstawow do postaci diagonalnej. */
for(int i = 0; i < n; ++i)
for(int j = 0; j < n; ++j) {
if (x[i][i] != 0.0) {
if (j != i) {
double p = x[j][i]/x[i][i];
for(int k = 0; k < n+1; ++k)
x[j][k] -= x[i][k]*p;
}
} else {
for(int k = i+1; k < n; ++k) {
if (x[k][i] != 0.0) {
for(int m = 0; m < n; ++m) {
double temp = x[i][m];
x[i][m] = x[k][m];
x[k][m] = -temp;

}
break;
}
}
}
}
/* Wyznaczamy rozwizanie ukadu. */
for(int i = 0; i < n; ++i)
if (x[i][i] != 0.0)
for(int j = 0; j < n; ++j) {
x[i][n] /= x[i][i];
x[i][i] = 1.0;
}
else if (x[i][i] == x[i][n])
throw new ArithmeticException("Ukad sprzeczny lub nieoznaczony");
}
W przykadowym rozwizaniu nie ograniczamy liczby równa. W odrónieniu od

metody wyznaczników budujcej wiele kopii macierzy metoda eliminacji przekszta-
ca macierz ukadu równa w miejscu, gdzie j utworzono (macierz ulega zmianie).
Jeli bdzie nam potrzebna pocztkowa posta ukadu równa, to musimy przed wy-
woaniem metody solve() skopiowa dane do innej tablicy.

/* Tu wstaw kod metody solve(). */

/* Liczba równa */
int n;
do {
System.out.print("Podaj liczb równa ukadu, n = ");
n = cin.nextInt();
} while (n < 2);
double[][] ur = new double[n][n+1];
input(ur);
/* Rozwizanie ukadu */
try {
solve(ur);
for(int i = 0; i < n; ++i)
System.out.printf("x[%d] = %f\n", i+1, ur[i][n]);
}
}
}
Zadanie 28.27. Matrix.java, Z28_27.java

W klasie Matrix korzystamy z metod pochodzcych z dwóch klas, Scanner i Random,
z pakietu java.util. W tym celu tworzymy prywatne i statyczne obiekty cin (ang.
console input) i rnd (ang. random). Ma to na celu uatwienie pracy z klas podczas jej

tworzenia i testowania jej moliwoci (random() — wypenianie macierzy wylosowa-

nymi wartociami) oraz w czasie wprowadzania danych (metoda input()) i wywie-
tlania wyników (metoda printf()).
Obiekt posiada prywatne pole M2 bdce referencj do dwuwymiarowej tablicy liczb

typu double, zawierajcej elementy macierzy. Do dyspozycji mamy trzy konstruktory:
tworzcy macierz na podstawie istniejcej tablicy dwuwymiarowej, tworzcy macierz
o podanych wymiarach (wypenion zerami) i konstruktor kopiujcy.
Oprócz wspomnianych metod (random(), input() i printf()) w klasie Matrix zdefinio-

wano metody umoliwiajce dostp do prywatnych danych (elementów tablicy M, czyli
elementów macierzy). Metoda getAt() pozwala odczyta warto elementu z okrelo-
nego wiersza i kolumny, a metoda setAt() nadaje okrelonemu elementowi podan
warto. Wymiary macierzy moemy pozna, korzystajc z metod getRows() i getCo-
lumns(). Dziki tym metodom zewntrzne metody mog przeksztaca obiekty repre-
zentujce macierze (o ile takich operacji nie oferuj metody klasy Matrix).
import java.util.*;
public class Matrix {
private static Random rnd = new Random();
private double[][] M;
public Matrix(double[][] x) {
int r = x.length; // liczba wierszy (rows)
int c = x[0].length; // liczba kolumn (columns)
M = new double[r][c];
for(int i = 0; i < r; ++i)
for(int j = 0; j < c; ++j)
M[i][j] = x[i][j];
}
public Matrix(int r, int c) {

/* r liczba wierszy (rows), c liczba kolumn (columns) */
}
public Matrix(Matrix x) {
int r = x.M.length;
int c = x.M[0].length;
for(int i = 0; i < r; ++i)
for(int j = 0; j < c; ++j)
M[i][j] = x.M[i][j];
}
public Matrix random() {

for(int i = 0; i < M.length; ++i)
2
Gdy programujemy w Javie, jestemy przyzwyczajeni do zapisywania identyfikatorów staych wiel-
kimi literami. W tym przypadku M nie oznacza staej, lecz jest identyfikatorem tablicy, która odpowia-
da macierzy reprezentowanej przez obiekt. W kilku nastpnych zadaniach bdziemy oznaczali macie-
rze wielkimi literami (tak jak przyjmuje si w podrcznikach do matematyki).

for(int j = 0; j < M[0].length; ++j)

M[i][j] = rnd.nextDouble();
return this;
}
public Matrix input() {

for(int j = 0; j < M[i].length; ++j) {
System.out.printf("M[%d][%d] = ", i, j);
M[i][j] = cin.nextDouble();
}
return this;
}
public Matrix printf(String format) {

for(int i = 0; i < M.length; ++i) {
System.out.printf(format, M[i][j]);
}
return this;
}
public double getAt(int i, int j) {

return M[i][j];
}
public void setAt(int i, int j, double x) {

M[i][j] = x;
}
public int getRows() {

return M.length;
}
public int getColumns() {

return M[0].length;
}
}
W przykadzie pokazujemy moliwoci tak zdefiniowanej klasy Matrix.

class Z28_27 {
double[][] a = {{0, 3, -2, 2},{2, 1, -3, -1},{2, 1, -3, 4} };
Matrix A = new Matrix(a);

A.printf("%8.2f");
Matrix B = new Matrix(3, 4);

System.out.println("Wypenienie macierzy B wartociami
losowymi");
B.random().printf("%8.2f");
Matrix C = new Matrix(a);

System.out.println("Konstruktor kopiujcy - C jest kopi A");

C.random().printf("%8.2f");
System.out.println("Liczba wierszy: "+C.getRows());
System.out.println("Liczba kolumn: "+C.getColumns());
System.out.println("Element C[0][1]: "+C.getAt(0, 1));
System.out.println("Podstawiam C[0][0] = -3.5");
C.setAt(0, 1, -3.5);
System.out.println("Element C[0][0]: "+C.getAt(0, 1));
Matrix D = new Matrix(2, 2);

System.out.println("Wprowadzanie danych z konsoli do
macierzy D");
D.input();
System.out.println("Macierz D");
D.printf("%10.4f");
}
}
Zadanie 28.28. Matrix.java, Z28_28.java

Do klasy Matrix dodajemy metody add() (dodawanie), sub() (odejmowanie) i mult()
(mnoenie) w dwóch wariantach — mnoenie macierzy przez macierz i mnoenie ma-
cierzy przez skalar.
public Matrix add(Matrix x) {
if (M.length != x.M.length || M[0].length != x.M[0].length)
Matrix tmp = new Matrix(this);
tmp.M[i][j] = M[i][j]+x.M[i][j];
return tmp;
}
public Matrix sub(Matrix x) {

if (M.length != x.M.length || M[0].length != x.M[0].length)
tmp.M[i][j] = M[i][j]-x.M[i][j];
return tmp;
}
public Matrix mult(Matrix x) {

if (M[0].length != x.M.length)
Matrix tmp = new Matrix(M.length, x.M[0].length);
for(int j = 0; j < x.M[0].length; ++j)
for(int k = 0; k < x.M.length; ++k)
tmp.M[i][j] += M[i][k]*x.M[k][j];
return tmp;
}
public Matrix mult(double x) {



tmp.M[i][j] *= x;
return tmp;
}
Na macierzach wypenionych wylosowanymi wartociami pokazujemy wykonywanie

zdefiniowanych w klasie Matrix dziaa na macierzach.
class Z28_28 {
System.out.println("Wypenienie macierzy A wartociami
losowymi");
Matrix A = new Matrix(3, 4).random().printf("%8.2f");
System.out.println("Wypenienie macierzy B wartociami
losowymi");
Matrix B = new Matrix(3, 4).random().printf("%8.2f");
System.out.println("Suma macierzy, A+B = ");

A.add(B).printf("%8.2f");
System.out.println("Suma macierzy, B+A = ");
B.add(A).printf("%8.2f");
System.out.println("Rónica macierzy, A-B = ");

A.sub(B).printf("%8.2f");
System.out.println("Rónica macierzy, B-A = ");
B.sub(A).printf("%8.2f");
Matrix C = new Matrix(3, 2).random().printf("%8.2f");
System.out.println("Macierz D");
Matrix D = new Matrix(2, 4).random().printf("%8.2f");
System.out.println("Iloczyn macierzy, C*D = ");
C.mult(D).printf("%10.4f");
C.printf("%10.4f");
System.out.println("Iloczyn macierzy przez skalar, 3*C = ");
C.mult(3).printf("%10.4f");
}
}

Doczamy do klasy Matrix metody zwracajce macierz (kwadratow) reprezentowa-
n przez obiekt w postaci macierzy trójktnej lub diagonalnej (na podstawie rozwi-
zania zada 28.20, 28.21 i 28.22). Uzyskane macierze charakteryzuj si tym, e maj
taki sam wyznacznik jak macierz wyjciowa i jest on równy iloczynowi elementów
z gównej przektnej macierzy.
Macierz trójktna górna — wszystkie elementy poniej gównej przektnej maj war-
to zero.
public Matrix upperTriangular() {
if (M.length != M[0].length)
int n = M.length;


for(int i = 0; i < n-1; ++i)
for(int j = i+1; j < n; ++j) {
if (tmp.M[i][i] != 0.0) {
double p = tmp.M[j][i]/tmp.M[i][i];
for(int k = 0; k < n; ++k)
tmp.M[j][k] -= tmp.M[i][k]*p;
} else {
for(int k = i+1; k < n; ++k) {
if (tmp.M[k][i] != 0.0) {
for(int m = 0; m < n; ++m) {
double temp = tmp.M[i][m];
tmp.M[i][m] = tmp.M[k][m];
tmp.M[k][m] = -temp;
}
break;
}
}
}
}
return tmp;
}
Macierz trójktna dolna — wszystkie elementy poniej gównej przektnej maj war-
to zero.
public Matrix lowerTriangular() {
int n = M.length;
for(int i = n-1; i > 0; --i)
for(int j = i-1; j >= 0; --j) {
if (tmp.M[i][i] != 0.0) {
for(int k = 0; k < n; ++k)
} else {
for(int k = i-1; k >= 0; --k) {
if (tmp.M[k][i] != 0.0) {
for(int m = 0; m < n; ++m) {
}
break;
}
}
}
}
return tmp;
}
Macierz diagonalna — wszystkie elementy poza gówn przektn maj warto zero.
public Matrix diagonal() {


int n = M.length;
for(int i = 0; i < n; ++i)
for(int j = 0; j < n; ++j) {
if (tmp.M[i][i] != 0.0) {
if (j != i) {
for(int k = 0; k < n; ++k)
}
} else {
for(int k = i+1; k < n; ++k) {
if (tmp.M[k][i] != 0.0) {
for(int m = 0; m < n; ++m) {
double p = tmp.M[i][m];
tmp.M[k][m] = -p;
}
break;
}
}
}
}
return tmp;
}
Macierz kwadratow o wylosowanych elementach przeksztacamy na posta trójktn

(górn lub doln) i posta diagonaln.
class Z28_29 {
Matrix A = new Matrix(5, 5).random().printf("%8.2f");
System.out.println("Macierz trójktna górna");

A.upperTriangular().printf("%8.2f");
System.out.println("Macierz trójktna dolna");

A.lowerTriangular().printf("%8.2f");
System.out.println("Macierz diagonalna");
A.diagonal().printf("%8.2f");
}
}
Moemy zbudowa dla macierzy trójktnych lub diagonalnych metod obliczajc

wyznacznik macierzy:
private static double determinant(Matrix x) {
/* Tylko dla macierzy kwadratowych - trójktnych i diagonalnych */
int n = x.getRows();
double tmp = 1.0;
for(int i = 0; i < n; ++i)
tmp *= x.getAt(i, i);
return tmp;
}

Demonstrujc dziaanie metody, moemy obliczy wyznacznik macierzy:

System.out.println("Macierz trójktna górna");
System.out.printf("det A = %.4f\n",
determinant(A.upperTriangular().printf("%8.2f")));
Zwrómy uwag na kolejno dziaa:

A.upperTriangular() — zamieniamy macierz A na macierz trójktn,
A.upperTriangular().printf("%8.2f") — zamieniamy macierz A na macierz
trójktn i wywietlamy j w konsoli,
determinant(A.upperTriangular().printf("%8.2f"))) — zamieniamy
macierz A na macierz trójktn, wywietlamy j w konsoli i obliczamy
wyznacznik (nastpnie moemy go wywietli lub wykorzysta w innych
obliczeniach).
Oczywicie moemy skoncentrowa si wycznie na obliczeniu wyznacznika, np.:

double w = determinant(A.lowerTriangular());
Wykonane operacje naturalnie nie zmieniaj macierzy (obiektu) A.

Moemy skorzysta z rozwizania zadania 28.19. Przedstawiona tam metoda reku-
rencyjna pochania duo pamici, co ogranicza równie stopie macierzy obliczanego
wyznacznika. Ponadto zapoyczymy pomys z zadania 28.29 i odpowiednio zmodyfi-
kujemy metod upperTriangle(), dostosowujc j do obliczania wyznacznika.
public double det() {
int n = M.length;
for(int i = 0; i < n-1; ++i) {
for(int j = i+1; j < n; ++j) {
if (tmp.M[i][i] != 0.0) {
for(int k = 0; k < n; ++k)
} else {
for(int k = i+1; k < n; ++k) {
if (tmp.M[k][i] != 0.0) {
for(int m = 0; m < n; ++m) {
}
break;
}
}
}
}
}

double d = 1.0;
for(int i = 0; i < n; ++i)
d *= tmp.M[i][i];
return d;
}
Dziaanie metody sprawdzimy na przykadzie macierzy z wylosowanymi wartociami

elementów:
class Z28_30 {
Matrix A = new Matrix(5, 5).random().mult(10).printf("%8.2f");
System.out.printf("Wyznacznik det A = %f\n", A.det());
}
}

Na podstawie rozwizania zadania 28.23 budujemy w klasie Matrix metod inverse()
zwracajc macierz odwrotn do macierzy (kwadratowej) reprezentowanej przez obiekt.
public Matrix inverse() {
int n = M.length;
Matrix I = new Matrix(n, n);
for(int i = 0; i < n; ++i)
I.M[i][i] = 1.0;
for(int i = 0; i < n; ++i)

for(int j = 0; j < n; ++j) {
if (tmp.M[i][i] != 0.0) {
if (j != i) {
for(int k = 0; k < n; ++k) {
I.M[j][k] -= I.M[i][k]*p;
}
}
} else {
for(int k = i+1; k < n; ++k) {
if (tmp.M[k][i] != 0.0) {
for(int m = 0; m < n; ++m) {
temp = I.M[i][m];
I.M[i][m] = I.M[k][m];
I.M[k][m] = -temp;
}
break;
}
}
}
}

for(int i = 0; i < n; ++i)

if (tmp.M[i][i] != 0.0)
for(int j = 0; j < n; ++j)
I.M[i][j] /= tmp.M[i][i];
else
istnieje");
return I;
}
W przykadzie macierz kwadratow A wypeniamy wartociami losowymi i wyzna-

czamy macierz odwrotn B (B = A–1). Poprawno oblicze sprawdzamy, obliczajc
iloczyny macierzy A·B i B·A. W obu przypadkach powinnimy otrzyma macierz jed-
nostkow. Wyznaczniki macierzy odwrotnych powinny by liczbami odwrotnymi i ich
iloczyn powinien wynosi 1. Uzyskanie takich wyników potwierdzi poprawno zbu-
dowanych metod.
class Z28_31 {
Matrix A = new Matrix(5, 5).random().mult(10).printf("%8.2f");
System.out.println("Macierz odwrotna B");
Matrix B = A.inverse().printf("%8.2f");
System.out.println("Iloczyn macierzy A*B =");
A.mult(B).printf("%8.2f");
System.out.println("Iloczyn macierzy B*A =");
B.mult(A).printf("%8.2f");
System.out.printf("Wyznacznik det A = %f\n", A.det());
System.out.printf("Wyznacznik det B = %f\n", B.det());
System.out.printf("det A * det B = %f\n", A.det()*B.det());
}
}

Ukad n równa liniowych o n niewiadomych:
a11 x1 a12 x2 a1n xn b1
°a21 x1 a22 x2 a2 n xn b 2
°
®...............................................
°
¯°an1 x1 an 2 x2 ann xn b n
moemy zapisa w postaci równania macierzowego (A·X = B):
ª a11 a12 a1n º ª x1 º ª b1 º

«a a22 a2 n »» «« x2 »» «b »
« 21 « 2»
« » «» «»
« » « » « »
¬ a n1 an 2 ann ¼ ¬ xn ¼ ¬bn ¼
Mnoc równanie lewostronnie przez macierz odwrotn do macierzy podstawowej

ukadu, uzyskamy rozwizanie ukadu (X = A–1·B):

1
ª x1 º ª a11 a12 a1n º ª b1 º
«x » «a a22 a2 n »» ««b2 »»
« 2» « 21
«» « » «»
« » « » « »
¬ xn ¼ ¬ a n1 an 2 ann ¼ ¬bn ¼
Wyraenie to moemy w atwy sposób zapisa przy uyciu obiektów i metod klasy
Matrix (X = A.inverse().mult(B)). Podobnie wykonamy sprawdzenie, obliczajc
A.mult(X) i porównujc z kolumn wyrazów wolnych B (wizualnie, po wywietleniu
wyników w konsoli lub po zbudowaniu metody equals() w klasie Matrix).
class Z28_32 {
/* Ukad równa - macierz odwrotna */
Matrix A = new Matrix(3, 3).random();
Matrix B = new Matrix(3, 1).random();
Matrix X;
System.out.println("Ukad równa A*X = B");
System.out.println("Macierz gówna A = ");
A.printf("%8.2f");
System.out.println("Kolumna wyrazów wolnych B = ");
B.printf("%8.2f");
System.out.println("Rozwizanie ukadu X = ");
X = A.inverse().mult(B).printf("%8.2f");
System.out.println("Sprawdzenie A*X = ");
A.mult(X).printf("%8.2f");
}
}

Do klasy Matrix doczmy metod replaceCol(). Metoda ta wykonuje kopi obiektu
(macierzy) i podstawia w miejscu wskazanej kolumny wartoci elementów z jedno-
kolumnowej macierzy przekazanej jako parametr (liczba wierszy obu macierzy musi
by równa).
public Matrix replaceCol(int k, Matrix c) {
if (k < 0 || k > M[0].length-1 || c.M.length != M.length
|| c.M[0].length != 1)
throw new ArithmeticException("Niewaciwe dane");
int n = M.length;
for(int i = 0; i < n; ++i)
tmp.M[i][k] = c.M[i][0];
return tmp;
}
Zdefiniowan metod replaceCol() wykorzystamy do rozwizania ukadu równa

metod wyznaczników. Obliczmy wyznacznik gówny double w = A.det(). Jeli wy-
znacznik gówny jest róny od zera, to ukad jest oznaczony. W ptli obliczamy wy-
znaczniki dla kolejnych zmiennych — zastpujemy kolumn wspóczynników przy
tej zmiennej przez kolumn wyrazów wolnych, liczymy wyznacznik i warto niewia-
domej (Matrix Wx = new Matrix(A).replaceCol(i, B); X.setAt(i, 0, Wx.det());
X.setAt(i, 0, X.getAt(i, 0)/w);).

class Z28_33 {
/* Ukad równa - metoda wyznaczników */
int n = 4;
Matrix A = new Matrix(n, n).random().mult(10);
Matrix B = new Matrix(n, 1).random().mult(5);
Matrix X = new Matrix(n, 1);
System.out.println("Macierz gówna A = ");

A.printf("%8.2f");
double w = A.det();
System.out.printf("Wyznacznik gówny W = %.4f\n", w);
System.out.println("Kolumna wyrazów wolnych B = ");

B.printf("%8.2f");
if (w != 0) {
for(int i = 0; i < n; ++i) {
System.out.printf("Macierz Wx[%d]\n", i);
Matrix Wx = new Matrix(A).replaceCol(i, B).
printf("%8.2f");
X.setAt(i, 0, Wx.det());
System.out.printf("Wyznacznik Wx[%d] = %.4f\n",
i, X.getAt(i, 0));
X.setAt(i, 0, X.getAt(i, 0)/w);
}
System.out.println("Rozwizanie ukadu X = ");
X.printf("%8.2f");
System.out.println("Sprawdzenie A*X = ");
A.mult(X).printf("%8.2f");
} else
}
}
Moemy tu dostrzec pewne komplikacje wynikajce z wywietlania wyników pored-

nich; bez tego rachunek mógby wyglda tak:
X.setAt(i, 0, new Matrix(A).replaceCol(i, B).det()/w)
Jeli wyznacznik gówny jest zerem, to wywietlilimy informacj, e ukad jest sprzecz-
ny lub nieoznaczony. Czytelnik moe ten fragment rozbudowa o analiz wartoci
wszystkich wyznaczników i orzeczenie, czy ukad jest sprzeczny (co najmniej jeden
wyznacznik róny od zera), czy nieoznaczony (wszystkie wyznaczniki równe zero).
29. Obliczanie wartoci funkcji,

rekurencja i inne zadania
Po uruchomieniu programu dla przykadowych danych zawartych w tablicy x zauwa-
ymy, e metoda f() zwraca bezwzgldn warto liczby. Metod t moemy nazwa

skrótem abs (jak postpilibymy w wikszoci jzyków programowania), pochodz-

cym od angielskiej nazwy absolute value (bezwzgldna warto liczby).
class Z29_1 {
public static double f(double x) {
return (x > 0)?x:-x;
}

double[] x = {-3.3, -2.15, -1.0, 0.0, 1.25, 3,1415, 7.5};
for(double a: x)
System.out.println("a = "+a+",\tf(a) = "+f(a));
}
}
Jedynie dla liczby 0,0 zamiast spodziewanej wartoci 0,0 otrzymamy –0,0. Wynika to
z istnienia w typach liczb zmiennoprzecinkowych dwóch reprezentacji zera. Wspo-
mnian niedogodno (dotyczc zera) moemy wyeliminowa, modyfikujc nieznacz-
nie kod metody:
static double abs(double x) {
return (x >= 0)?x:-x;
}
Zadanie 29.2. MinMax.java, Z29_2.java

Budujemy klas MinMax zawierajc metody min() i max() z dwoma parametrami tego
samego typu (double, float, int lub long):
class MinMax {
public static double min(double x, double y) {
if (x <= y)
return x;
else
return y;
}
public static double max(double x, double y) {
if (x >= y)
return x;
else
return y;
}
/* pozostae metody... */
}
Zamiast instrukcji warunkowej moemy zastosowa wyraenie warunkowe, co skróci

zapis kodu ródowego:
public static double min(double x, double y) {
return (x <= y)?x:y;
}
public static double max(double x, double y) {
return (x >= y)?x:y;
}
Podobnie moemy zmodyfikowa kod pozostaych metod.

Dziaanie metod min() i max() moemy sprawdzi w programie:

class Z29_2 {
/* Liczby typu double */
System.out.println(MinMax.min(2.5, -3.2));
System.out.println(MinMax.min(2.5, 5.2));
/* Liczby typu float */
float a = MinMax.min(-5.66f, 2.0f);
System.out.println(a);
System.out.println(MinMax.max(a, a/2));
/* ... */
}
}

Funkcja f(x) zwraca znak liczby: –1 dla liczb ujemnych, 0 dla 0 i 1 dla liczb dodatnich.
Odpowiedni nazw mogoby by sowo znak, ac. signum lub stosowany w matema-
tyce skrót sgn.
Kod metody sgn() obliczajcej warto tej funkcji moemy zapisa, uywajc instruk-
cji warunkowych:
static int sgn(double x) {
if (x < 0)
return -1;
else if (x == 0.0)
return 0;
else
return 1;
}
lub wyraenia warunkowego:

return (x < 0)?-1:(x == 0)?0:1;
}
W taki sam sposób zdefiniujemy metod sgn() dla innych typów argumentów.
/* Tu wstaw kod metody sgn(). */
System.out.println("Znak liczby -3.56: "+sgn(-3.56));
System.out.println("Znak liczby 0.0: "+sgn(0.0));
System.out.println("Znak liczby 4.2: "+sgn(4.2f));
}
}
Wyraenie x przyjmuje warto 1 dla x > 0 i –1 dla x < 0. Zatem funkcja f x zwraca
x
znak liczby (zob. rozwizanie zadania 29.3). Metod obliczajc warto tej funkcji
moemy nazwa sgn (skrót od ac. signum):


if (x == 0.0)
return 0;
else
return (int)(Math.abs(x)/x);
}
lub:
return ((x == 0.0)?0:(int)(Math.abs(x)/x));
}
W podobny sposób zdefiniujemy metody dla innych typów argumentów. Poniewa

wynik powinien by typu int, a warto wyraenia Math.abs(x)/x jest zgodna z typem
argumentu x, musimy pamita o rzutowaniu tej wartoci na typ int.

a) Funkcja f x, y zwraca maksimum dwóch liczb x i y i moemy t funkcj
oraz odpowiadajc jej metod oznaczy skrótem max.
public static double f(double x, double y) {
return (x+y+Math.abs(x-y))/2;
}
b) Funkcja g x, y zwraca minimum dwóch liczb x i y i moemy t funkcj

oraz odpowiadajc jej metod oznaczy skrótem min.
public static double g(double x, double y) {
return (x+y-Math.abs(x-y))/2;
}
c) Wród liczb x i –x wiksz jest liczba dodatnia, a zatem metoda h() zwraca
bezwzgldn warto liczby x.
public static double h(double x) {
return f(x, -x);
}
Test dziaania metod f() i g() przeprowadzimy na 9 parach liczb, natomiast metod
h() przetestujemy dla 6 wartoci.
class Z29_5 {
/* Tu wstaw kod funkcji f, g, h. */
double[] a = {-3.3, 0.0, 1.25};
double[] b = {-5.12, 0.25, 1.5};
for(double x: a)
for(double y: b) {
System.out.printf("f(%f, %f) = %f\n", x, y, f(x, y));
System.out.printf("g(%f, %f) = %f\n", x, y, g(x, y));
}
for(double x: a)
System.out.printf("h(%f) = %f\n", x, h(x));
for(double x: b)
System.out.printf("h(%f) = %f\n", x, h(x));
}
}


Na podstawie wzorów x 2 x x i x 3 x x x zbudujemy metody square() (kwadrat)
i cube() (szecian). Metody tworzymy w dwóch wersjach: dla argumentów zmienno-
przecinkowych i dla argumentów cakowitych.
class Z29_6 {
public static double square(double x) {
return x*x;
}
public static double cube(double x) {
return x*x*x;
}
public static int square(int x) {
return x*x;
}
public static int cube(int x) {
return x*x*x;
}

System.out.println("Kwadraty i szeciany liczb od 1 do 15");
for(int n = 1; n < 16; ++n)
System.out.printf("%3d%8d%8d\n", n, square(n), cube(n));
System.out.println("Kwadraty i szeciany liczb od 1.0 do 3.0");

double x = 1.0;
while (x <= 3.0) {
System.out.printf("%7.2f%10.4f ", x, square(x));
System.out.printf("%12.6f\n", cube(x));
x += 0.25;
}
}
}

Poniewa x 0 1 , to przyjmujemy 1 jako pocztkow warto potgi (double p = 1.0).
Nastpnie w ptli n-krotnie mnoymy t warto przez podstaw (p *= x).
class Z29_7 {
public static double adoen(double x, int n) {
double p = 1.0;
for(int i = 0; i < n; ++i)
p *= x;
return p;
}
System.out.println("Potgi liczby 2");
for(int n = 0; n <= 10; ++n)
System.out.println(adoen(2, n));
}
}

Wyniki zostan wywietlone w postaci uamka dziesitnego, np. 1.0, mimo e s to

liczby cakowite. Moemy t niedogodno wyeliminowa, stosujc rzutowanie wy-
niku na typ cakowity System.out.println((int)adoen(2, n)); lub definiujc metod
adoen() dla podstawy typu cakowitego:
public static int adoen(int x, int n) {
int p = 1;
for(int i = 0; i < n; ++i)
p *= x;
return p;
}

Zdefiniujmy metody rekurencyjne adoen() dla podstawy zmiennoprzecinkowej:
if (n == 0)
return 1.0;
else
return x*adoen(x, n-1);
}
i dla podstawy cakowitej:

public static int adoen(int x, int n) {
if (n == 0)
return 1;
else
return x*adoen(x, n-1);
}
W obu przypadkach wykadnik moe by dowoln liczb naturaln.
Dziaanie metody moemy sprawdzi, obliczajc kilka potg, np.:

System.out.println("Potgi liczby 2");
for(int n = 0; n <= 10; ++n)
System.out.println(power(2, n));

Zacznijmy od zdefiniowania metody sqr() obliczajcej kwadrat liczby.
public static double sqr(double x) {
return x*x;
}
Zastosowanie metody sqr() zredukuje o poow liczb wywoa rekurencyjnych me-

tody adoen().
if (n == 0)
return 1;
else if (n%2 == 1) // n jest nieparzyste
return x*sqr(adoen(x, (n-1)/2));

else // n jest parzyste

return sqr(adoen(x, n/2));
}
Dziaanie metody moemy sprawdzi, np. wykonujc obliczenia kilku wartoci potg
liczby 2.
for(int i = 0; i <= 10; ++i)
System.out.println(adoen(2, i));
Aby oblicza potgi o podstawie cakowitej, moemy zdefiniowa analogiczne meto-

dy, stosujc typ int lub long.

Metod power() moemy zbudowa, wykorzystujc instrukcj warunkow:
public static double power(double x, int n) {
if (n < 0)
return 1/adoen(x, -n);
else
return adoen(x, n);
}
lub wyraenie warunkowe:

public static double power(double x, int n) {
return (n < 0)?1/adoen(x, -n):adoen(x, n);
}
Metod adoen() utworzymy na podstawie rozwizania zadania 29.7, 29.8 lub 29.9
(w tym ostatnim przypadku potrzebna bdzie metoda sqr()). Dziaanie funkcji spraw-
dzimy, wykonujc obliczenia kilku wartoci potg liczby 2.
for(int i = -10; i <= 10; ++i)
System.out.println(power(2, i));

Na podstawie wzoru iteracyjnego x 1 §¨ x a ·¸ budujemy metod sqrt(). W ptli
2© x¹
przechowujemy w zmiennej pw poprzedni warto przyblienia x i obliczamy kolejn
iteracj. Obliczenia kontynuujemy, gdy rónica (bezwzgldna warto rónicy) jest
dostatecznie dua (wiksza lub równa 0,00000001). Precyzj oblicze moemy zmie-
ni w zalenoci od potrzeb.
class Z29_11 {
public static double sqrt(double a) {
double pw, x = 1;
do {
pw = x;
x = (x+a/x)/2;
} while (Math.abs(pw-x) >= 0.00000001);
return x;
}


System.out.println("Pierwiastki kwadratowe");
for(int i = 1; i <= 20; ++i) {
System.out.printf("%3d%15.8f", i, sqrt(i));
System.out.printf("%15.8f\n", Math.sqrt(i));
}
}
}
Testujc dziaanie metody sqrt(), obliczylimy pierwiastki kwadratowe z liczb od 1

do 20. Wyniki wywietlilimy z dokadnoci do 8 miejsc po przecinku. S one zgod-
ne z wynikami zwróconymi przez metod biblioteczn Math.sqrt().

Rozwizanie zadania jest cakowicie podobne do rozwizania zadania 29.11. Naley
jedynie poprawi nazwy funkcji i zmieni wzór iteracyjny.
class Z29_12 {
public static double cbrt(double a) {
double pw, x = 1;
do {
pw = x;
x = (2*x+a/(x*x))/3;
return x;
}

System.out.println("Pierwiastki szecienne");
for(int i = 1; i <= 20; ++i) {
System.out.printf("%3d%15.8f", i, cbrt(i));
System.out.printf("%15.8f\n", Math.cbrt(i));
}
}
}

Rozwizanie zadania jest uogólnieniem przypadków przedstawionych w zadaniach
29.11 i 29.12. Ze wzgldu na potrzeb czstego obliczania potg o wykadniku ca-
kowitym i podstawie dodatniej wykorzystamy tu jedn z wersji metody adoen() (zob.
zadanie 29.7, 29.8 lub 29.9). Uzyskane wyniki porównamy z wynikami zwróconymi
przez standardow metod Math.pow().
class Z29_13 {
double p = 1.0;
for(int i = 0; i < n; ++i)
p *= x;
return p;
}
public static double nRoot(double a, int n) {

double pw, x = 1;
do {

pw = x;
x = ((n-1)*x+a/adoen(x, n-1))/n;
return x;
}

System.out.println("Pierwiastki n-tego stopnia z 8");
for(int n = 2; n <= 10; ++n) {
System.out.printf("%3d%15.8f", n, nRoot(8, n));
System.out.printf("%15.8f\n", Math.pow(8, 1.0/n));
}
}
}

Oprócz sinusa i cosinusa hiperbolicznego (metody obliczajce warto tych funkcji s
dostpne w klasie Math) mamy cztery inne funkcje hiperboliczne:
sinh x
tangens hiperboliczny tanh x (inne oznaczenia: tgh x lub th x),
cosh x
cosh x 1
cotangens hiperboliczny coth x (inne oznaczenia: ctgh x
sinh x tanh x
lub cth x),
1
secans hiperboliczny sech x ,
cosh x
1
cosecans hiperboliczny csch x .
sinh x
class Z29_14{
static String[] title = {" x ", "sinh x", "cosh x", "tanh x",
"coth x", "sech x", "csch x"};
System.out.println("Tablice funkcji hiperbolicznych\n");
for(String str: title)
System.out.printf("%9s", str);
double x, sh, ch, th;
for(int n = -50; n <= 50; ++n) {
x = (double)n/10;
sh = Math.sinh(x); // sinus hiperboliczny
ch = Math.cosh(x); // cosinus hiperboliczny
th = sh/ch; // tangens hiperboliczny
System.out.printf("%9.1f%9.4f%9.4f%9.4f", x, sh, ch, th);
// cotangens, secans i cosecans hiperboliczny
System.out.printf("%9.4f%9.4f%9.4f\n", 1/th, 1/ch, 1/sh);
}
}
}
Skompilowany program uruchamiamy poleceniem

java Z29_14 > FunkcjeHiperboliczne.txt
i wyniki zostan przekierowane z konsoli do pliku tekstowego.


1
Wprowadzimy dodatkowe zmienne: ex1 = Math.exp(x) ( e x ) i ex2 = 1/ex1 ( e x ).
ex
e x e x i cosh x
e x e x
Na podstawie wzorów sinh x obliczymy sh = (ex1-ex2)/2
2 2
i ch = (ex1+ex2)/2. Dalsze obliczenia przeprowadzimy tak samo jak w zadaniu 29.14.
double x, ex1, ex2, sh, ch, th;
for(int n = -50; n <= 50; ++n) {
x = (double)n/10;
ex1 = Math.exp(x);
ex2 = 1/ex1;
sh = (ex1-ex2)/2; // sinus hiperboliczny
ch = (ex1+ex2)/2; // cosinus hiperboliczny
th = sh/ch; // tangens hiperboliczny
System.out.printf("%9.4f%9.4f%9.4f\n", 1/th, 1/ch, 1/sh);
}
Jeli wprowadzimy dodatkowe zmienne r=ex1–ex2 i s=ex1+ex2, to dalej moemy obli-

czy sh=r/2; ch=s/2; th=r/s;. Wyraenia obliczajce wartoci kolejnych funkcji
(cotangens, secans i cosecans hiperboliczny) przyjm posta: s/r, 2/s, 2/r:
double x, ex1, ex2, r, s, sh, ch, th;
for(int n = -50; n <= 50; ++n) {
x = (double)n/10;
ex1 = Math.exp(x);
ex2 = 1/ex1;
r = ex1-ex2;
s = ex1+ex2;
sh = r/2; // sinus hiperboliczny
ch = s/2; // cosinus hiperboliczny
th = r/s; // tangens hiperboliczny
System.out.printf("%9.4f%9.4f%9.4f\n", s/r, 2/s, 2/r);
}
Wyniki oblicze zapiszemy w pliku tekstowym (zob. rozwizanie zadania 29.15).
Zadanie 29.16. FH.java, Z29_16.java

W klasie FH (public class FH {}) zdefiniujemy na podstawie rozwizania zadania
29.14 lub 29.15 metody obliczajce wartoci funkcji hiperbolicznych:
static double sinh(double x) {/* sinus hiperboliczny */
double ex = Math.exp(x);
return (ex-1/ex)/2;
}
static double cosh(double x) {/* cosinus hiperboliczny */

return (ex+1/ex)/2;

static double tanh(double x) {/* tangens hiperboliczny */

double ex1 = Math.exp(x);
double ex2 = 1/ex1;
return (ex1-ex2)/(ex1+ex2);
}
static double coth(double x) {/* cotangens hiperboliczny */

double ex1 = Math.exp(x);
double ex2 = 1/ex1;
return (ex1+ex2)/(ex1-ex2);
}
static double sech(double x) {/* secans hiperboliczny */

return 2/(ex+1/ex);
}
static double csch(double x) {/* cosecans hiperboliczny */

return 2/(ex-1/ex);
}
Funkcje odwrotne do funkcji hiperbolicznych moemy obliczy na podstawie wzorów:
area sinus hiperboliczny arsinh x

ln x x 2 1 — funkcja odwrotna
do sinusa hiperbolicznego:
static double arsinh(double x) {/* area sinus hiperboliczny */
return Math.log(x+Math.sqrt(x*x+1));
}
area cosinus hiperboliczny arcosh x

ln x x 2 1 dla x t 1 — funkcja
odwrotna do cosinusa hiperbolicznego:
static double arcosh(double x) {/* area cosinus hiperboliczny */
return Math.log(x+Math.sqrt(x*x-1));
}
1 1 x
area tangens hiperboliczny artanh x ln — funkcja odwrotna
2 1 x
do tangensa hiperbolicznego:
static double artanh(double x) {/* area tangens hiperboliczny */
return Math.log((1+x)/(1-x))/2;
}
1 x 1
area cotangens hiperboliczny arcoth x ln — funkcja odwrotna
2 x 1
do cotangensa hiperbolicznego:
static double arcoth(double x) {/* area cotangens hiperboliczny */
return Math.log((x+1)/(x-1))/2;
}

§ 1 1·
area secans hiperboliczny arsech x ln¨¨ 2 1 ¸¸ — funkcja odwrotna
© x x¹
do secansa hiperbolicznego:
static double arsech(double x) {/* area secans hiperboliczny */
return Math.log(Math.sqrt(1/(x*x)-1)+1/x);
}
§ 1 1·
area cosecans hiperboliczny arcsch x ln¨¨ 1 2 ¸¸ — funkcja odwrotna
© x x¹
do cosecansa hiperbolicznego:
static double arcsch(double x) {/* area cosecans hiperboliczny */
return Math.log(Math.sqrt(1+1/(x*x))+1/x);
}
Demonstrujc dziaanie zdefiniowanych metod, obliczymy wartoci funkcji hiperbo-

licznych (w ptli) dla kilku wybranych argumentów, jednoczenie dla uzyskanych
wyników obliczymy wartoci funkcji odwrotnej (obliczenia zestawimy w trzech ko-
lumnach). Porównujc pierwsz i trzeci kolumn, sprawdzimy poprawno oblicze.
System.out.println("Sinus hiperboliczny i area sinus hiperboliczny");
double x = -7.05, y;
while (x < 10) {
y = FH.sinh(x);
System.out.printf("%15.7f%15.7f%15.7f\n", x, y, FH.arsinh(y));
x += 1.47;
}
Podobne obliczenia przeprowadzimy dla pozostaych funkcji hiperbolicznych i funk-

cji do nich odwrotnych.
Zadanie 29.17. FTD.java, 29_17.java

W klasie FTD (public class FTD {}) zdefiniujemy metody obliczajce wartoci funk-
cji trygonometrycznych, w których argumentem jest miara kta wyraona w stopniach.
Wykorzystamy w tym celu metody zdefiniowane w klasie Math (sin(), cos() i tan())
oraz sta Math.PI.
static double sin(double x) { /* sinus */
return Math.sin(x/180*Math.PI);
}
static double cos(double x) { /* cosinus */

return Math.cos(x/180*Math.PI);
}
static double tan(double x) { /* tangens */

return Math.tan(x/180*Math.PI);
}
Wyraenie x/180*Math.PI przeliczajce stopnie na radiany moemy zastpi wywoa-

niem metody Math.toRadians(x).

Na podstawie zalenoci cot x 1 (cotangens), 1 (secans) i 1

sec x csc x
tan x cos x sin x
(cosecans) zdefiniujemy:
static double cot(double x) { /* cotangens */
return 1/Math.tan(x/180*Math.PI);
}
static double sec(double x) { /* secans */

return 1/Math.cos(x/180*Math.PI);
}
static double csc(double x) { /* cosecans */

return 1/Math.sin(x/180*Math.PI);
}
W klasie Math zdefiniowano trzy metody obliczajce wartoci funkcji odwrotnych

do funkcji trygonometrycznych: arcus sinus (asin()), arcus cosinus (acos()) i arcus
tangens (atan()), zwracajce wynik (miar kta) wyraony w radianach. Dzielc wy-
nik przez S i mnoc przez 180, otrzymamy miar kta w stopniach, np. Math.asin(x)/
Math.PI*180. Podane wyraenie moemy zastpi wywoaniem metody toDegrees()
z klasy Math (Math.toDegrees(Math.asin(x))).
static double arcsin(double x) {
return Math.asin(x)/Math.PI*180;
}
static double arccos(double x) {

return Math.acos(x)/Math.PI*180;
}
static double arctan(double x) {

return Math.atan(x)/Math.PI*180;
}
Wykorzystamy zalenoci tan x 1 , 1 i 1 do wyznaczenia funk-

cos x sin x
cot x sec x csc x
cji odwrotnych dla funkcji cotangens, secans i cosecans.
static double arccot(double x) {
return Math.atan(1/x)/Math.PI*180;
}
static double arcsec(double x) {

return Math.acos(1/x)/Math.PI*180;
}
static double arccsc(double x) {

return Math.asin(1/x)/Math.PI*180;
}
Do klasy doczymy dwie metody zamieniajce miary któw: stopnie na radiany

(degToRad()) i radiany na stopnie (radToDeg()).

static double degToRad(double x) {

return x/180*Math.PI;
}
static double radToDeg(double x) {

return x/Math.PI*180;
}
Demonstrujc dziaanie metod z klasy FTD, zbudujemy tablic funkcji trygonometrycz-

nych dla wybranych któw (o mierze wyraonej w stopniach).
System.out.println("Funkcje trygonometryczne\n");
String[] title = {"x", "sin x", "cos x", "tan x", "cot x", "sec x", "csc x"};
for(String s:title)
System.out.printf("%10s", s);
double[] alfa = {0.1, 1.0, 15.0, 30.0, 45.0, 60.0, 75.0, 89.0, 89.9};
for(double x: alfa) {
System.out.printf("%10.1f%10.4f%10.4f", x, FTD.sin(x), FTD.cos(x));
System.out.printf("%10.4f%10.4f", FTD.tan(x), FTD.cot(x));
System.out.printf("%10.4f%10.4f\n", FTD.sec(x), FTD.csc(x));
}
Testujc dziaanie funkcji odwrotnych, obliczymy miary któw ostrych w tzw. trójk-
cie egipskim (trójkt prostoktny o bokach dugoci 3, 4 i 5 jednostek).
System.out.println("\nFunkcje odwrotne do funkcji trygonometrycznych");
System.out.println("Obliczanie miary kta ostrego w trójkcie egipskim");
System.out.println("(a = 3, b = 4 i c = 5)\n");
double a = 3.0, b = 4.0, c = 5.0; // boki trójkta egipskiego
System.out.println("sin A = "+a/c+",\tA = "+FTD.arcsin(a/c)+"°");
System.out.println("cos A = "+b/c+",\tA = "+FTD.arccos(b/c)+"°");
System.out.println("tan A = "+a/b+",\tA = "+FTD.arctan(a/b)+"°");
System.out.println("cot A = "+b/a+",\tA = "+FTD.arccot(b/a)+"°");
System.out.println("sec A = "+c/b+",\tA = "+FTD.arcsec(c/b)+"°");
System.out.println("csc A = "+c/a+",\tA = "+FTD.arccsc(c/a)+"°");
Na koniec sprawdzimy, ile stopni ma radian i jak czci radiana jest stopie.
System.out.println("\nKonwersja miar któw");
System.out.println("1 rad = "+FTD.degToRad(1)+"°");
System.out.println("1° = "+FTD.radToDeg(1)+" rad");
Zadanie 29.18. FTR.java, Z29_18.java

Moemy skopiowa kod klasy FTD do pliku FTR.java i zmieni nazw klasy na FTR.
Nie zmieniamy kodu metod dokonujcych zamiany miar któw, natomiast w pozo-
staych metodach usuwamy wyraenia zamieniajce stopnie na radiany (z wyraenia
x/180*Math.PI pozostawiamy x) i radiany na stopnie (w metodach obliczajcych war-
toci funkcji odwrotnych usuwamy /Math.PI*180).
public class FTR {
/* Funkcje trygonometryczne - miara kta wyraona w radianach */
static double sin(double x) { /* sinus */

return Math.sin(x);
}
/* itd. */
/* Funkcje odwrotne - wynik w radianach */

static double arcsin(double x) {
return Math.asin(x);
}
/* itd. */
/* Konwersje miar któw */

/* Kod pozostawiamy bez zmian. */
}
Przykadowe obliczenia wykonamy dla kta o mierze 60°, zaczynajc od zamiany miary
stopniowej kta na miar ukow (w radianach):
double a = FTR.degToRad(60);
System.out.println("a = "+a+" rad");
System.out.println("sin a = "+FTR.sin(a));
System.out.println("cos a = "+FTR.cos(a));
System.out.println("tan a = "+FTR.tan(a));
System.out.println("cot a = "+FTR.cot(a));
System.out.println("sec a = "+FTR.sec(a));
System.out.println("csc a = "+FTR.csc(a));
System.out.println("a = "+FTR.radToDeg(a)+"\u00B0");
}
}

Notatki


Programowanie W Jezyku Java. Zbior Zadan Z Podpowiedziami - Wiesaw Rychlicki

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programowanie W Jezyku Java. Zbior Zadan Z Podpowiedziami - Wiesaw Rychlicki

Uploaded by

Copyright:

Available Formats

Ebookpoint.pl kopia dla: pawher@o2.

Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi

Redaktor prowadzący: Ewelina Burska

Projekt okładki: Studio Gravite/Olsztyn

Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock.

Materiały do książki można znaleźć pod adresem:

Copyright © Helion 2012

• Poleć książkę na Facebook.com • Księgarnia internetowa

• Kup w wersji papierowej • Lubię to! » Nasza społeczność

Ebookpoint.pl kopia dla: pawher@o2.pl

Ebookpoint.pl kopia dla: pawher@o2.pl

Rozdzia 4. Czwarty krok — pliki, tablice i macierze ......................................... 77

Ebookpoint.pl kopia dla: pawher@o2.pl

W pocztkowych rozdziaach umieszczono w tekcie zada sugerowane nazwy plików

Ebookpoint.pl kopia dla: pawher@o2.pl

Ebookpoint.pl kopia dla: pawher@o2.pl

Ebookpoint.pl kopia dla: pawher@o2.pl

Poszukaj niezbdnych plików w internecie, wykorzystujc np. fraz Java download,

Ebookpoint.pl kopia dla: pawher@o2.pl

Skorzystaj z opcji pomocy, jak oferuje program java.exe.

2. JDK, Notatnik i klasyczny

Ebookpoint.pl kopia dla: pawher@o2.pl

Skorzystaj z przygotowanych wczeniej plików wsadowych i dysku X:.

W systemie Windows kod ródowy pisany jest w Notatniku (strona kodowa

Uyj kilka razy instrukcji System.out.println("...");. Moesz równie zapisa

W tym zadaniu i zadaniach podobnych wywietlenie wiersza tekstu (z przejciem

Ebookpoint.pl kopia dla: pawher@o2.pl

3. Znaki, tablice znaków i klasa String

Przy okazji poznae komentarz liniowy (wierszowy) stosowany w kodach ródowych.

Tablica znaki moe przechowywa maksymalnie 15 elementów (tak warto podali-

Ebookpoint.pl kopia dla: pawher@o2.pl

Tablic znaków moemy równie wypeni wartociami (zainicjowa) w trakcie defi-

Mamy dwie równowane deklaracje zmiennej tablicowej:

Tablic moemy zainicjowa list wartoci umieszczon w nawiasach { }. Rozmiar

Rozmiar tablicy mona odczyta za pomoc odwoania nazwaTablicy.length6.

Indeksy elementów tablicy s liczbami cakowitymi i nale do przedziau od 0 do n–1,

Ebookpoint.pl kopia dla: pawher@o2.pl

c) poziomo — wielkimi literami,

Parametrem metody print() (println()) moe by zmienna typu char. Przydatna

Ebookpoint.pl kopia dla: pawher@o2.pl

Przestawiaj kolejno pary elementów tablicy: pierwszy z ostatnim, drugi z przedostat-

Ebookpoint.pl kopia dla: pawher@o2.pl

Zadeklaruj tablic znaków o odpowiednim wymiarze. Wykorzystaj tabel kodów ASCII

4. Klasa String — operacje na tekstach

Ebookpoint.pl kopia dla: pawher@o2.pl

Rozwiemy teraz kilka zada podobnych do zada z rozdziau 3. Zastpimy tablic

Ebookpoint.pl kopia dla: pawher@o2.pl

b) poziomo — znaki rozdzielone dodatkowymi odstpami (tzw. spacjowanie

W podpunktach a) i b) moesz skorzysta z ptli typu for i metody charAt(). Mona

Zob. wskazówk do zadania 4.4.

Ebookpoint.pl kopia dla: pawher@o2.pl

Zob. wskazówk do zadania 4.7.

5. Tablica argumentów aplikacji

W tablicy zawarte s referencje do obiektów typu String przekazanych przez system

Pole args.length zawiera liczb przekazanych argumentów. Argumenty w progra-

W kolejnych zadaniach wykorzystamy tablic argumentów do przekazywania danych

Ebookpoint.pl kopia dla: pawher@o2.pl

Wielkoci liter na wydruku powinny by zgodne z przykadem, niezalenie od tego,

Wypisz bdy, które powstan podczas uruchomienia aplikacji z niewaciw liczb

6. Prawda czy fasz

Klasa Boolean opakowuje prosty typ boolean.

Ebookpoint.pl kopia dla: pawher@o2.pl

 & lub && — koniunkcj (iloczyn logiczny, AND),

W pocztkowych rozdziaach umieszczono w tekcie zada sugerowane nazwy plików

Skorzystaj z przygotowanych wczeniej plików wsadowych i dysku X:.

W systemie Windows kod ródowy pisany jest w Notatniku (strona kodowa

Uyj kilka razy instrukcji System.out.println("...");. Moesz równie zapisa

W tym zadaniu i zadaniach podobnych wywietlenie wiersza tekstu (z przejciem

Tablica znaki moe przechowywa maksymalnie 15 elementów (tak warto podali-

Tablic znaków moemy równie wypeni wartociami (zainicjowa) w trakcie defi-

Mamy dwie równowane deklaracje zmiennej tablicowej:

Tablic moemy zainicjowa list wartoci umieszczon w nawiasach { }. Rozmiar

Rozmiar tablicy mona odczyta za pomoc odwoania nazwaTablicy.length6.

Indeksy elementów tablicy s liczbami cakowitymi i nale do przedziau od 0 do n–1,

Parametrem metody print() (println()) moe by zmienna typu char. Przydatna

Rozwiemy teraz kilka zada podobnych do zada z rozdziau 3. Zastpimy tablic

W podpunktach a) i b) moesz skorzysta z ptli typu for i metody charAt(). Mona

W tablicy zawarte s referencje do obiektów typu String przekazanych przez system

Wielkoci liter na wydruku powinny by zgodne z przykadem, niezalenie od tego,

Wypisz bdy, które powstan podczas uruchomienia aplikacji z niewaciw liczb

& lub && — koniunkcj (iloczyn logiczny, AND),

| lub || — alternatyw (sum logiczn, OR).

c) prawo podwójnego przeczenia p p .

W zapisie matematycznym wyrae logicznych zastosowano nastpujce symbole:

Przyjmijmy, e wartoci logiczne s uporzdkowane i false poprzedza true. Impli-

e) prawo eliminacji implikacji p q p q .

Warto cakowit (potrzebn do oblicze) zawart w obiekcie moemy uzyska przy

Zwró uwag na kolejno wykonywania dziaa, gdy operatora + uywasz do oblicze

Parametry s przekazywane do programu jako acuchy znaków. Potrzebna bdzie

Z kadym z wymienionych typów prostych zwizana jest klasa opakowujca — Byte,

Kada z wymienionych klas posiada metody zwracajce warto reprezentowan przez

Jeden z konstruktorów klasy String tworzy acuch znaków na podstawie tablicy

Skorzystaj z rozwizania zadania 8.4 i pamitaj, e kody cyfr s równe: 0 — 48,

Zamie tekst na cig bajtów, a nastpnie przedstaw bajty w postaci szesnastkowej.

Moemy zastosowa metod statyczn doubleToLongBits() z klasy Double i zamie-

Pierwszy parametr (acuch_formatujcy) jest acuchem znaków (obiektem klasy

szeroko — okrela szeroko pola, czyli liczb znaków przeznaczonych

Znacznik formatujcy rozpoczyna si znakiem % i koczy (obowizkowym) znakiem

Liczby 2, 3, 5, 7, 11, 13 i 17 umie w tablicy. Zastosuj ptl typu for each do

Zgodnie z definicj n x x n , wic do obliczania pierwiastków mona wykorzysta

Wykorzystaj specyfikatory %o, %d i %x w acuchu formatujcym.

Dane uytkownik wprowadza z klawiatury. Wyniki naley wywietli z dokadnoci

Wykorzystaj metody klasy Scanner do przeczytania danych z acucha znaków.

Wicej informacji mona znale w dokumentacji: http://docs.oracle.com/javase/1.5.0/

Zacznij od zbudowania acucha znaków "(, )", do którego nastpnie wstawisz

Zacznij od zbudowania acucha znaków "(#1, #2)". Podacuchy "#1" i "#2"

Z acucha znaków naley wydoby podacuchy reprezentujce liczby a i b

Dugo wektora obliczymy ze wzoru u a 2 b2 c2 .

Instrukcja warunkowa ma posta

Najpierw obliczana jest warto wyraenia logicznego. Jeeli wyraenie ma warto