11.01.2023 Views

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.

SHOW MORE
SHOW LESS

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

Hooray! Your file is uploaded and ready to be published.

Saved successfully!

Ooh no, something went wrong!