Programovanie v jazyku Java

© 2008 Mgr. Viliam Búr

Obsah
Programovanie v jazyku Java...............................................................................................................1
Programovací jazyk Java a vývojové prostredie Eclipse.................................................................2
Prvý program...................................................................................................................................3
Premenné.........................................................................................................................................5
Funkcie.............................................................................................................................................6
Objekty.............................................................................................................................................8
Jednoduchá aplikácia.....................................................................................................................10
Kreslenie (1)..............................................................................................................................12
Kreslenie (2)..............................................................................................................................12
Ovládanie klávesami (Semafor)................................................................................................12
Ovládanie klávesami (Pohyb)...................................................................................................14
Porovnanie jazykov Imagine a Java...............................................................................................15
Programovací jazyk Java a vývojové prostredie Eclipse
Java je programovací jazyk, ktorý vznikol v roku 1995. Podobá sa na C++, v niektorých
veciach je jednoduchší, ale zato pomalší. Existujú tri verzie jazyka: Standard Edition – klasická
verzia; Enterprise Edition – klasická verzia s pridanými možnosťami na vytváranie webových
aplikácií; Micro Edition – zjednodušená verzia pre mobily. (Táto učebnica popisuje Standard
Edition.)
Na rozdiel od C++, ktoré vytvára priamo spustiteľný program (napríklad súbor typu „*.exe“),
z programu v jazyku Java sa vytvorí „bytecode“. Ten sa dá spustiť na každom počítači, na ktorom je
nainštalovaný „runtime“. Zatiaľ čo spustiteľné programy sa musia vytvárať osobitne pre každý
operačný systém, ten istý bytecode sa dá spustiť na každom počítači, kde je nainštalovaný runtime.
Programy v jazyku Java sa dajú spustiť aj v internetovom prezerači ako súčasť webovej stránky;
takýto program sa volá „applet“.
(Jazyk Java nemá nič spoločné s jazykom JavaScript, ktorý sa používa na písanie skriptov
pre webové stránky. Názov JavaScript bol zvolený len ako marketingový trik.)
Ak si chceme nainštalovať Javu, na stránke java.sun.com si vyberieme „Downloads“ a „Java
SE“. Ak chceme iba spúšťať programy v Jave, stiahneme najnovší „Java SE Runtime Environment
(JRE)“. Ak chceme aj vytvárať vlastné programy, stiahneme najnovší „Java SE Development Kit
(JDK)“. (Nesťahujeme obidva, lebo JDK v sebe obsahuje aj JRE.) Stiahnutý program spustíme.

