Java - podręcznik
Niniejszy podręcznik stanowi element innowacji społecznej HEAR_IT, która powstała w ramach Inkubatora Włączenia Społecznego.
Niniejszy podręcznik stanowi element innowacji społecznej HEAR_IT, która powstała w ramach Inkubatora Włączenia Społecznego.
- TAGS
- programowanie
- java
- komputer
Create successful ePaper yourself
Turn your PDF publications into a flip-book with our unique Google optimized e-Paper software.
<strong>podręcznik</strong> hearIT<br />
JAVA<br />
niech kod będzie z Tobą!<br />
Powrót do spisu treści
Wydawca: Bartosz Kosiński – Far Beyond Business<br />
Licencja: Creative Commons BY-SA<br />
ISBN: 978-83-63278-75-5<br />
Autorzy: Bartosz Kosiński, Kamila Chęcińska<br />
Redaktor: Bartosz Kosiński<br />
Opracowanie graficzne, skład i korekta: Piotr Kulig<br />
HEAR_IT: www.hearit.pl
Niniejsza publikacja stanowi część innowacji społecznej HEAR_<br />
IT opracowanej przez Stowarzyszenie Edukacji Pozaformalnej<br />
„Meritum”.<br />
Innowacja uzyskała wsparcie finansowe w ramach projektu Inkubator<br />
Włączenia Społecznego, który realizowany jest przez<br />
Regionalny Ośrodek Polityki Społecznej w Krakowie, Fundację<br />
Rozwoju Demokracji Lokalnej im. Jerzego Regulskiego oraz<br />
Uniwersytet Jagielloński w Krakowie.<br />
Projekt wdrażany w ramach IV Osi Priorytetowej Programu<br />
Operacyjnego Wiedza Edukacja Rozwój (Działanie 4.1: Innowacje<br />
społeczne), na zlecenie Ministerstwa Rozwoju, finansowany<br />
jest ze środków Unii Europejskiej w ramach Europejskiego Funduszu<br />
Społecznego. Projekt jest realizowany od 1 października<br />
2020 r. do 30 września 2023 r. w całej Polsce. Wartość projektu<br />
wynosi 5 855 993,00 zł.
Podręcznik hearIT – JAVA<br />
Wprowadzenie 6<br />
Programowanie 9<br />
Algorytmy 15<br />
Zmienne 22<br />
Instrukcja wejścia/wyjścia 33<br />
Listy i tablice 38<br />
Instrukcje warunkowe 44<br />
Pętle w języku JAVA 49<br />
Funkcje 57<br />
Obiekty i Klasy 66<br />
Podsumowanie 70
Wprowadzenie<br />
Z różnych, mniejszych i większych komputerów, korzystamy<br />
każdego dnia. Korzystamy ze smartfonów, laptopów, prowadzimy<br />
samochody, które często mają już swoje własne komputery<br />
pokładowe i wielu innych sprzętów. Większość komputerów<br />
składa się z obudowy i ukrytych w środku układów<br />
elektronicznych. Te elementy elektroniczne to między innymi<br />
rezystory, kondensatory, tranzystory i procesory. Osoba, która<br />
obsługuje urządzenie elektroniczne, nie musi znać tych nazw.<br />
Budowa typowego komputera jest na tyle skomplikowana, że<br />
tylko niewielu specjalistów umie dokładnie powiedzieć, który<br />
element do czego służy. Ale skoro obsługujesz komputer, to<br />
tak naprawdę zmuszasz jego układy elektroniczne do działania.<br />
Więc może jeszcze o tym nie wiesz, ale już trochę programujesz<br />
i trochę jesteś programistą!<br />
Komputer osobisty to laptop lub komputer stacjonarny. Laptop<br />
ma baterię i można go używać w podróży. Komputer stacjonarny<br />
ma monitor i jest na stale podłączony do prądu. Mimo tych<br />
różnic, każdy komputer osobisty działa bardzo podobnie. Moż-<br />
6<br />
Powrót do spisu treści
Wprowadzenie<br />
na na nim czytać, przeglądać internet, oglądać filmy, słuchać<br />
muzyki. Można też tworzyć: pisać, publikować w internecie,<br />
montować filmy i nagrywać muzykę. Ale sam komputer jako<br />
obudowa i układy elektroniczne nie poradziłby sobie z tymi zadaniami.<br />
Potrzebne są też programy komputerowe. Taki podstawowy<br />
program służący do obsługi pozostałych programów<br />
nazywa się system operacyjny. W komputerach osobistych stosuje<br />
się przede wszystkim systemy operacyjne Windows, macOS<br />
i Linux. Każdy z nich ma wiele wersji i może różnie wyglądać.<br />
Ale mają one bardzo ważną wspólną cechę – służą do<br />
podstawowej obsługi komputera i dają możliwość uruchamiania<br />
aplikacji, czyli programów. Część programów dostępna jest<br />
od razu z systemem operacyjnym, na przykład kalkulator. Inne<br />
trzeba dodatkowo zainstalować i służą konkretnym celom, na<br />
przykład Google Chrome to przeglądarka internetu.<br />
Wiesz już, że skoro zmuszasz komputer do działania, to w pewnym<br />
sensie jesteś programistą. Żeby stać się programistą tak<br />
naprawdę (w pełnym tego słowa znaczeniu), musisz napisać<br />
swój własny program komputerowy. Jak to zrobić? Okazuje<br />
się, że to bardzo proste. Programy dla komputerów osobistych<br />
z systemami operacyjnymi Windows, macOS i Linux można<br />
napisać na przykład za pomocą języka programowania <strong>Java</strong>.<br />
I o tym właśnie jest ten <strong>podręcznik</strong>.<br />
7<br />
Powrót do spisu treści
Programowanie<br />
Programowanie to tworzenie programów komputerowych.<br />
Użytkownik widzi gotowy program komputerowy, na przykład<br />
kalkulator w komputerze. Kalkulator wymaga, żeby podać mu<br />
dwie liczby i działanie, jakie ma wykonać. Dla uproszczenia<br />
przyjmijmy, że nasz kalkulator tylko dodaje liczby. W takiej sytuacji,<br />
gdy użytkownik poda liczby 2 i 3, to kalkulator da wynik<br />
5. Ale skąd komputer wie, co ma zrobić z liczbami? Do tego<br />
potrzebny jest program komputerowy o nazwie Kalkulator. Taki<br />
program składa się z wielu linijek znaków, które w całości nazywamy<br />
kodem źródłowym programu. Fragment kodu przykładowego<br />
kalkulatora wygląda następująco:<br />
public class ProstyKalkulator {<br />
public static void main(String[] args) {<br />
int x, y, z;<br />
System.out.println(„Podaj pierwszą liczbę:”);<br />
x = getInt();<br />
System.out.println(„Podaj drugą liczbę:”);<br />
8<br />
Powrót do spisu treści
Programowanie<br />
y = getInt();<br />
z = x + y;<br />
System.out.println(„Wynik dodawania: „ + z);<br />
}<br />
}<br />
Powyższy fragment kodu napisano w języku programowania <strong>Java</strong>.<br />
Są różne języki programowania. Najpopularniejsze języki programowania<br />
to: C, Python, C++, C#, Visual Basic, <strong>Java</strong>Script, PHP, R,<br />
Groovy, Asembler, SQL, Swift, Go, Ruby, Matlab, Perl, Objective-C,<br />
Delphi, Classic Visual Basic. Jest ich dużo więcej, podobnie jak<br />
języków, w których komunikują się ludzie. Języki programowania<br />
służą komunikacji pomiędzy człowiekiem a komputerem, a dokładnie<br />
do wydawania komputerowi poleceń.<br />
Języki programowania różnią się między innymi poziomem<br />
tego, jak bardzo są zrozumiałe dla komputera, a jak bardzo dla<br />
człowieka. <strong>Java</strong> jest przykładem języka wysokiego poziomu,<br />
czyli łatwego do zrozumienia dla człowieka. W powyższym<br />
przykładzie znajdują się wyłącznie słowa wymyślone przez programistę<br />
i komendy w języku angielskim. Programista wymyślił<br />
słowa i zdania: „Podaj pierwszą liczbę”, „Podaj drugą liczbę”.<br />
„Int” to skrót od „integer” (liczba całkowita), „getInt” (pobierz<br />
liczbę całkowitą) oznacza pobranie danych od użytkownika,<br />
„println” (Print in new line – wydrukować tekst w nowej linijce)<br />
9<br />
Powrót do spisu treści
Programowanie<br />
to polecenie, które służyło wydrukowaniu wyniku, gdy jeszcze<br />
nie było monitorów, a dziś służy do wyświetlania na ekranie. Te<br />
i kolejne polecenia zostaną omówione w następnych rozdziałach<br />
<strong>podręcznik</strong>a.<br />
Żeby komputer zrozumiał kod napisany w języku <strong>Java</strong>, kod ten<br />
trzeba dodatkowo przetłumaczyć (skompilować). Kompilacja<br />
to proces przekształcania kodu zapisanego przez programistę<br />
na kod zrozumiały dla komputera. Językiem skrajnie niskiego<br />
poziomu jest kod maszynowy. Jest to język programowania<br />
w pełni zrozumiały dla komputera, ale bardzo trudny do zrozumienia<br />
dla człowieka. Przykładowy fragment kodu maszynowego<br />
wygląda tak:<br />
000000 00001 00010 00110 00000 100000<br />
Dzieje się tak, ponieważ pamięć komputera składa się z ogromnej<br />
liczby jednostek zwanych bitami. Bit może mieć tylko dwie<br />
wartości: 0 lub 1. „0” oznacza się też jako FALSE (fałsz), a „1”<br />
jako TRUE (prawda). Dla komputera odpowiedź na pytanie<br />
„Czy pada deszcz?” można zapisać w postaci jednego bitu: 0 –<br />
nie pada; 1 – pada.<br />
Środowisko programistyczne<br />
Sam kod programu można zapisać nawet na kartce papieru,<br />
ale byłoby to bardzo niewygodne. Najlepsze miejsca na pisanie<br />
10<br />
Powrót do spisu treści
Programowanie<br />
kodu <strong>Java</strong> to takie, gdzie od razu można wypróbować działanie<br />
programu, który piszemy. Żeby komputer mógł zrozumieć polecenia<br />
w języku <strong>Java</strong>, konieczne jest skorzystanie z odpowiedniego<br />
środowiska programistycznego. Dobrym rozwiązaniem<br />
na początek nauki programowania w <strong>Java</strong> jest zainstalowanie<br />
pakietu JDK. Co to jest?<br />
JDK to <strong>Java</strong> Development Kit. Jest to środowisko programistyczne,<br />
czyli zestaw narzędzi i bibliotek niezbędnych do programowania<br />
w języku <strong>Java</strong>. JDK zawiera w sobie tzw. JRE,<br />
czyli <strong>Java</strong> Runtime Environment. Jest to środowisko uruchomieniowe,<br />
czyli zestaw elementów niezbędny do uruchomienia<br />
programów napisanych w języku <strong>Java</strong>. JRE natomiast zawiera<br />
w sobie tzw. JVM. JVM to <strong>Java</strong> Virtual Machine (wirtualna<br />
maszyna Javy), której zadaniem jest odpowiednio tłumaczyć<br />
i wykonywać już skompilowany kod, niezależnie od systemu<br />
operacyjnego, na którym się znajduje.<br />
Jak zainstalować narzędzia niezbędne do programowania<br />
w <strong>Java</strong> (instalacja JDK)?<br />
<strong>Java</strong> jest dynamicznie rozwiajana. Dość szybko pojawiają się<br />
kolejne wersje. Tak więc dziś numerek pliku do pobrania bądź<br />
katalogu po instalacji może się różnic od tego zaprezentowanego<br />
w przykładach.<br />
11<br />
Powrót do spisu treści
Programowanie<br />
1. Przejdź na stronę Oracle do sekcji download i pobierz (JDK)<br />
<strong>Java</strong> SE Development Kit dla swojego systemu:<br />
https://www.oracle.com/technetwork/java/javase/downloads/<br />
index.html<br />
Zainstaluj wybierając domyślnie opcje w instalatorze.<br />
2. W Zmiennych środowiskowych systemu Windows ustaw<br />
nową zmienną systemową JAVA_HOME do katalogu JDK<br />
(na przykład C:\Program Files\<strong>Java</strong>\jdk-x.x.x)<br />
12<br />
Powrót do spisu treści
Programowanie<br />
3. Nadal w Zmiennych środowiskowych systemu Windows<br />
znajdź i zaznacz zmienną Path. Wybierz Edytuj, następnie<br />
Nowy i tu z kolei podaj ścieżkę do katalogu Bin w JDK<br />
(na przykład C:\Program Files\<strong>Java</strong>\jdk1.8.0_151\bin)<br />
13<br />
Powrót do spisu treści
Programowanie<br />
4. Otwórz okno linii poleceń (cmd) i wpisz polecenie java –<br />
version.<br />
Jeśli wszystko przebiegło pomyślnie to zostanie zwrócona<br />
wersja zainstalowanej Javy.<br />
5. Uruchom IDE (InteliJ, NetBeans lub Eclipse) i zacznij pisać<br />
programy.<br />
Jeżeli potrzebujemy szybko wypróbować prosty fragment<br />
kodu, możemy też skorzystać z jednego z wielu środowisk<br />
programistycznych dostępnych online, na przykład:<br />
https://www.programiz.com/java-programming/online-compiler/+<br />
14<br />
Powrót do spisu treści
Algorytmy<br />
Kod programu komputerowego jest zapisem algorytmu. Algorytm<br />
to schemat postępowania, czyli zestaw instrukcji. To nie<br />
temat tego <strong>podręcznik</strong>a, dlatego omówimy tylko do czego wykorzystujemy<br />
algorytmy w programowaniu i jak są zbudowane.<br />
Algorytm może być przedstawiony na różne sposoby. Jednym<br />
z nich jest schemat blokowy. Jakie bloki możemy wyróżnić?<br />
wprowadzanie/<br />
wyprowadzanie<br />
danych<br />
15<br />
Powrót do spisu treści
Algorytmy<br />
wykonywanie działań<br />
16<br />
Powrót do spisu treści
Algorytmy<br />
Przykładem algorytmu z życia codziennego jest przepis kulinarny.<br />
Bardzo prosty algorytm ilustrujący przepis na spaghetti<br />
wygląda następująco:<br />
Ugotuj makaron<br />
NIE<br />
Czy chcesz<br />
danie mięsne?<br />
TAK<br />
Dodaj mięso<br />
Dodaj warzywa<br />
STOP<br />
17<br />
Powrót do spisu treści
Algorytmy<br />
Podobnie projektuje się program komputerowy. Program<br />
komputerowy jest zestawem poleceń (instrukcji) dla komputera.<br />
W naszym przykładzie poleceniami było: „Ugotuj makaron”,<br />
„Dodaj mięso”, „Dodaj warzywa”. Komputer zamiast tego<br />
może wykonać obliczenie, wyświetlić tekst na ekranie, skopiować<br />
dane, wydać dźwięk, itd. W naszym algorytmie pojawiło<br />
się pytanie „Czy chcesz danie mięsne?”. W takiej sytuacji odpowiedź<br />
zmienia sposób realizacji przepisu na spaghetti: powstanie<br />
danie mięsne lub bezmięsne. W kodzie programu byłaby<br />
to instrukcja warunkowa, której działanie byłoby zależne<br />
od odpowiedzi użytkownika. Na przykład kalkulator zapytałby,<br />
czy użytkownik chce, żeby dodać do siebie liczby, czy żeby<br />
odjąć od siebie liczby. Przed napisaniem programu w języku<br />
<strong>Java</strong> warto narysować sobie podobny schemat, żeby wiedzieć,<br />
co chcemy osiągnąć. Spróbujmy zatem to zrobić. Zaczynamy<br />
oczywiście od bloku „Start” i wprowadzenia dwóch liczb od<br />
użytkownika. Liczby te przechowamy w tak zwanych zmiennych.<br />
O nich porozmawiamy sobie w dalszej części <strong>podręcznik</strong>a.<br />
Na potrzeby tego zadania załóżmy, że są to takie miejsca<br />
do przechowania liczb.<br />
18<br />
Powrót do spisu treści
Algorytmy<br />
Podaj pierwszą liczbę,<br />
liczba1<br />
Podaj pierwszą liczbę,<br />
liczba2<br />
Zwróćmy uwagę, że bloki połączone są za pomocą strzałki. To<br />
ona wytycza kierunek wykonywania się algorytmu. Kolejnym<br />
krokiem byłoby zsumowanie wartości. Do tego posłuży nam<br />
blok operacji.<br />
Podaj pierwszą liczbę,<br />
liczba1<br />
Podaj pierwszą liczbę,<br />
liczba2<br />
suma:= liczba1+liczba2<br />
19<br />
Powrót do spisu treści
Algorytmy<br />
Wynik dodawania został przechowany w nowo utworzonej<br />
zmiennej „suma”. Pora zakończyć algorytm.<br />
Co by było, gdybyście chcieli wykonać dzielenie? algorytm wyglądałby<br />
bardzo podobnie, ale musielibyśmy zabezpieczyć się<br />
przed dużym błędem, jakim jest dzielenie przez 0. Zobaczmy<br />
jakby to wyglądało w naszym algorytmie.<br />
Podaj pierwszą liczbę,<br />
liczba1<br />
Podaj pierwszą liczbę,<br />
liczba2<br />
suma:= liczba1+liczba2<br />
STOP<br />
20<br />
Powrót do spisu treści
Algorytmy<br />
Dodatkowo dołożyliśmy blok warunkowy, który sprawdza, czy<br />
wartość znajdująca się pod zmienną liczba2 jest różna 0. Jeżeli<br />
tak, to wyświetla się komunikat, że nie można wykonać tego<br />
działania (jest to lewa odnoga algorytmu), w przeciwnym razie<br />
(prawa odnoga algorytmu) działanie zostanie wykonane. Algorytmy<br />
pomagają nam zaprogramować program przed jego<br />
napisaniem. Dzięki nim tworzymy plan, którego będziemy się<br />
trzymali podczas pisania kodu, aby o niczym nie zapomnieć<br />
i nie pogubić się.<br />
21<br />
Powrót do spisu treści
Zmienne<br />
Wyobraźmy sobie grę, w której użytkownik zdobywa punkty<br />
za swoje osiągnięcia. Komputer zapamiętuje liczbę punktów<br />
użytkownika. Jeżeli użytkownik zdobędzie dodatkowy punkt,<br />
liczba punktów się zwiększa. Gdzie komputer zapamiętuje liczbę<br />
punktów użytkownika? Wszystko to odbywa się w pamięci<br />
komputera.<br />
Pamięć komputera składa się z komórek, w których umieszczane<br />
są wartości. Również nasza liczba punktów znajduje się<br />
w jednej z nich. Takie miejsce w pamięci komputera, w którym<br />
przechowujemy jakąś liczbę nazywamy w programowaniu<br />
zmienną.<br />
Nasza zmienna ma specjalną etykietę, na której znajduje się nazwa.<br />
Dzięki niej komputer będzie mógł szybciej odnaleźć naszą<br />
zmienną. Jak tworzymy zmienną w języku <strong>Java</strong>?<br />
Zacznijmy od stworzenia najprostszego programu, który wyświetli<br />
nam na ekranie słowa: „Witaj świecie!”.<br />
22<br />
Powrót do spisu treści
Zmienne<br />
public class HelloWorld {<br />
public static void main (String[] args) {<br />
System.out.println(„Witaj Świecie”);<br />
}<br />
}<br />
Każdy program w języku <strong>Java</strong> będzie składał się z jednej,<br />
głównej, publicznej klasy (public class). W tym wypadku nazywa<br />
się ona HelloWorld – jest to nazwa naszego całego programu.<br />
W ramach tej jednej, głównej klasy będziemy tworzyli<br />
klasy dodatkowe, które będą poszczególnymi częściami, fragmentami<br />
naszego programu, odpowiedzialnymi za robienie<br />
różnych rzeczy.<br />
Jak w takim razie dodać do naszego programu zmienne? Dodanie<br />
(czyli deklaracja) zmiennej do programu wymaga w języku<br />
<strong>Java</strong> podania typu zmiennej oraz jej nazwy. W języku <strong>Java</strong><br />
istnieje 8 podstawowych typów zmiennych, które decydują,<br />
jakiego rodzaju wartości można w takiej zmiennej przechowywać.<br />
W każdym języku programowania będziemy mieli 3 podstawowe<br />
typy zmiennych:<br />
1. Takie, które przechowują liczby (zmienne liczbowe)<br />
2. Takie, które przechowują znaki i/lub tekst (zmienne tekstowe)<br />
23<br />
Powrót do spisu treści
Zmienne<br />
3. Takie, które przechowują wartości logiczne – prawda/fałsz<br />
(zmienne logiczne)<br />
Typy zmiennych liczbowych w Javie:<br />
1. Dla liczb całkowitych:<br />
• byte – 1 bajt – pozwala zapisać liczby w zakresie od – 128<br />
do 127,<br />
• short – 2 bajty – zakres od – 32 768 do 32 767,<br />
• int – 4 bajty – zakres od – 2 147 483 648 do 2 147 483 647,<br />
• long – 8 bajtów – zakres od – 2^63 do (2^63)-1 (posiadają<br />
przyrostek L, lub l).<br />
2. Dla tzw. Liczb zmiennoprzecinkowych, czyli takich, które<br />
mają miejsca dziesiętne po przecinku:<br />
• float – 4 bajty – max ok 6-7 liczb po przecinku (posiadają<br />
przyrostek F, lub f),<br />
• double – 8 bajtów – max ok 15 cyfr po przecinku (posiadają<br />
przyrostek D, lub d).<br />
Każda zadeklarowana zmienna rezerwuje sobie określoną liczbę<br />
miejsca w pamięci. Powoduje to, że w zależności od tego, jak<br />
dużą liczbę planujemy zapisać w danej zmiennej, powinniśmy<br />
dopasować do tego rodzaj zmiennej. Jeśli planujemy w zmiennej<br />
przechowywać liczbę uczniów w danej klasie, spokojnie<br />
powinna nam do tego wystarczyć zmienna typu byte. Jakiego<br />
typu zmiennej powinniśmy użyć do zapisania wieku wybranej<br />
24<br />
Powrót do spisu treści
Zmienne<br />
osoby? Za rekordzistkę długości życia ludzkiego uznaje się Jeanne<br />
Louise Calment, obywatelkę Francji. Francuzka żyła 122<br />
lata. Tym samym również i w tym wypadku zmienna typu byte<br />
powinna być w pełni wystarczająca. Ale gdybyśmy chcieli zapisać<br />
wiek żółwia (które mogą żyć nawet 150 lat!) to już konieczne<br />
będzie wykorzystanie zmiennej short. Jeśli chcielibyśmy<br />
w zmiennej zapisać liczbę osób żyjących w Polsce (ok. 38 mln)<br />
czy nawet w Chinach (ok. 1,4 mld) to spokojnie wystarczy nam<br />
zmienna int. Ale już do zapisania liczby ludności całego świata<br />
(ponad 8 mld) będziemy musieli zadeklarować zmienną long.<br />
Typ zmiennej tekstowej w Javie:<br />
Char – służy do zapisania pojedynczego znaku, np. A, X, C.<br />
Typ zmiennej logicznej w Javie:<br />
Boolean – służy do zapisania zmiennej logicznej, która może<br />
zawierać dwie możliwe wartości:<br />
true – prawda<br />
false – fałsz<br />
Przykładowe sposoby deklarowania zmiennych w <strong>Java</strong>:<br />
int promienKola = 8;<br />
char b;<br />
double x, y;<br />
promienKola, b, x, y w powyższych przykładach to nazwy na-<br />
25<br />
Powrót do spisu treści
Zmienne<br />
szych zmiennych. Pojedynczą linię kodu w Javie najczęściej będziemy<br />
kończyli znakiem średnika ;<br />
W pierwszym przykładzie zapis „= 8” oznacza, że w momencie<br />
deklaracji zmiennej, przypisaliśmy do niej konkretną wartość.<br />
W pozostałych dwóch przykładach stworzyliśmy po prostu<br />
zmienne o danym typie i nazwie. W dalszej części programu<br />
będziemy mogli do tych zmiennych przypisać wartości, póki co<br />
są one puste (null), czyli nie mają w sobie żadnej przypisanej<br />
wartości.<br />
W ostatnim przykładzie pojawiły się dwie nazwy zmiennych po<br />
przecinku: x oraz y. Możemy w jednej linijce kodu zadeklarować<br />
większą liczbę zmiennych danego typu, zamiast więc pisać:<br />
int liczbaOsob;<br />
int wiekOsob;<br />
int wzrostOsob;<br />
możemy je zadeklarować następująco:<br />
int liczbaOsob, wiekOsob, wzrostOsob;<br />
Czasami będziemy deklarowali zmienne, które nigdy nie powinny<br />
się zmienić. W takiej sytuacji będziemy musieli wykorzystać<br />
słowo FINAL. Jak to będzie wyglądało? Jeśli chcemy<br />
zadeklarować zmienną określającą liczbę dni w tygodniu użyjemy<br />
składni:<br />
26<br />
Powrót do spisu treści
Zmienne<br />
final byte liczbaDniWTygodniu = 7;<br />
Jest to tzw. Stała, czyli zmienna o stałej, niezmiennej wartości.<br />
Na zmiennych możemy wykonywać różnego rodzaju operacje,<br />
w przypadku zmiennych liczbowych mogą to być np. operacje<br />
arytmetyczne, takie jak dodawanie (+), odejmowanie (-), mnożenie<br />
(*) czy dzielenie (/).<br />
Poniżej znajduje się przykład fragmentu programu, który obliczy<br />
nam liczbę osób uczących się w danej klasie:<br />
int liczbaDziewczynek = 10;<br />
int liczbaChlopcow = 9;<br />
int uczniowieWCalejKlasie;<br />
uczniowieWCalejKlasie = liczbaDziewczynek + liczbaChlopcow;<br />
Pamiętacie wzór na pole koła?<br />
Obwód koła liczymy ze wzoru π*r2 (gdzie r oznacza promień<br />
koła).<br />
Możemy to zapisać w programie w taki sposób:<br />
final float π = 3.14f;<br />
int promienR = 8;<br />
float pole;<br />
pole = pi * promienR * promienR;<br />
27<br />
Powrót do spisu treści
Zmienne<br />
Właśnie wykonaliśmy nasze pierwsze „operacje” na zmiennych.<br />
W programowaniu możemy wykonywać różne operacje na<br />
zmiennych wykorzystując odpowiednie znaki. Znaki te nazywane<br />
są operatorami. Poniżej znajdują się operatory stosowane<br />
w języku <strong>Java</strong>:<br />
Znak Operacja Przykład<br />
+ dodawanie PUNKTY = PUNKTY + 1<br />
-<br />
odejmowanie<br />
PUNKTY = PUNKTY – 1<br />
* mnożenie PUNKTY = PUNKTY * 2<br />
wartość<br />
/<br />
całkowita<br />
z dzielenia<br />
PUNKTY = PUNKTY // 2<br />
%<br />
reszta<br />
z dzielenia<br />
PUNKTY = PUNKTY % 2<br />
class Operacje {<br />
public static void main(string[] args) {<br />
int a = 17;<br />
int b = 4;<br />
int c = a + b; //=21<br />
System.out.println(c);<br />
28<br />
Powrót do spisu treści
Zmienne<br />
c = a – b; //=13<br />
System.out.println(c);<br />
c = a * b; //=68<br />
System.out.println(c);<br />
c = a / b; //=4 ponieważ ta operacje podaje tylko<br />
wynik całkowity z dzielenia, bez reszty<br />
System.out.println(c);<br />
c = a % b; //=1 czyli reszta z dzielenia<br />
System.out.println(c);<br />
}<br />
}<br />
Bardzo często używane są skrócone formy znaków na przykład<br />
„+=”, „-=”, „*=”, „/=” i tak dalej.<br />
W takiej sytuacji zamiast pisać np.:<br />
zmiennaX = zmiennaX + 5;<br />
możemy napisać:<br />
zmiennaX += 5;<br />
albo zamiast:<br />
liczbaUczniow = liczbaUczniow – 1;<br />
liczbaUczniow – = 1;<br />
Musisz pamiętać, że nie można wykonywać na zmiennych<br />
operacji, które nie są zgodne z jej typem. Czyli np. jeśli mamy<br />
29<br />
Powrót do spisu treści
Zmienne<br />
zmienną o typie char (tekstowym), to nie możemy do niej niczego<br />
dodawać ani od niej odejmować. Ale podobnie, jeśli<br />
mamy zmienną całkowitą (np. int), to nie możemy do niej dodawać<br />
liczb po przecinku.<br />
Jeśli mamy taki fragment programu:<br />
int x = 0;<br />
x = x + 1.1; // program się nie skompiluje, dostaniemy komunikat<br />
‘cannot convert from double to int’<br />
ale w tej samej sytuacji zadziała następująca operacja:<br />
x += 1.1; // operatory łączone, takie jak += czy /= mają ukrytą<br />
konwersję, więc w takim wypadku zmienna x po tej operacji<br />
będzie miała wartość równą 1.<br />
Jeśli chodzi o zmienne, to warto zapamiętać dwa pojęcia:<br />
1. Deklaracja zmiennej – to określenie typu i nazwy zmiennej.<br />
2. Inicjalizacja zmiennej – to nadanie wartości zmiennej.<br />
Więc int x; // to zadeklarowanie zmiennej o nazwie x i typie<br />
integer.<br />
x = 2; // to inicjalizacja zmiennej przez przypisanie do niej<br />
wartości – 2.<br />
Natomiast int y=5; // to jednoczesne zadeklarowanie zmiennej<br />
o nazwie y i typie integer, ale jednocześnie jej inicjalizacja<br />
30<br />
Powrót do spisu treści
Zmienne<br />
poprzez przypisanie wartości równej 5.<br />
Jak tworzymy nazwy zmiennych? Obowiązują tu następujące<br />
zasady.<br />
Nazwa zmiennej:<br />
• musi zaczynać się od litery, znaku „_” lub znaku dolara „$”,<br />
• może zawierać liczbę, ale nie może znajdować się ona na<br />
początku nazwy,<br />
• może zawierać małe i duże litery,<br />
• nie może zawierać spacji,<br />
• nie może być taka sama, jak nazwa zastrzeżona w języku<br />
<strong>Java</strong> (np. class, public, void),<br />
• niezalecane jest używanie polskich znaków (ą,ę, etc.). Co<br />
prawda <strong>Java</strong> skompiluje i uruchomi poprawnie taki kod, ale<br />
jest to bardzo zła praktyka!<br />
Przykłady poprawnych nazw zmiennych:<br />
liczba, Liczba, LICZBA<br />
liczba1, liczba_1, Liczba1_Liczba2<br />
Wymyślona nazwa przypisana jest do zmiennej i nie może być<br />
użyta ponownie do nazwy innej zmiennej. Należy jednak pamiętać,<br />
że zmienne: liczba, Liczba, LICZBA to trzy całkiem różne<br />
zmienne dla komputera, gdyż nazwy zmiennych składają się<br />
z innych znaków.<br />
31<br />
Powrót do spisu treści
Zmienne<br />
Natomiast każda z poniższych nazw jest niepoprawna i spowoduje<br />
błąd kompilacji:<br />
double 314ToPi; // nazwa nie może zaczynać się od liczby,<br />
int promien kola; // spacja w nazwie jest niedozwolona,<br />
int liczba#pracownikow; // znak # nie może wystąpić w nazwie,<br />
int class; // class to słowo kluczowe w języku <strong>Java</strong>.<br />
32<br />
Powrót do spisu treści
Instrukcje wejścia/wyjścia<br />
Do wyświetlania na ekranie służy funkcja „print()” lub „println()”.<br />
Różnica między nimi jest taka, że print wyświetli napis zaraz po<br />
poprzednim, a println wyświetli napis w nowej linijce.<br />
Język <strong>Java</strong> bazuje na różnego rodzaju klasach, dlatego nie<br />
wszystkie słowa klucze, takie jak print czy println, zadziałają<br />
samodzielnie. Na tym etapie nie ma potrzeby, by wyjaśniać to<br />
zagadnienie dokładniej, ale musisz pamiętać, że pełny i poprawny<br />
zapis powinien wyglądać przy tych dwóch instrukcjach<br />
następująco, jeśli chcemy, by tekst został wyświetlony w konsoli<br />
na ekranie komputera:<br />
System.out.print()<br />
System.out.println()<br />
Wyświetlmy zatem napis na ekranie.<br />
public class Main {<br />
public static void main(String[] args) {<br />
System.out.print(„Ala ma kota!”);<br />
33<br />
Powrót do spisu treści
Instrukcje wejścia/wyjścia<br />
}<br />
}<br />
Wynik:<br />
Ala ma kota!<br />
Ale gdybyśmy ten program trochę zmodyfikowali:<br />
public class Main {<br />
public static void main(String[] args) {<br />
System.out.print(„Ala”);<br />
System.out.print(„ma”);<br />
System.out.print(„kota!”);<br />
}<br />
}<br />
To wynik byłby następujący:<br />
Alamakota!<br />
Natomiast przy takiej modyfikacji:<br />
public class Main {<br />
public static void main(String[] args) {<br />
System.out.println(„Ala”);<br />
System.out.println(„ma”);<br />
System.out.println(„kota!”);<br />
}<br />
}<br />
34<br />
Powrót do spisu treści
Instrukcje wejścia/wyjścia<br />
Otrzymalibyśmy wynik:<br />
Ala<br />
ma<br />
kota!<br />
Napis, który chcemy wyświetlić, umieszczamy wewnątrz nawiasów<br />
półokrągłych. Nie możemy zapomnieć także o cudzysłowie.<br />
Jeżeli chcemy zrobić przejście do kolejnej linijki wewnątrz<br />
napisu, to dodajemy do niego „\n”.<br />
public class Main {<br />
public static void main(String[] args) {<br />
System.out.print(„Ala ma \n kota!”);<br />
}<br />
}<br />
Wynik:<br />
Ala ma<br />
kota!<br />
Jak wyświetlić na ekranie wartość zmiennej? To także bardzo<br />
proste. Wewnątrz nawiasów półokrągłych umieszczamy nazwę<br />
naszej zmiennej. Nie umieszczamy jej nazwy w cudzysłowie,<br />
gdyż to by oznaczało, że chcemy wyświetlić taki napis, a nie<br />
wartość zmiennej o takiej samej nazwie. Zobaczmy różnicę.<br />
35<br />
Powrót do spisu treści
Instrukcje wejścia/wyjścia<br />
public class Main {<br />
public static void main(String[] args) {<br />
int zmienna = 5;<br />
System.out.print(zmienna);<br />
}<br />
}<br />
Wynik: 5<br />
A co, jeśli chcemy wprowadzić wartość z klawiatury? Używaliśmy<br />
System.out do wyświetlania danych na ekranie. Do wprowadzania<br />
danych należy użyć analogicznego System.in.<br />
System.in ma jedną wadę – pozwala nam odczytywać z klawiatury<br />
tylko kody znaków.<br />
Co to oznacza? Że np. liczba „A” zostanie zakodowana i wczytana<br />
jako liczba 65.<br />
Aby obejść ten problem musimy użyć bardziej złożonej konstrukcji.<br />
Nie przejmuj się, jeśli nie wszystkie fragmenty poniższego<br />
kodu będą dla Ciebie do końca jasne, z czasem poznasz<br />
je dużo dokładniej!<br />
InputStream inputStream = System.in;<br />
Reader inputStreamReader = new InputStreamReader(input-<br />
Stream);<br />
36<br />
Powrót do spisu treści
Instrukcje wejścia/wyjścia<br />
BufferedReader bufferedReader = new BufferedReader(input-<br />
StreamReader);<br />
String imie = bufferedReader.readLine(); //Wczytaj z klawiatury<br />
ciąg tekstowy<br />
String sWiek = bufferedReader.readLine(); //Wczytaj z klawiatury<br />
ciąg tekstowy<br />
int nWiek = Integer.parseInt(sWiek); //Konwertuj ciąg<br />
tekstowy na liczbę.<br />
37<br />
Powrót do spisu treści
Listy i tablice<br />
Wyobraźmy sobie program, który ma za zadanie odczytanie<br />
wartości średnich temperatur z siedmiu dni tygodnia. Jak komputer<br />
może przechować te wartości? Oczywiście wiemy już,<br />
że można utworzyć siedem zmiennych. Nie byłoby to jednak<br />
wygodne rozwiązanie. W sytuacjach, w których chcemy zapamiętać<br />
kilka wartości, stosujemy listy i tablice. Czym one są?<br />
Lista/tablica zawiera uporządkowany zbiór danych. Jak to wygląda?<br />
Możemy je porównać do pasażerów siedzących w przedziale<br />
pociągu.<br />
38<br />
Powrót do spisu treści
Listy i tablice<br />
Każdy z pasażerów siedzi na miejscu, które ma swój numer. Na<br />
liście elementy znajdują się na pozycjach – oznaczonych numerami<br />
– zwanych indeksami. Można to zobrazować następująco:<br />
indeksy: 0 1 2 3 4 5<br />
25 23.9 „kot”<br />
„Ola ma<br />
psa”<br />
0.5 9<br />
Na którym miejscu na liście znajduje się słowo „kot”? Na indeksie<br />
numer 2. Który to z kolei element listy/tablicy? To 3 element.<br />
Zwróćmy uwagę, że elementy numerujemy od 0!<br />
Różnica między tablicami i listami jest przede wszystkim taka,<br />
że listy mogą mieć zmienną ilość elementów. Druga dość ważna<br />
różnica to sposób, w jaki używamy list. Przykładowo, nie<br />
bierzemy kolejnego elementu przez podanie kolejnego numeru<br />
w nawiasach kwadratowych ale poprzez odpowiednią metodę<br />
– get(nr). Na dokładne rozróżnienie list i tablic przyjdzie<br />
jeszcze pora. W tym momencie skupimy się już na samych tablicach.<br />
Jak stworzyć tablicę?<br />
Zaczynamy od określenia typu danych, które będą przechowywane<br />
w tablicy i wymyślenia jej nazwy, np:<br />
Int[] tablicaPierwsza<br />
39<br />
Powrót do spisu treści
Listy i tablice<br />
Definiowanie tablicy nie różni się więc bardzo od definiowania<br />
zmiennych, musimy tylko pamiętać o dodaniu kwadratowych<br />
nawiasów [ i ].<br />
Zanim jednak będziemy mogli używać tablicy, musimy ją utworzyć,<br />
co możemy zrobić na co najmniej na dwa sposoby:<br />
Wykorzystując słowo kluczowe new i podając, z ilu elementów<br />
maksymalnie będzie się składać dana tablica.<br />
Zainicjować tablicę w momencie jej definiowania wprowadzając<br />
wartości w nawiasach klamrowych { i }.<br />
int[] calkowite = new int[5];<br />
taka tablica może przechowywać maksymalnie 5 liczb całkowitych<br />
double[] rzeczywiste = { 3.14, 10, – 2.5 };<br />
taka tablica przechowuje już w momencie tworzenia 3 wartości<br />
liczbowe:<br />
3,14 na pozycji (indeksie) 0<br />
10 na pozycji 1<br />
-2,5 na pozycji 2<br />
Wartości umieszczamy w nawiasach kwadratowych oddzielając<br />
je przecinkami.<br />
40<br />
Powrót do spisu treści
Listy i tablice<br />
Jak wyciągnąć z listy któryś z elementów? Jest to bardzo proste!<br />
Wystarczy nam nazwa listy i numer indeksu, na którym ten<br />
element się znajduje.<br />
int[] calkowite = new int[5];<br />
calkowite[0] = 10; // pierwszy element ma indeks 0 (a nie<br />
1)!<br />
calkowite[1] = 15;<br />
całkowite[2] = 24;<br />
całkowite[3] = 1;<br />
calkowite[4] = 200; // piaty element ma indeks 4 (a nie<br />
5)!<br />
Żeby wyświetlić elementy tablicy albo wykonać na nich podstawowe<br />
operacje (tak jak na zmiennych) możemy użyć znanego<br />
już słowa klucza println:<br />
System.out.println(„Suma dwóch pierwszych elementów tablicy<br />
to „ + (calkowite[0] + calkowite[1]) );<br />
System.out.println(„Ostatnim elementem tablicy jest: „ +<br />
calkowite[4]);<br />
Listy w języku <strong>Java</strong> mają wbudowane wiele funkcji, które mogą<br />
nam ułatwić pracę. W tym miejscu poznamy tylko kilka podstawowych,<br />
na kolejne przyjdzie czas, gdy trochę lepiej poznasz<br />
język <strong>Java</strong>.<br />
41<br />
Powrót do spisu treści
Listy i tablice<br />
Zmienną tzw. tablicową można zmierzyć, tzn. sprawdzić, z ilu<br />
składa się elementów, korzystając z atrybutu tablicy o nazwie<br />
length:<br />
public class RozmiarTablicy {<br />
public static void main(String[] args) {<br />
double[] rzeczywiste = { 3, 4, – 20.5, 11.234 };<br />
System.out.println(„Liczba elementow w tablicy rzeczywiste:<br />
„ + rzeczywiste.length);<br />
}<br />
}<br />
Wynikiem tego programu będzie wyświetlony tekst:<br />
Liczba elementow w tablicy rzeczywiste: 4’<br />
Specyficznym złożonym typem zmiennych, których jeszcze<br />
nie poznaliśmy, jest String – który pozwala zapisywać większą<br />
liczbę znaków, a nawet całe zdania. Na poniższym przykładzie<br />
możesz zobaczyć, jak będzie wyglądała praca ze zmienną typu<br />
string i prostą tablicą złożoną z kilku słów.<br />
public class RozmiarStringITablicy {<br />
public static void main(String[] args) {<br />
String tekst = „Witajcie!”;<br />
String[] slowa = { „Ala”, „ma”, „kota” };<br />
System.out.println(„Liczba słów w zmiennej tekst: „ +<br />
42<br />
Powrót do spisu treści
Listy i tablice<br />
tekst.length());<br />
System.out.println(„Liczba elementów w tablicy: „ +<br />
slowa.length);<br />
System.out.println(<br />
„Liczba znaków w pierwszym słowie z tablicy: „ +<br />
slowa[0].length()<br />
);<br />
}<br />
}<br />
Wynikiem tego programu będzie:<br />
Liczba słów w zmiennej tekst: 9<br />
Liczba elementów w tablicy: 3<br />
Liczba znaków w pierwszym słowie z tablicy: 4<br />
43<br />
Powrót do spisu treści
Instrukcje warunkowe<br />
Instrukcja warunkowa jest jedną z podstawowych instrukcji<br />
programowania. Wbrew pozorom używamy jej na co dzień.<br />
Czasami zdarza nam się mówić „Jeśli coś się stanie…”. Na przykład<br />
„Jeśli pójdę spać późnym wieczorem, rano będę śpiący”.<br />
Spróbujmy pomyśleć nad przykładami z naszego życia.<br />
Spójrzmy na kolejny przykład.<br />
„Jeśli w weekend będzie ładna pogoda, wybierzemy się na<br />
spacer. W przeciwnym razie zostanę w domu.”<br />
Spróbujmy zobrazować to zdanie w postaci bloków algorytmu.<br />
TAK<br />
Czy pogoda<br />
jest ładna?<br />
NIE<br />
Pójdziemy na spacer<br />
Zostaniemy w domu<br />
44<br />
Powrót do spisu treści
Instrukcje warunkowe<br />
Zatem instrukcja warunkowa jest jak skrzyżowanie, na którym<br />
komputer musi zdecydować, w którą stronę pójdzie.<br />
Najważniejszy jest warunek. Jeśli warunek zostanie spełniony,<br />
skręcimy w prawo, jeśli nie, w lewo. Proszę spróbować przedstawić<br />
swoje pomysły również z wykorzystaniem bloków algorytmu.<br />
Spójrz na inny przykład.<br />
„Jeśli liczba punktów przekroczy 50, przechodzisz do następnego<br />
poziomu. W przeciwnym razie przegrywasz grę.”<br />
To bardzo popularny przykład z programowania. Jak wygląda<br />
algorytm?<br />
TAK<br />
Czy liczba punktów<br />
przekroczyła 50?<br />
NIE<br />
Przechodzisz dalej<br />
Przegrywasz grę<br />
45<br />
Powrót do spisu treści
Instrukcje warunkowe<br />
Ten sam fragment kodu w języku <strong>Java</strong>:<br />
if (punkty > 50){<br />
System.out.println(„Przechodzisz do kolejnego etapu”);<br />
} else {<br />
System.out.println(„Przegrywasz grę”);<br />
}<br />
Przeanalizujmy, jak zbudowana jest instrukcja warunkowa:<br />
if warunek:<br />
działanie jeżeli warunek jest spełniony<br />
else:<br />
działanie jeżeli warunek nie jest spełniony<br />
Ważny jest warunek. Jeżeli mamy problem z utworzeniem warunku<br />
można sobie zadać pytanie „Od czego teraz zależy, co<br />
się będzie działo dalej?”. Warunek jest budowany za pomocą<br />
znaków logicznych. Poniżej są one przedstawione w tabeli.<br />
Znak<br />
Znaczenie<br />
ab<br />
a jest większe niż b<br />
a==b<br />
a jest równe b<br />
46<br />
Powrót do spisu treści
Instrukcje warunkowe<br />
Znak<br />
Znaczenie<br />
a=b<br />
a jest większe bądź równe b<br />
a != b<br />
A jest różne od b<br />
Zobaczmy to na przykładach:<br />
I Czy użytkownik jest pełnoletni?<br />
if (wiek >= 18)<br />
II Czy przekroczono prędkość?<br />
if (predkosc > 50)<br />
III Czy temperatura jest ujemna?<br />
if (temperatura < 0)<br />
IV Czy wpisano liczbę 7?<br />
if (liczba == 7)<br />
Co jeżeli nasza decyzja jest uzależniona od kilku warunków?<br />
Spójrz na ten przykład: Jeśli w weekend będzie ładna pogoda<br />
i mama będzie zdrowa, pójdziemy na spacer. W przeciwnym<br />
razie zostaniemy w domu.<br />
To nie to samo, co: Jeśli w weekend będzie ładna pogoda lub<br />
mama będzie zdrowa, pójdziemy na spacer. W przeciwnym razie<br />
zostaniemy w domu.<br />
47<br />
Powrót do spisu treści
Instrukcje warunkowe<br />
W pierwszym przypadku pójdziemy na spacer jeśli zarówno<br />
pogoda będzie dobra, jak i mama zdrowa. W drugim przypadku<br />
pójdziemy na spacer jeśli spełniony zostanie co najmniej jeden<br />
z warunków. Aby móc wprowadzić dwa warunki, musimy<br />
je połączyć tak zwanymi operatorami logicznymi „or” i „and”.<br />
Operator „or” oznacza polskie „lub”. Stosujemy go, jeżeli chcemy,<br />
by choć jeden warunek został spełniony. Operator „and”<br />
tłumaczymy po polsku jako „i”. Stosując ten operator obydwa<br />
warunki muszą zostać spełnione.<br />
W języku <strong>Java</strong> operator logiczny and oznaczamy za pomocą<br />
znaków &&, a operator logiczny or ||.<br />
Zobaczmy, jak wygląda warunek z zastosowaniem operatorów<br />
logicznych w języku Python. W naszym przykładzie przejście<br />
do kolejnego etapu jest możliwe jeżeli liczba punktów jest<br />
większa od 50.<br />
if (punkty>0 && punkty
Pętle w języku <strong>Java</strong><br />
Pętla for<br />
Czasami chcemy, żeby komputer wykonał jakieś polecenie wielokrotnie.<br />
Żeby napisać:<br />
ha<br />
ha<br />
ha<br />
możemy wielokrotnie napisać ten sam fragment kodu. Będzie<br />
wyglądać to następująco:<br />
System.out.println(„ha”);<br />
System.out.println(„ha”);<br />
System.out.println(„ha”);<br />
Nie jest to kłopot, gdy chcemy coś powtórzyć kilka razy. Ale<br />
powtórzenie czynności kilkadziesiąt albo kilkaset razy będzie<br />
już o wiele rozsądniej zrealizować w inny sposób. Wielokrotne<br />
wykonanie tego samego zestawu instrukcji realizuje się z wykorzystaniem<br />
pętli. Prosta pętla, która wyświetli trzykrotnie „ha”,<br />
tak samo jak w przykładzie powyżej, wygląda następująco:<br />
49<br />
Powrót do spisu treści
Pętle w języku <strong>Java</strong><br />
for (int i = 0; i < 3; i++) {<br />
System.out.println(„ha”);<br />
}<br />
Tłumacząc z angielskiego na polski widzimy tu następującą instrukcję:<br />
Dla zmiennej „i” w zakresie trzech powtórzeń wykonaj<br />
polecenie: wyświetl „ha”. „For” jest tu instrukcją wywołującą<br />
pętlę o nazwie „pętla for”. „i” to zmienna utworzona, żeby<br />
pętla mogła policzyć, ile razy ma się wykonać. „3” to liczba wykonań<br />
pętli. Polecenie „println” jest ujęte w klamrach { }, dzięki<br />
temu komputer wie, że jest ono w pętli, czyli ma się wykonać<br />
tyle razy, ile razy wykonuje się pętla. Wyrażenie i++ oznacza,<br />
że wartość zmiennej i będzie zwiększana o 1 przy każdym wykonaniu<br />
pętli<br />
Żeby lepiej zrozumieć, w jaki sposób komputer interpretuje pętlę,<br />
zmieńmy nieco kod:<br />
for (int i = 0; i < 3; i++) {<br />
System.out.println(i);<br />
}<br />
System.out.println(„ha”);<br />
Program wykonał się w następujący sposób:<br />
0<br />
1<br />
50<br />
Powrót do spisu treści
Pętle w języku <strong>Java</strong><br />
2<br />
ha<br />
Przeanalizujmy całość krok po kroku. Znów zastosowano „pętlę<br />
for” i zmienną „i”. Tym razem po każdym obrocie pętli<br />
komputer wyświetlił wartość zmiennej „i”. Wartość ta przybierała<br />
kolejno „0”, „1” i „2”, czyli faktycznie się zmieniała. W ten<br />
sposób komputer policzył, że pętla ma się wykonać 3 razy. Pamiętajmy<br />
o tym, że dla człowieka 3 razy to „1”, „2” i „3”, a dla<br />
komputera „0”, „1” i „2”. Taki sposób liczenia wynika z omówionego<br />
na początku <strong>podręcznik</strong>a sposoby zapisu danych przez<br />
komputer: pierwszy bit danych zapisuje „0” lub „1”.<br />
W tym samym przykładzie znalazła się dodatkowa linijka wyświetlająca<br />
„ha”. „ha” wyświetliło się tylko raz, ponieważ linijka<br />
ta znalazła się poza klamrą pętli for. Zatem „System.out.println<br />
(„ha”)” nie było tutaj we wnętrzu pętli, a już poza nią.<br />
Zamiast polecenia zmiennej i można zastosować tablicę. Wtedy<br />
pętla wykona się tyle razy, ile jest elementów tablicy:<br />
String[] kolory = {„czerwony”, „pomarańczowy”, „żółty”,<br />
„zielony”, „niebieski”, „granatowy”, „fioletowy”};<br />
for (String i : kolory){<br />
System.out.println(i);<br />
}<br />
51<br />
Powrót do spisu treści
Pętle w języku <strong>Java</strong><br />
Powyższy kod wyświetlił nam kolejno kolory tęczy:<br />
czerwony<br />
pomarańczowy<br />
żółty<br />
zielony<br />
niebieski<br />
granatowy<br />
fioletowy<br />
Pętla wykonała się 7 razy, bo w liście kolory jest 7 elementów.<br />
Zmienna „i” przyjmowała różne wartości dla każdego obiegu<br />
pętli. Były to kolejno „czerwony”, „pomarańczowy”, „żółty” itd.<br />
Obliczenia w pętli<br />
Pętla for, oprócz wyświetlania komunikatów na ekranie, może<br />
również posłużyć wielu innym celom, na przykład obliczeniom<br />
matematycznym. W poniższym przykładzie policzymy, ile wartości<br />
może przyjąć zmienna o podanej liczbie bitów. Wiemy<br />
już, że w jednym bicie mieszczą się tylko dwie wartości: „0”<br />
lub „1”. W dwóch bitach będą to 4 możliwe wartości: „00”, „01”,<br />
„10” i „11”. Każdy kolejny bit to wyższa potęga liczby 2. Spójrzmy<br />
na kod:<br />
int x = 2;<br />
for (int i = 1; i < 11; i++){<br />
System.out.println(i + „: „ + x);<br />
52<br />
Powrót do spisu treści
Pętle w języku <strong>Java</strong><br />
x = x*2;<br />
}<br />
Wynik działania programu wygląda następująco:<br />
1 : 2<br />
2 : 4<br />
3 : 8<br />
4 : 16<br />
5 : 32<br />
6 : 64<br />
7 : 128<br />
8 : 256<br />
9 : 512<br />
10 : 1024<br />
Przed pętlą utworzono zmienną „x” i przypisano jej wartość 2,<br />
ponieważ jeden bit danych może przyjmować tylko dwie różne<br />
wartości (wspomniane „0” lub „1”). Następnie utworzono pętlę<br />
for ze zmienną „i”, która będzie przyjmowała wartości od „1”<br />
do „10”. Dotychczas podawaliśmy tylko liczbę obrotów pętli,<br />
a zmienna „i” przyjmowała wartości od „0”. Tym razem podaliśmy<br />
początkową wartość zmiennej „i”, czyli „1”, i wartość, której<br />
zmienna „i” ma już nie osiągnąć, czyli „11”. W ten sposób<br />
wartość zmiennej „i” przyjmowała wartości od „1” do „10”.<br />
53<br />
Powrót do spisu treści
Pętle w języku <strong>Java</strong><br />
Każdy obieg pętli wyświetlał kolejno:<br />
• wartość zmiennej „i”, która oznaczała tu liczbę bitów danych;<br />
• dwukropek i spację dla lepszej czytelności wyników;<br />
• wartość zmiennej „x”, która oznaczała tu liczbę kombinacji<br />
zer i jedynek, jaką da się zapisać w „i” bitach danych.<br />
Ostatnia linijka kodu sprawia, że na koniec każdego obiegu pętli<br />
zmienna „x” jest mnożona dwukrotnie, czyli stanowi kolejne<br />
wielokrotności liczby 2.<br />
W ten sposób obliczyliśmy, że w jednym bicie da się zapisać<br />
dwie wartości (to już wiedzieliśmy), a w 10 bitach 1024 wartości.<br />
To dlatego w komputerach przedrostek kilo – nie oznacza<br />
1000, a 1024. Na przykład kilobajt to 1024 bajty.<br />
Pętla while<br />
Język programowania <strong>Java</strong> oprócz pętli for, obsługuje jeszcze<br />
„pętlę while”. „While” to po angielsku „dopóki”. Obsługę pętli<br />
while wytłumaczymy na przykładzie:<br />
int i = 0;<br />
while (i < 3) {<br />
System.out.println(„ha”);<br />
i++;<br />
}<br />
54<br />
Powrót do spisu treści
Pętle w języku <strong>Java</strong><br />
Trzykrotnie wyświetli się „ha”, tak samo jak w pierwszym przykładzie<br />
dla pętli for. Kod pętli while jest w tym przykładzie<br />
dłuższy, ale dobrze tłumaczy, jak myśli komputer. W pierwszej<br />
linijce tworzymy zmienną „i”, która jest niezbędna do liczenia<br />
obrotów pętli. Zmienna służąca do zliczenia obiegów pętli nazywa<br />
się w programowaniu: „iterator” (dlatego skrót „i”). W pętli<br />
for to też był iterator. Początkowa wartość iteratora wyniosła<br />
„0”. W drugiej linijce utworzyliśmy pętlę while, która ma się wykonywać<br />
dopóki „i” jest mniejsze od „3”. W pętli wykonują się<br />
dwie instrukcje: wyświetlanie napisu „ha” i zwiększanie wartości<br />
iteratora o 1 przy każdym obiegu pętli. Zatem „ha” wyświetliło<br />
się 3 razy, a iterator w kolejnych 3 obiegach pętli przyjął<br />
wartości: „0”, „1” i „2”.<br />
Kolejny przykład zastosowania pętli while to program wyświetlający<br />
dolary w postaci symboli „$”. Tym razem to zmienna x<br />
zdecyduje, ile razy pętla ma się wykonać:<br />
int i = 0;<br />
int x = 5;<br />
while (i < x){<br />
System.out.print(„$ „);<br />
i++;<br />
}<br />
Jeżeli zmienna x będzie wynosić 5, to na ekranie wyświetli się:<br />
$ $ $ $ $<br />
55<br />
Powrót do spisu treści
Pętle w języku <strong>Java</strong><br />
I tym razem zaczynamy od iteratora „i” o wartości początkowej<br />
„0”. Pętla while ma wykonywać się, dopóki wartość iteratora<br />
jest mniejsza od wartości zmiennej. Początkowa wartość<br />
iteratora to „0”. Po ustawieniu wartości zmiennej x na „5”<br />
w kolejnych obiegach pętli iterator przybrał wartości: „0”, „1”,<br />
„2”, „3”, „4”. Gdy tylko iterator osiągnął wartość „5”, to kolejny<br />
obieg pętli już się nie wykonał. Pętla wykonała się zatem 5 razy.<br />
W każdym obiegu pętli na ekranie wyświetla się „$”. W każdym<br />
obiegu pętli wartość zmiennej „i” zwiększa się o 1.<br />
56<br />
Powrót do spisu treści
Metody (funkcje)<br />
Metoda, nazywana także funkcją, to kod, który jest wprowadzany<br />
raz, ale może być wykonywany wiele razy. Nie jest jednak<br />
kod, który znajduje się w pętli.<br />
Wyobraźmy sobie taki problem. Co zrobić jeśli chcę wykonać<br />
ten sam fragment kodu, ale w różnych częściach projektu? Czy<br />
musimy wielokrotnie powtarzać ten fragment kodu? Nie, jest<br />
na to rozwiązanie! Do tego służą właśnie metody. Spróbujmy<br />
to sobie zwizualizować.<br />
Wyobraźmy sobie, że jesteśmy na łące.<br />
57<br />
Powrót do spisu treści
Metody (funkcje)<br />
Jakie elementy znajdują się na łące? Kwiaty, trawa, rzeka, drzewo,<br />
motyle.<br />
Wyobraźmy sobie, że piszemy program, który rysuje łąkę.<br />
Mamy następujące fragmenty kodu: „rysowanie trawy”, „rysowanie<br />
kwiatka”, „rysowanie trawy”, „rysowanie rzeki”, „rysowanie<br />
kwiatka”, „rysowanie trawy”, „rysowanie rzeki” i tak dalej.<br />
Jakie części kodu się powtarzają? Trawa, kwiat, rzeka powtarzają<br />
się. Załóżmy, że do narysowania kwiatka potrzeba 50 linijek<br />
kodu, a do narysowania trawy potrzeba 25 linijek kodu. Te<br />
fragmenty kodu występują wielokrotnie w naszym projekcie,<br />
ale nie możemy ich wsadzić do pętli tylko musimy pisać wielokrotnie.<br />
Nasz kod jest bardzo długi, prawda? Dlatego stworzymy<br />
3 metody. Pierwsza rysuje trawę, druga kwiat, a trzecia rzekę.<br />
Dzięki temu nie będziemy musieli wielokrotnie pisać tych<br />
linijek kodu. Jeśli chcemy narysować trawę, po prostu wywołamy<br />
metodę „Rysuj trawę”. Zajmie nam to jedną linijkę! Jak to<br />
będzie wyglądało?<br />
Rysuj_trawe();<br />
Rysuj_kwiatka();<br />
Rysuj_trawe();<br />
Rysuj_rzeke();<br />
Rysuj_kwiatka();<br />
Rysuj_trawe();<br />
58<br />
Powrót do spisu treści
Metody (funkcje)<br />
Przejdźmy teraz w inne miejsce. Jesteśmy w mieście. Jakie elementy<br />
infrastruktury się powtarzają? Jakie będą metody?<br />
Rysowanie budynku, rysowanie drogi, rysowanie samochodu.<br />
Zobaczmy kod w Javie:<br />
Rysuj_budynek();<br />
Rysuj_budynek();<br />
Rysuj_droge();<br />
Rysuj_budynek();<br />
Rysuj_samochod();<br />
Rysuj_budynek();<br />
59<br />
Powrót do spisu treści
Metody (funkcje)<br />
Ostatnie ćwiczenie. Jesteśmy teraz w kosmosie.<br />
Jakie elementy się powtarzają? Planety, gwiazdy, meteoryty.<br />
Takie właśnie stworzymy metody w programie „kosmos”!<br />
Rysuj_planete();<br />
Rysuj_gwiazde();<br />
Rysuj_gwiazde();<br />
Rysuj_planete();<br />
Rysuj_meteoryta();<br />
Rysuj_gwiazde();<br />
Tworzone przez nas metody są bardzo proste. Przenieśmy się<br />
ponownie na łąkę. Czy kwiaty, które widzimy, są takie same?<br />
Nie. Różnią się kolorem, liczbą płatków, długością łodygi.<br />
Proszę wyobrazić sobie, że jesteśmy metodą (funkcją) „Rysuj_<br />
kwiatek()”. Teraz proszę wykonać swoje zadanie. Myślę, że po-<br />
60<br />
Powrót do spisu treści
Metody (funkcje)<br />
jawiło się teraz pytanie „jaki kwiatek?”. Właśnie doszliśmy do<br />
bardzo ważnego wniosku – metoda „Rysuj kwiatek” potrzebuje<br />
pewnych informacji, aby móc się wykonać. Proszę narysować<br />
kwiat z 5 niebieskimi płatkami na 3 cm łodyżce. Jakie dane musieliśmy<br />
podać metodzie? Liczba płatków, kolor i długość łodygi.<br />
Są to parametry, czyli dane, które są niezbędne do wykonania<br />
metody. Zatem kod w języku <strong>Java</strong> wyglądałby następująco:<br />
Rysuj_trawe();<br />
Rysuj_kwiatka(5, „niebieski”, 3);<br />
Rysuj_trawe();<br />
Rysuj_rzeke();<br />
Rysuj_kwiatka(3, ”czerwony”, 10);<br />
Rysuj_trawe();<br />
Przejdźmy do przykładu miasta. Proszę o wykonanie metody<br />
„Narysuj budynek”. Jakich danych potrzebujemy do poprawnego<br />
działania? W końcu w mieście mamy różne budynki. Niższe,<br />
wyższe, bloki, kościoły, stacje benzynowe. Jaki budynek<br />
powinna narysować nasza metoda? Aby to wiedzieć, potrzebuje<br />
parametrów!<br />
Kod w języku <strong>Java</strong>:<br />
Rysuj_budynek(10, 20, ”kosciol”);<br />
Rysuj_ budynek(20, 5, ”stacja paliw”);<br />
Rysuj_droge();<br />
61<br />
Powrót do spisu treści
Metody (funkcje)<br />
Rysuj_ budynek(15, 10, ”blok”);<br />
Rysuj_samochod();<br />
Rysuj_budynek(45, 10, ”kosciol”);<br />
Pomyślmy teraz o metodach matematycznych, których możemy<br />
użyć w programowaniu. Wyobraźmy sobie, że jesteśmy metodą<br />
o nazwie „Dodawanie”. Więc zsumujmy liczby! Ale jakie<br />
liczby? Nasza metoda musi mieć parametry, aby móc poprawnie<br />
wykonywać swoją pracę. W tym przypadku są to liczby do<br />
zsumowania. Jeśli nie jesteśmy pewni jakie parametry potrzebuje<br />
nasza metoda zadajmy sobie pytanie „Jakich danych potrzebuje<br />
metoda, aby wykonać swoją pracę?”.<br />
Jak zatem wyglądają metody w języku <strong>Java</strong>?<br />
Każda metoda powinna być zadeklarowana w ramach klasy.<br />
Póki co tworzyliśmy programy z tylko jedną, główną klasą. Metoda<br />
zbudowana jest z następujących elementów:<br />
public class Main {<br />
static void mojaMetoda (argumenty) {<br />
zadania metody<br />
return wartość_zwracana<br />
}<br />
}<br />
62<br />
Powrót do spisu treści
Metody (funkcje)<br />
Pogrubiono elementy, które są obowiązkowe. Słowo static<br />
oznacza, że metoda odnosi się do klasy, a nie do obiektu w ramach<br />
tej klasy. Wiem, że brzmi to przerażająco, ale spokojnie,<br />
w swoim czasie dowiesz się, o co dokładnie chodzi
Metody (funkcje)<br />
Suma została obliczona. Można wynik dodawania wyświetlić<br />
na ekranie lub zwrócić do kodu, jeżeli zostanie on wykorzystany<br />
w dalszej części projektu. Zobaczmy, w jaki sposób można<br />
zwrócić wartość do kodu.<br />
public class Main {<br />
static int dodaj2Liczby(int Liczba1, int Liczba2) {<br />
int wynik;<br />
wynik = Liczba1 + Liczba2;<br />
return wynik;<br />
}<br />
public static void main(String[] args) {<br />
int z=dodaj2Liczby(5, 3);<br />
System.out.println(z);<br />
}<br />
}<br />
Komenda „return” zwraca wartość znajdującą się po niej do<br />
miejsca wywołania funkcji w kodzie głównym. Jak wywołać<br />
funkcję? To bardzo proste! Wystarczy użyć nazwy funkcji.<br />
Dodaj2Liczby(5, 3)<br />
Wynik zwrócony z tej funkcji umieściliśmy w zmiennej „z”, która<br />
w kolejnej linijce została wyświetlona na ekranie.<br />
64<br />
Powrót do spisu treści
Metody (funkcje)<br />
public static void main(String[] args) to fragment kodu,<br />
który niejako odpala, uruchamia nasz program. To wyrażenie<br />
będzie bardzo często pojawiało się w naszych kolejnych, edukacyjnych<br />
programach.<br />
65<br />
Powrót do spisu treści
Obiekty i klasy<br />
Język <strong>Java</strong> jest tzw. językiem obiektowym. Oznacza to, że<br />
opiera się na obiektach i klasach. Te dwa pojęcia będą konieczne,<br />
by w pełni zrozumieć i wykorzystać możliwości, jakie daje<br />
nam <strong>Java</strong>. W ramach naszego programu nie będziemy wchodzili<br />
głębiej w samo programowanie obiektowe, ale chciałbym,<br />
żebyście zrozumieli, czym dokładnie są obiekty i klasy, tak<br />
by w kolejnych, bardziej zaawansowanych kursach rozumieć<br />
w pełni zasady ich działania.<br />
Programowanie obiektowe to takie, w którym do budowy programów<br />
używamy klas, na podstawie których powstają obiekty.<br />
No dobrze, a co to takiego klasa?<br />
Klasa to blok kodu, fragment programu, który zawiera pola<br />
o określonym typie danych (tak jak w zmiennych) oraz metody,<br />
dzięki którym można wykonać operacje, m.in. z wykorzystaniem<br />
tych danych.<br />
Obiekt natomiast to instancja tworzona przez działający program<br />
na podstawie napisanej wcześniej klasy.<br />
66<br />
Powrót do spisu treści
Obiekty i klasy<br />
Na przykład, gdyby nasz program symulował ruch uliczny, to<br />
musielibyśmy zapewne odzwierciedlić w nim takie obiekty jak<br />
samochody. Każdy samochód ma jakieś cechy, takie jak kolor,<br />
model, silnik oraz ma różne możliwości działania, które możemy<br />
nim wykonać, np: jedź do przodu, skręcaj, hamuj, otwórz<br />
bagażnik. O tym, jakie cechy ma poszczególny samochód i jakie<br />
działania może podjąć, decyduje klasa samochodów, którą<br />
stworzylibyśmy w takim programie. Klasa opisuje więc, jakie<br />
cechy ma każdy samochód i jakie działania może wykonać,<br />
a obiekt to konkretny pojazd z własnym numerem rejestracyjnym,<br />
który tworzymy dzięki tej klasie.<br />
Specyficznym rodzajem metody jest tzw. konstruktor. Jest to<br />
specjalna metoda w ramach klasy, która pozwala na jej podstawie<br />
stworzyć obiekty.<br />
Struktura klasy wygląda w języku <strong>Java</strong> następująco:<br />
public class Nazwa {<br />
// Definicje pól<br />
// Definicje konstruktorów<br />
// Definicje metod<br />
}<br />
67<br />
Powrót do spisu treści
Obiekty i klasy<br />
Każda klasa ma swoją nazwę: Nazwa. Nazwa klasy musi spełniać<br />
ograniczenia dotyczące identyfikatorów i zgodnie z konwencjami<br />
nazewniczymi powinna zaczynać się od dużej litery<br />
i być pisana w tzw. UpperCamelCase.<br />
W Javie powinna istnieć tylko jedna klasa główna w każdym<br />
pliku i musi być ona publiczna. To, że klasa jest publiczna,<br />
możemy zidentyfikować po tym, że posiada modyfikator dostępu<br />
public. Z czasem dowiesz się dokładnie, czym różnią<br />
się klasy publiczne od prywatnych, ale to jeszcze nie jest ten<br />
moment
Obiekty i klasy<br />
Klasa FabrykaAut {<br />
Cechy produkowanych pojazdów: Marka, Model, Kolor, Silnik<br />
Konstruktor: wybierz markę, model, kolor i silnik, aby<br />
stworzyć nowy samochód<br />
Metody samochodu: Jedź do przodu, skręcaj, hamuj, otwórz<br />
bagażnik<br />
}<br />
W samym programie użylibyśmy polecenia:<br />
Stwórz w ramach klasy FabrykaAut samochód: Fiat, 126P,<br />
Biały z silnikiem 1,2<br />
To będzie nasz pierwszy obiekt, na którym możemy testować<br />
różne metody, np.:<br />
Niech Fiat126P, Biały z silnikiem 1,2 przyspieszy<br />
Niech Fiat126P, Biały z silnikiem 1,2 skręci w lewo<br />
Niech Fiat126P, Biały z silnikiem 1,2 zatrzyma<br />
Praca z klasami i obiektami nie jest łatwa i dla wielu młodych<br />
programistów stanowi olbrzymie wyzwanie. Spokojnie więc<br />
trzeba się z tym tematem zapoznać. Gdy już poczujesz się wystarczająco<br />
pewnie z naszymi podstawami programowania, to<br />
zachęcamy do skorzystania z naszej bazy linków zapoznanie<br />
się z dokładnymi zasadami działania obiektów i klas w ramach<br />
jednego z wielu bezpłatnych kursów.<br />
69<br />
Powrót do spisu treści
Podsumowanie<br />
<strong>Java</strong> to niezwykle potężny język programowania.<br />
Na pewno będzie stanowił na początku wyzwanie. Ale cierpliwości!<br />
Trochę pracy, trochę praktyki i na pewno uda się go zrozumieć!<br />
W ramach <strong>podręcznik</strong>a chcieliśmy pokazać Ci, jak ten<br />
język działa i jak rozpocząć z nim pracę. Mamy nadzieję, że<br />
udało nam się przybliżyć choć trochę język <strong>Java</strong>.<br />
Teraz jednak wszystko już zależy od Ciebie!<br />
Spodobał Ci się <strong>Java</strong> i chcesz poznać go lepiej? Na stronie HearIT<br />
znajdziesz linki do wielu kursów i materiałów edukacyjnych,<br />
dzięki którym poznasz ten język dużo lepiej!<br />
Pierwsze kroki, te najtrudniejsze, masz już za sobą! Nie ma się<br />
co bać, tylko trzeba dalej programować!<br />
Powodzenia!<br />
70<br />
Powrót do spisu treści
Żywa pagina<br />
71