Eclipse je vývojové prostredie, čiže program obsahujúci textový editor a mnoho ďalších
nástrojov užitočných pre programátora. Stiahneme ho na adrese www.eclipse.org, v menu
„Downloads“ ako „Eclipse IDE for Java Developers“. Stiahnutý archív rozbalíme na disku.
Pri prvom spustení si vyberieme „workspace“, čo je pracovný adresár, v ktorom budú uložené
všetky naše projekty. (Vybraný adresár sa dá neskôr zmeniť.)
Prvý program
Keď prvýkrát spustíme Eclipse, otvorí sa okno s názvom „Welcome“. Kliknutím na „x“ vedľa
nadpisu toto okno zavrieme a ukáže sa nám klasické rozloženie okien. (K tomuto úvodnému oknu
sa môžeme neskôr vrátiť pomocou meno „Help | Welcome“.)
Dôležité okno je „Package Explorer“, v ktorom vidíme všetky naše projekty a súbory.
Momentálne teda nič. Prvý projekt vytvoríme tak, že v tomto okne klikneme pravým tlačidlom
myši a vyberieme „New | Java Project“.
Názov projektu („Project name“) zadáme napríklad „projekt1“. Názov projektu je vlastne
názov adresára (podadresára vo workspace), v ktorom bude projekt uložený. Ostatné nastavenia
nebudeme meniť. Kliknutím na „Finish“ vytvoríme projekt.
Programy v jazyku Java sa skladajú z častí, ktoré nazývame „triedy“. Keď ideme písať
program, musíme najprv vytvoriť triedu.
Pravým tlačidlom klikneme na názov projektu (alebo na adresár „src“) a vyberieme „New |
Class“. Názov triedy („Name“) zadáme napríklad „Program“. Názov triedy by sa mal začínať
veľkým písmenom, a nemal by obsahovať medzery. Ešte zaškrtneme políčko „public static void
main(String[] args)“. Ostatné nastavenia nemeníme. Kliknutím na „Finish“ vytvoríme triedu.
Nová trieda sa teda volá „Program“ a je uložená v súbore „Program.java“. Ak sme si ako
workspace zadali napríklad „Z:\workspace“, potom je táto trieda na disku uložená ako „Z:\-
workspace\projekt1\src\Program.java“.
Automaticky vytvorený program vyzerá takto:
public class Program {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

}
Do programu môžeme vkladať komentáre. To sú texty, ktoré fungovanie programu nijako
neovplyvňujú, sú to len poznámky pre programátora. Ak chceme vložiť krátky komentár, dáme
v riadku dve lomky, a všetko až do konca riadku je komentár. Asi takto:
// toto je komentar
Komentár môžeme napísať aj za nejaký kód, asi takto:
public class Program { // toto je zaciatok programu
a
} // toto je koniec programu
Komentár na viacero riadkov píšeme medzi „/*“ a „*/“. Asi takto:
/*
(C) 2008 Viliam Bur
Toto je pokusny program, ktory som vytvoril na hodine informatiky.
*/
Ak z nášho automaticky vytvoreného programu vymažeme komentáre, zostane toto:
public class Program {
public static void main(String[] args) {
}
}
Prvý riadok hovorí, že je to trieda s názvom „Program“. Zložená zátvorka je začiatok triedy.
Druhý riadok hovorí, že táto trieda má funkciu s názvom „main“ (a tá má nejaké zložité parametre,
ktoré si vysvetlíme neskôr). Pomocou tejto funkcie sa spúšťa program. Zložená zátvorka je začiatok
funkcie. V treťom riadku je koniec funkcie „main“, a vo štvrtom riadku je koniec triedy „Program“.
 Skôr ako spustíme program, musíme zadať, aby niečo robil. Použijeme príkaz „System.out.-
println“, ktorým sa vypisuje text do príkazového riadku. (Áno, je to čudné, že taký jednoduchý
príkaz má taký zložitý názov. Neskôr to bude jednoduchšie. Náš program bude vyzerať takto:
public class Program {
public static void main(String[] args) {
System.out.println("Ahoj");
}
}
Program uložíme kliknutím na tlačidlo s disketou, a spustíme pomocou zeleného tlačidla
so šípkou. V dolnej časti vývojového prostredia sa v okne „Console“ vypíše text.
Texty sa zadávajú v úvodzovkách. Okrem textov môžeme vypisovať aj čísla, a môžeme s nimi
robiť základné matematické operácie.
public class Program {
public static void main(String[] args) {
System.out.println(2 + 2);
}
}
Keď skončíme prácu s prostredím Eclipse, vypneme ho. Program je uložený na disku
v adresári projektu, a keď nabudúce Eclipse zapneme, všetky okná sa otvoria tak, ako boli otvorené
pred vypnutím, takže môžeme pokračovať v práci.
Premenné
Údaje, s ktorými v programe pracujeme, môžeme ukladať do premenných. V jazyku Java
treba pri každej premennej uviesť, aký druh údajov sa v nej môže nachádzať (napríklad celé čísla,
desatinné čísla, texty,...). Ak chceme mať premennú s názvom „x“, do ktorej budeme ukladať celé
čísla, zapíšeme to takto:
int x;
Do premennej „x“ uložíme číslo 5:
x = 5;
Vypíšeme obsah premennej „x“:
System.out.println(x);
Celý program:
public class Program {
public static void main(String[] args) {
int x;
x = 5;
System.out.println(x);
}
}
Rovnako sa do premenných ukladajú texty; rozdiel je len v tom, že typ premennej je „String“.
(Slovo „int“ sa píše s malým začiatočným písmenom, slovo „String“ s veľkým. Niečo to znamená,
ale to si povieme až neskôr.)
public class Program {
public static void main(String[] args) {
String s;
s = "brontosaurus";
System.out.println(s);
}
}
Obsah premennej možno počas programu meniť. Napríklad:
public class Program {
public static void main(String[] args) {
int x;
x = 5;
System.out.println(x);
x = 7;
System.out.println(x);
x = x + 1;
System.out.println(x);
}
}
Funkcie
Každá trieda môže obsahovať niekoľko funkcií. Už máme jednu, ktorá sa volá „main“.
Vytvoríme si novú funkciu s názvom „pis“, ktorá vypíše dané číslo. (Bude robiť to isté ako
„System.out.println“, len sa to bude kratšie zapisovať.)
Novú funkciu napíšeme buď pred funkciu „main“ alebo za ňu. Na poradí funkcií nezáleží.
Hlavne aby sme nenapísali jednu dovnútra druhej. Funkcia začína a končí tam, kde sú zložené
zátvorky.
public class Program {

static void pis(int cislo) {

System.out.println(cislo);
}

public static void main(String[] args) {

pis(10);
}

}
Vytvorili sme funkciu „pis“, ktorá dostane ako parameter číslo. Keby sme chceli rovnakým
spôsobom vypisovať aj texty, musíme vytvoriť novú funkciu, tentokrát s číselným parametrom.
public class Program {

static void pis(int cislo) {

System.out.println(cislo);
}

static void pis(String text) {

System.out.println(text);
}

public static void main(String[] args) {

pis(10);
pis("ahoj");
}

}
V jazyku Java môžu mať dve funkcie rovnaký názov, pretože podľa parametra je jasné, ktorá
funkcia sa má kedy použiť.
Ak chceme, aby funkcia vracala výsledok, musíme pred názov funkcie uviesť typ výsledku.
(Slovo „void“ znamená, že funkcia nevracia žiaden výsledok.) Výsledok vraciame pomocou
príkazu „return“.
public class Program {

static int dvojnasobok(int x) {

return 2 * x;
}

static String menoSTitulmi(String meno) {

return "Profesor " + meno + ", CSc.";
}

public static void main(String[] args) {

System.out.println(dvojnasobok(10));
System.out.println(menoSTitulmi("Javomír Programotvorný"));
}

}
 Všimnite si, že znamienko „+“ má v jazyku Java dve rôzne funkcie; sčítanie čísel a spájanie
textov.
Ak sa názov funkcie skladá z viacerých slov, je zvykom začínať ďalšie slová veľkým
písmenom.
Objekty
Programovací jazyk Java nám poskytuje rôzne druhy údajov, napríklad čísla a texty. Okrem
toho si môžeme vytvárať vlastné údaje.
Dnešným príkladom bude... pes. To ešte v Jave určite nie je.
Pravým tlačidlom kliknite na projekt a vyberte „New | Class“. Ako názov triedy zadajte
„Pes“. Stlačte „Finish“.
Pes.java
public class Pes {
}
Teraz máme dve triedy, a teda dva súbory. Hlavný program, čiže trieda „Program“ je v súbore
„Program.java“. Trieda „Pes“ je v súbore „Pes.java“. Teraz sa vrátime do hlavného programu,
do funkcie „main“, a doplníme nejaké príkazy na prácu so psom.
Program.java
public class Program {

public static void main(String[] args) {

Pes p;
p = new Pes();
}

}
Zatiaľ čo čísla vieme zapísať číslicami, a texty vieme zapísať ako text v úvodzovkách, nového
psa musíme vytvoriť pomocou príkazu „new“. Vytvorenie premennej „p“ typu „Pes“ a uloženie
hodnoty do tejto premennej sa už robí tak isto ako s číslami a textmi.
Máme teda psa, ale zatiaľ s ním nevieme robiť nič. Tak nech aspoň šteká.
Pes.java
public class Pes {

void stekaj() {
System.out.println("Haf!");
}

}
Program.java
public class Program {

public static void main(String[] args) {

Pes p;
p = new Pes();
p.stekaj();
}

}
Vytvorili sme metódu „stekaj“. Všimnite si, že pred názvom metódy nie je uvedené slovo
„static“. To je preto, lebo štekať môže iba konkrétny pes, čiže v hlavnom programe vždy píšeme
napríklad „p.stekaj()“, nestačí iba „stekaj()“. Funkcie, ktoré môže používať iba konkrétny objekt, sa
nazývajú metódy.
Aby sme vedeli jednotlivých psov od seba odlíšiť, potrebujú mať nejaké meno.
Pes.java
public class Pes {

String meno;

void stekaj() {
System.out.println("Haf!");
}
}
Program.java
public class Program {

public static void main(String[] args) {

Pes p;
p = new Pes();
p.meno = "Rex";
System.out.println(p.meno);
}

}
Teraz môžeme upraviť štekanie tak, aby sa pri ňom vypísalo meno psa.
Pes.java
public class Pes {

String meno;

void stekaj() {
System.out.println(meno + " povedal: Haf!");
}

}
Program.java
public class Program {

public static void main(String[] args) {

Pes p;
p = new Pes();
p.meno = "Rex";
p.stekaj();
}

}
Všimnite si, že keď v hlavnom programe používame meno psa, musíme zadať „p.meno“, aby
bolo jasné, ktorému psovi zadávame meno. Pri písaní metódy „stekaj“ však stačí napísať iba
„meno“. Je to preto, že šteká vždy nejaký konkrétny pes; „p.stekaj()“. Je teda jasné, ktorého psa
meno ideme vypísať... toho, ktorý práve šteká.
Jednoduchá aplikácia
Vytvorme si jednoduchú grafickú aplikáciu, ktorá bude reagovať na stlačenie a pustenie
klávesy, na kliknutie myši, a aby sme mohli robiť animácie, bude reagovať aj na časovač.
Pre väčšiu prehľadnosť si ju rozdelíme na dve triedy. V triede „Aplikacia“ bude základ, aby to celé
fungovalo. V triede „MojaAplikacia“ budú veci, ktoré si my do tohoto základu doplníme.
Aplikacia.java
import java.awt.*;
import java.awt.event.*;
import java.util.*;

public abstract class Aplikacia extends Frame {

private static final long serialVersionUID = 1L;

private Insets insets;

private Timer timer;

Aplikacia() {
super();
setVisible(true);
setResizable(false);
insets = getInsets();
setSize(
400 + insets.left + insets.right,
300 + insets.top + insets.bottom
);
addKeyListener(new MyKeyListener());
addMouseListener(new MyMouseListener());
addWindowListener(new MyWindowListener());
timer = new Timer();
timer.schedule(new MyTimerTask(), 20, 20);
}

abstract void priCasovaci();

abstract void priKresleni(Graphics g);
abstract void priStlaceniKlavesy(KeyEvent e);
abstract void priPusteniKlavesy(KeyEvent e);
abstract void priKliknutiMysi(MouseEvent e);

@Override
public void paint(Graphics g) {
super.paint(g);
if (null == insets) return;
g.translate(insets.left, insets.top);
priKresleni(g);
}

class MyKeyListener extends KeyAdapter {

@Override
public synchronized void keyPressed(KeyEvent e) {
priStlaceniKlavesy(e);
}

@Override
public void keyReleased(KeyEvent e) {
priPusteniKlavesy(e);
}

}
 class MyMouseListener extends MouseAdapter {

@Override
public synchronized void mouseClicked(MouseEvent e) {
if (null == insets) return;
e.translatePoint(-insets.left, -insets.top);
priKliknutiMysi(e);
}

class MyWindowListener extends WindowAdapter {

@Override
public synchronized void windowClosing(WindowEvent e) {
timer.cancel();
dispose();
}

class MyTimerTask extends TimerTask {

@Override
public synchronized void run() {
priCasovaci();
repaint();
}

}
MojaAplikacia.java
import java.awt.*;
import java.awt.event.*;

public class MojaAplikacia extends Aplikacia {

private static final long serialVersionUID = 1L;

// tu si vytvorime premenne

MojaAplikacia() {

super();
setTitle("Moja pokusna aplikacia");

// tu dame do premennych zaciatocnu hodnotu

void priCasovaci() {

// tu zadame zmeny pri animacii

void priKresleni(Graphics g) {

// tu vykreslime, co treba

}
 void priStlaceniKlavesy(KeyEvent e) {

// tu zareagujeme na stlacenie klavesy

void priPusteniKlavesy(KeyEvent e) {

// tu zareagujeme na pustenie klavesy

void priKliknutiMysi(MouseEvent e) {

// tu zareagujeme na kliknutie mysi

public static void main(String[] args) {

new MojaAplikacia();
}

}
Táto aplikácia po spustení otvorí na obrazovke okno; kliknutím na červené tlačidlo v pravom
hornom rohu aplikáciu zavrieme.
Kreslenie (1)
Ak chceme vykresliť na obrazovke nehybný útvar, stačí upraviť funkciu „priKresleni“.
void priKresleni(Graphics g) {

g.setColor(Color.RED);
g.drawRect(100, 150, 10, 20);

}
Príkaz „setColor“ nastaví farbu, ktorou budeme kresliť. Príkaz „drawRect“ vykreslí obdĺžnik;
prvé číslo je vzdialenosť od ľavého okraja okna; druhé číslo je vzdialenosť od horného okraja okna;
tretie číslo je šírka obdĺžnika; štvrté číslo je výška obdĺžnika.
Úloha 1: Nakresli vedľa seba tri obdĺžniky, každý inej farby. (Trieda „Color“ má tieto farebné
konštanty: BLACK, BLUE, CYAN, DARK_GRAY, GRAY, GREEN, LIGHT_GRAY, MAGENTA,
ORANGE, PINK, RED, WHITE, YELLOW.)
Úloha 2: Nakresli tri obdĺžniky rovnakej farby pod sebou. (Ak chceme kresliť viacero vecí
jednou farbou, príkaz „setColor“ stačí zadať raz, na začiatku.)
Úloha 3: Čo musí platiť pre zadané čísla, aby sa namiesto obdĺžnika vykreslil štvorec?
Nakresli tri štvorce v sebe, každý inou farbou.
Kreslenie (2)
Príkaz „fillRect“ nakreslí vyfarbený obdĺžnik. Príkaz „drawOval“ nakreslí elipsu, a príkaz
„fillOval“ nakreslí vyfarbenú elipsu. Parametre sú rovnaké ako pri príkaze „drawRect“.
…
Ovládanie klávesami (Semafor)
Ak chceme, aby náš program reagoval na stlačenie klávesy, potrebujeme si stav programu
uložiť do premennej. V metóde „priStlaceniKlavesy“ sa totiž dozvieme, aká klávesa bola stlačená,
ale nemôžeme v nej nič kresliť. V metóde „priKresleni“ zase kreslíme, ale už nevieme, aké klávesy
boli kedy stlačené. Preto budeme pri stlačení kláves meniť hodnoty premenných, a pri vykresľovaní
budeme kresliť na základe hodnôt v premenných.
 Vytvorme si napríklad semafor, ktorý budeme prepínať klávesami. Na semafore môže svietiť
červená, oranžová, alebo zelená farba. Stav semafora si uložíme do premennej „stavSemafora“.
Bude to číselná premenná, s hodnotami 1 = červená, 2 = oranžová, 3 = zelená).
Premennú vytvoríme na začiatku programu – vnútri triedy „MojaAplikacia“ ale mimo
jednotlivých metód:
public class MojaAplikacia extends Aplikacia {

…
int stavSemafora;

…
}
Pri spustení programu treba premennej priradiť úvodnú hodnotu. V konštruktore
„MojaAplikacia“ uložíme do premennej „stavSemafora“ napríklad hodnotu 1, čiže po spustení
programu bude na semafore svietiť červené svetlo.
MojaAplikacia() {

super();
…
stavSemafora = 1;

}
Do príkazu „priVykresleni“ zadáme príkazy na vykreslenie semafora. Jednotlivé svetlá
vykreslíme pomocou príkazov „drawOval“, ak sú vypnuté a „fillOval, ak sú zapnuté. Využijeme
pritom príkaz „if“ a skontrolujeme hodnotu v premennej „stavSemafora“.
void priKresleni(Graphics g) {

g.setColor(Color.RED);
if (1 == stavSemafora) {
g.fillOval(50, 50, 50, 50);
} else {
g.drawOval(50, 50, 50, 50);
}

g.setColor(Color.ORANGE);
if (2 == stavSemafora) {
g.fillOval(50, 100, 50, 50);
} else {
g.drawOval(50, 100, 50, 50);
}

g.setColor(Color.GREEN);
if (3 == stavSemafora) {
g.fillOval(50, 150, 50, 50);
} else {
g.drawOval(50, 150, 50, 50);
}

}
Do príkazu „priStlaceniKlavesy“ zadáme príkazy, aby sa pri stlačení správnych kláves zmenil
stav semafora. Použijeme klávesy Q, W, E (sú pekne vedľa seba) a do premennej „stavSemafora“
nastavíme hodnoty 1, 2, 3.
void priStlaceniKlavesy(KeyEvent e) {

if (KeyEvent.VK_Q == e.getKeyCode()) {
stavSemafora = 1;
}
 if (KeyEvent.VK_W == e.getKeyCode()) {
stavSemafora = 2;
}
if (KeyEvent.VK_E == e.getKeyCode()) {
stavSemafora = 3;
}

}
A to je všetko. Spustite aplikáciu, a prepínajte semafor tlačidlami 1, 2, 3.
Úloha 1: Vykreslite uprostred obrazovky jeden predmet, ktorého tvar sa bude meniť
pri stlačení klávesy. Vyberte si štyri klávesy, ktorými z neho vytvoríte a) prázdny štvorec, b) plný
štvorec, c) prázdny kruh, d) plný kruh.
Úloha 2: Vykreslite na obrazovke kruh, ktorého farba sa bude meniť pri stlačení klávesy: C =
červená, Z = zelená, M = modrá. Nebudeme si vymýšľať žiadne číselné kódy, ale do premennej
uložíme rovno farbu. Takto vytvoríme premennú:
Color farbaKruhu;
Takto ju naštartujeme:
farbaKruhu = Color.BLACK;
V príkaze „priKresleni“ nastavíme farbu príkazom:
g.setColor(farbaKruhu);
A v príkaze „priStlaceniKlavesy“ uložíme do premennej novú farbu takto:
if (KeyEvent.VK_C == e.getKeyCode()) {
farbaKruhu = Color.RED;
}
Ovládanie klávesami (Pohyb)
Porovnanie jazykov Imagine a Java
V ľavom stĺpci je program v jazyku Java, v pravom stĺpci je program v jazyku Imagine.
Vytvoríme číselnú premennú „x“.
int x; v Imagine netreba vytvárať premenné
Do číselnej premennej „x“ uložíme číslo 5.
x = 5; urob "x 5
Vypíšeme číslo uložené v premennej „x“.
System.out.println(x); píš :x
Vytvoríme textovú premennú „t“.
String t; v Imagine netreba vytvárať premenné
Do textovej premennej „t“ uložíme slovo „ahoj“.
t = "ahoj"; urob "t "ahoj
Vypíšeme text uložený v premennej „t“.
System.out.println(t); píš :t
Vytvoríme nový príkaz „urobNieco“.
static void urobNieco() { viem urobNieco
… …
} koniec
Vytvoríme nový príkaz „urobNieco“ s číselnými parametrami „x“ a „y“.
static void urobNieco(int x, int y) { viem urobNieco :x :y
… …
} koniec
Vytvoríme nový príkaz „vypocitajNieco“, ktorý vráti výsledok 5.
static int vypocitajNieco() { viem vypocitajNieco
… …
return 5; výsledok 5
} koniec
Podmienka.
if (…) { ak … [
… …
} ]
Podmienka s dvomi možnosťami.
if (…) { ak2 … [
… …
} else { ] [
… …
} ]
Opakovanie kým je splnená podmienka.
while (…) { kým […] [
… …
} ]
Opakovanie 10-krát.
for (int i = 0; i < 10; i++) { opakuj 10 [
… …
} ]
Program na výpočet faktoriálu:
static int faktorial(int n) { viem faktorial :n
if (n > 1) { ak2 :n > 1 [
return n * faktorial(n – 1); výsledok :n * faktorial :n – 1
} else { ] [
return 1; výsledok 1
} ]
} koniec
...