Zobrazenie zdroja stránky 2020/21 Programovanie (2) v Jave

=Letný semester=

{| style="width: 100%;"
|-
| style="vertical-align:top; width: 40%;"| 
'''Kontakt na vyučujúcich''':
* [http://www.dcs.fmph.uniba.sk/~kostolanyi/ Peter Kostolányi] (prednášky a cvičenia):
: miestnosť M-227
: [[Image:e-pk2.png]] 
* Lukáš Kiss (cvičenia):
: miestnosť M-25
: [[Image:e-lk.png]] 
| style="vertical-align:top; width: 60%;"|
'''Rozvrh''':
* '''Prednášky''':
: pondelok, 9:00 &ndash; 10:30, MS Teams
* '''Cvičenia''':
: streda, 11:30 &ndash; 13:00, MS Teams
* Konzultácie po dohode mailom
|}

== Prednášky a cvičenia v letnom semestri ==

{| style="width: 100%;"
|-
|style="background:#f0f0f0" |'''Týždeň 15.2. &ndash; 21.2.''' Úvod do jazyka Java
|-
|-
| [[#Letný semester, prednáška č. 1|Prednáška 1]] '''&middot;''' [[#Letný semester, cvičenia č. 1|Cvičenia 1]] '''&middot;''' [[#Letný semester, pravidlá|Pravidlá]] '''&middot;''' [[#Letný semester, softvér|Softvér]]
|-
|style="background:#f0f0f0" |'''Týždeň 22.2. &ndash; 28.2.''' Základy objektovo orientovaného programovania I
|-
| [[#Letný semester, prednáška č. 2|Prednáška 2]] '''&middot;''' Cvičenia 2 '''&middot;'''  ''Test pre pokročilých''
|-
|style="background:#f0f0f0" |'''Týždeň 1.3. &ndash; 7.3.'''  Základy objektovo orientovaného programovania II
|-
| [[#Letný semester, prednáška č. 3|Prednáška 3]] '''&middot;''' Cvičenia 3
|-
|style="background:#f0f0f0" |'''Týždeň 8.3. &ndash; 14.3.''' Výnimky, generické programovanie
|-
| [[#Letný semester, prednáška č. 4|Prednáška 4]] '''&middot;''' Cvičenia 4 '''&middot;'''  ''Test č. 1''  '''&middot;''' [[#Riešenia testu č. 1|Riešenia úloh z testu]]
|-
|style="background:#f0f0f0" |'''Týždeň 15.3. &ndash; 21.3.''' Java Collections, lokálne a anonymné triedy, iterátory
|-
| [[#Letný semester, prednáška č. 5|Prednáška 5]] '''&middot;''' Cvičenia 5
|-
|style="background:#f0f0f0" |'''Týždeň 22.3. &ndash; 28.3.''' Javadoc, Testovanie, JUnit, Grafy a grafové algoritmy I
|-
| [[#Letný semester, prednáška č. 6|Prednáška 6]] '''&middot;''' Cvičenia 6 '''&middot;''' ''Test č. 2'' '''&middot;''' [[#Riešenia testu č. 2|Riešenia úloh z testu]]
|-
|style="background:#f0f0f0" |'''Týždeň 29.3. &ndash; 4.4.''' Grafy a grafové algoritmy II
|-
| [[#Letný semester, prednáška č. 7|Prednáška 7]] '''&middot;''' Cvičenia 7 
|-
|style="background:#f0f0f0" |'''Týždeň 5.4. &ndash; 11.4.''' Veľkonočný pondelok
|-
| Cvičenia 8 '''&middot;''' ''Test č. 3'' '''&middot;''' [[#Riešenia testu č. 3|Riešenia úloh z testu]]
|-
|style="background:#f0f0f0" |'''Týždeň 12.4. &ndash; 18.4.''' Grafy a grafové algoritmy III
|-
| [[#Letný semester, prednáška č. 9|Prednáška 9]] '''&middot;''' Cvičenia 9 '''&middot;''' ''Test č. 4'' '''&middot;''' [[#Riešenia testu č. 4|Riešenia úloh z testu]]
|-
|style="background:#f0f0f0" |'''Týždeň 19.4. &ndash; 25.4.''' Lambda výrazy, JavaFX I
|-
| [[#Letný semester, prednáška č. 10|Prednáška 10]] '''&middot;''' Cvičenia 10
|-
|style="background:#f0f0f0" |'''Týždeň 26.4. &ndash; 2.5.''' JavaFX II
|-
| [[#Letný semester, prednáška č. 11|Prednáška 11]] '''&middot;''' Cvičenia 11 '''&middot;''' ''Test č. 5'' '''&middot;''' [[#Riešenia testu č. 5|Riešenia úloh z testu]]
|-
|style="background:#f0f0f0" |'''Týždeň 3.5. &ndash; 9.5.''' JavaFX III
|-
| [[#Letný semester, prednáška č. 12|Prednáška 12]] '''&middot;''' Cvičenia 12 '''&middot;''' ''Náhradný test č. 1'' '''&middot;''' [[#Riešenia náhradného testu č. 1|Riešenia úloh z testu]]
|-
|style="background:#f0f0f0" |'''Týždeň 10.5. &ndash; 16.5.''' JavaFX IV
|-
| [[#Letný semester, prednáška č. 13|Prednáška 13]] '''&middot;''' Cvičenia 13 '''&middot;''' [[#Textový editor: kompletný zdrojový kód]] '''&middot;''' ''Náhradný test č. 2'' '''&middot;''' [[#Riešenia náhradného testu č. 2|Riešenia úloh z testu]]
|-
|}

=Letný semester, prednáška č. 1=
== Úvodné informácie ==
 
* V prípade potreby kontaktujte vyučujúcich mailom (kontakty možno nájsť na [[#Programovanie (2) v Jave|úvodnej stránke]]).
* Predmet sa bude riadiť [[#Letný semester, pravidlá|pravidlami pre letný semester]].
* Okrem bodovaných úloh budú na testovači zverejňované aj nebodované cvičenia.
* Konzultácie po predchádzajúcej dohode mailom.
* Heslo na testovači: rovnaké ako minulý semester; u tých, čo minulý semester nechodili, zmenené na <tt>prog2</tt>. V prípade problémov s prihlasovaním dajte vedieť.
* Softvér potrebný na tomto predmete:
** Java SE 15 (alebo ľubovoľná verzia od 11 vyššie).
** Platforma JavaFX pre vývoj aplikácií s grafickým používateľským rozhraním.
** Vývojové prostredie (IDE) pre Javu, odporúčame IntelliJ IDEA Community Edition.
** [[#Letný semester, softvér|Informácie o inštalácii a základnom použití uvedeného softvéru]].
** Vhodnou príležitosťou na vyriešenie prípadných problémov môžu byť prvé cvičenia.
* Základné zdroje informácií o jazyku Java:
** [https://docs.oracle.com/en/java/javase/15/docs/api/index.html Dokumentácia k Java API].
** [https://docs.oracle.com/javase/tutorial/ Tutoriály k jazyku Java].
** Príklady vhodnej študijnej literatúry možno nájsť v [https://sluzby.fmph.uniba.sk/infolist/sk/1-INF-166_11.html informačnom liste predmetu].
* Na začiatku stredajších cvičení bude zverejnená prvá bonusová domáca úloha.

== Základné črty jazyka Java a programovania v ňom ==

Prvoradým cieľom tohto predmetu je zvládnutie základov ''objektovo orientovaného programovania'' (OOP) prostredníctvom programovacieho jazyka Java. Na úvod je užitočné vedieť o tomto jazyku nasledujúce:

* Základné syntaktické konštrukcie jazyka Java sú v mnohom veľmi podobné jazykom C a C++. Už tento týždeň by sme mali zvládnuť prepísať do Javy väčšiu časť programov z minulého semestra; budúci týždeň by to už mali byť úplne všetky programy. 
* Jazyk Java je silne (aj keď nie čisto) ''objektovo orientovaný''. Použite ''tried'' &ndash; ktoré sú popri ''objektoch'' základným konceptom OOP &ndash; je nutné na napísanie aj toho najjednoduchšieho programu. 
* Na druhej strane je triedu možné použiť aj ako obyčajný &bdquo;obal&rdquo; pre niekoľko ''metód'' (t.j. funkcií) podobného typu ako v minulom semestri. Takýmto spôsobom budeme s Javou pracovať na dnešnej prednáške. S ozajstným objektovo orientovaným programovaním začneme až budúci týždeň.
* Programy v jazyku Java sa obvykle nekompilujú do strojového kódu, ale do tzv. javovského ''bytekódu''. Po skompilovaní programu teda nedostávame bežný spustiteľný súbor, ale súbor, ktorý možno spustiť na javovskom virtuálnom stroji (angl. ''Java Virtual Machine''; skr. JVM). Vykonávanie takýchto programov je síce o niečo pomalšie, zato sú však prenositeľné medzi rôznymi operačnými systmémami a architektúrami.

Celkovo ide o jazyk omnoho vyššej úrovne, než jazyk C: v oveľa väčšej miere sa tu abstrahuje od počítačovej architektúry. Java napríklad neumožňuje priamy prístup k pamäťi počítača a o uvoľňovanie alokovanej pamäte sa stará JVM automaticky prostrednictvom mechanizmu tzv. ''garbage collection''. Hoci teda jazyk nie je príliš vhodný na nízkoúrovňové programovanie, tvorba &bdquo;bežných&rdquo; používateľských programov je tu podstatne pohodlnejšia, než napríklad v jazyku C. Okrem toho Java disponuje veľkou knižnicou štandardných tried (''Java Class Library''; skr. JCL), v ktorej je okrem iného implementované aj množštvo algoritmov a dátových štruktúr. Orientáciu v možnostiach ponúkaných touto knižnicou značne uľahčuje [https://docs.oracle.com/en/java/javase/15/docs/api/index.html dokumentácia k nej].

Rozdiel v úrovni abstrakcie medzi jazykmi C a Java sa premieta aj do typického programátorského štýlu. Od efektívnosti samotnej implementácie sa dôraz obvykle posúva k aspektom softvérového inžinierstva, ako sú napríklad čitateľnosť, rozšíriteľnosť a &bdquo;spravovateľnosť&rdquo; kódu. S niektorými elementárnymi princípmi softvérového inžinierstva sa zoznámime aj na tomto predmete.

== Prvý program v jazyku Java ==

Tradične začneme programom, ktorý na konzolu vypíše text <tt>Hello, World!</tt>. 

<syntaxhighlight lang="java">public class Hello {

    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }

}
</syntaxhighlight>
* Názov súboru sa musí zhodovať s názvom triedy, ku ktorému sa pridá prípona <tt>.java</tt> &ndash; v našom prípade teda musí byť zdrojový kód uložený v súbore <tt>Hello.java</tt>.
* Program je potrebné skompilovať javovským kompilátorom a následne spustiť na javovskom virtuálnom stroji &ndash; návod možno nájsť na [[#Letný semester, softvér|osobitnej stránke]]. Po skompilovaní programu získame súbor <tt>java.class</tt> spustiteľný na JVM.

Rozoberme postupne jednotlivé časti uvedeného programu:
* Funkcia <tt>main</tt>, ktorá sa podobne ako v C/C++ začne vykonávať bezprostredne po spustení programu, je &bdquo;obalená&rdquo; v triede, ktorú sme nazvali <tt>Hello</tt>. V jazyku Java musí byť všetok kód súčasťou nejakej triedy (význam tried pre OOP zatiaľ ponechajme bokom).
* Hlavička funkcie <tt>main</tt> musí byť vždy tvaru ako vyššie. Modifikátory <tt>public</tt> a <tt>static</tt> si vysvetlíme neskôr; nasleduje návratový typ <tt>void</tt>, názov funkcie <tt>main</tt> a argumenty funkcie <tt>main</tt>, ktorými sú argumenty programu z príkazového riadku (v podobe poľa reťazcov).
* Samotný výpis na konzolu realizuje metóda <tt>System.out.println</tt>.

Keďže jeden väčší program typicky pozostáva z množstva rôznych tried (v rôznych súboroch), je možné triedy ďalej umiestniť do balíkov; program tak často pozostáva z niekoľkých balíkov navzájom súvisiacich tried. Umiestnenie triedy do balíka možno realizovať príkazom na začiatku zdrojového súboru. 

<syntaxhighlight lang="java">package somepackage;

public class Hello {

    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }

}
</syntaxhighlight>
* V našom prípade sme triedu <tt>Hello</tt> umiestnili do balíka <tt>somepackage</tt>. Pri práci s IDE ako napr. IntelliJ je často potrebné pridať balík aj do projektu; rozdiel je tiež pri kompilovaní a spúšťaní triedy z príkazového riadku. Viac sa možno dočítať [[#Letný semester, softvér|tu]].   
* Pokiaľ deklarácia balíka chýba, považuje sa trieda za súčasť nepomenovaného balíka (angl. ''unnamed package'' alebo ''default package''). Používanie nepomenovaného balíka vo všeobecnosti nie je dobrá prax, ale je zmysluplné pri menších programoch pre vlastnú potrebu (alebo pre potreby tohto predmetu).
* Za dobrú prax sa naopak považuje pomenúvanie balíkov tak, aby boli celosvetovo jednoznačne identifikovateľné &ndash; za týmto účelom preto boli vybracované [https://docs.oracle.com/javase/tutorial/java/package/namingpkgs.html špeciálne konvencie], ktoré ale na tomto predmete nebudeme dodržiavať.

== Konvencie pomenúvania identifikátorov ==

Za účelom sprehľadnenia zdrojového kódu a často pomerne rozsiahlych knižníc sa pri pomenúvaní identifikátorov v Jave používajú (okrem iných aj) nasledujúce konvencie:
* Názvy tried by mali vždy začínať veľkým písmenom (pri viacslovných názvoch začína veľkým písmenom aj každé ďalšie slovo).
* Názvy premenných a metód by naopak mali vždy začínať malým písmenom (pri viacslovných názvoch začínajú ďalšie slová veľkým písmenom).

Nedodržiavanie týchto konvencií budeme na tomto predmete považovať za chybu. O ďalších konvenciách používaných v tomto smere sa možno dočítať [https://www.oracle.com/java/technologies/javase/codeconventions-namingconventions.html tu].

== Príklad o niečo rozsiahlejšieho programu ==

Nižšie je príklad o niečo rozsiahlejšieho programu v jazyku Java. Pokúste sa s využitím skúseností z minulého semestra uhádnuť, čo tento program robí.

<syntaxhighlight lang="java">import java.util.*;

public class Program {

    /* Spocita sucet prvkov pola a.
     */
    public static int sum(int[] a) {
        int result = 0;
        for (int i = 0; i <= a.length - 1; i++) {
            result += a[i];
        }
        return result;
    }

    /* Spocita priemer hodnot prvkov pola a.
     */
    public static double average(int[] a) {
        return (double) sum(a) / a.length;
    }

    /* Najde najvacsi prvok pola a.
     */
    public static int max(int[] a) {
        int max = Integer.MIN_VALUE;  // Premenna ma rovnaky nazov ako metoda
        for (int i = 0; i <= a.length - 1; i++) {
            if (a[i] >= max) {
                max = a[i];
            }
        }
        return max;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        int[] a = new int[n];

        for (int i = 0; i <= n - 1; i++) {
            a[i] = scanner.nextInt();
        }
        scanner.close();

        System.out.println("Sucet: " + sum(a));
        System.out.println("Priemer: " + average(a));
        System.out.println("Maximum: " + max(a));
    }

}
</syntaxhighlight>

* Okamžite vidieť množstvo podobností medzi jazykmi C/C++ a Java, ale aj niekoľko drobných rozdielov.
* Konštrukcie jazyka Java použité v tomto programe podrobnejšie rozoberieme nižšie.

== Základné konštrukcie jazyka Java ==

=== Primitívne typy ===

Jazyk Java podporuje celkovo osem [https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html primitívnych dátových typov] (<tt>void</tt> sa za primitívny typ nepovažuje):
* <tt>int</tt>: 32-bitové celé čísla so znamienkom, v rozsahu od ''-2<sup>31</sup>'' po ''2<sup>31</sup> - 1''; ďalšie celočíselné typy sú <tt>byte</tt>, <tt>short</tt> a <tt>long</tt> (na rozdiel od C/C++ už teda <tt>long</tt> a <tt>short</tt> nie sú modifikátory, ale priamo celočíselné typy).
* <tt>double</tt>: 64-bitové desatinné čísla s pohyblivou desatinnou čiarkou; ďalší typ desatinných čísel je 32-bitový <tt>float</tt>.
* <tt>boolean</tt>: logické hodnoty <tt>true</tt> alebo <tt>false</tt>.
* <tt>char</tt>: 16-bitové znaky v kódovaní Unicode (UTF-16); typ teda napríklad podporuje slovenskú diakritiku.

Deklarácie premenných a priradenia zapisujeme rovnako ako v C/C++. Na rozdiel od C/C++ možno napríklad definovať aj lokálnu premennú s rovnakým názvom ako niektorá metóda.
<syntaxhighlight lang="java">
int x = 0;
</syntaxhighlight>
Kompilátor pritom nedovolí použitie neinicializovanej lokálnej premennej.
<syntaxhighlight lang="java">
int x;
System.out.println(x); // variable x might not have been initialized
</syntaxhighlight>
Neskôr uvidíme, že prvky polí a premenné tried a ich inštancií sa inicializujú automaticky.

Pretypovanie tiež funguje podobne ako v C/C++, avšak implicitné (automatické) pretypovanie je možné pre menší počet dvojíc typov, než v C/C++. Číselné typy možno usporiadať ako <tt>byte ≺ short ≺ int ≺ long ≺ float ≺ double</tt> a implicitné pretypovanie je možné iba v smere tohto usporiadania. Ďalej je možné implicitne pretypovať <tt>char</tt> na <tt>int</tt>, <tt>long</tt>, <tt>float</tt> a <tt>double</tt> (nie však naopak). Zvyšné pretypovania je nutné robiť explicitne, rovnako ako v C/C++.
<syntaxhighlight lang="java">
int x = 65;
char c = (char) x;
System.out.println(c);
</syntaxhighlight>
Možno ale napríklad priamo písať <tt>char c = 65</tt>.

=== Operátory ===

Jazyk Java podporuje podobnú sadu operátorov ako jazyky C a C++; ich kompletný zoznam vrátanie precedencií možno nájsť [https://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html tu]. Spomeňme predovšetkým:
* Operátory priradenia <tt>=, +=, *=</tt>, atď.
* Aritmetické operátory <tt>+, -, *, /, %</tt>. Na celočíselných typoch sa operátor <tt>/</tt> správa, rovnako ako v C/C++, ako celočíselné delenie.
* Prefixové a sufixové operátory <tt>++, --</tt>.
* Relačné a porovnávacie operátory <tt>==, !=, <, >, <=, >=</tt>.
* Logické operátory <tt>||, &&, !</tt>.

=== Cykly a podmienky ===

Nasledujúce konštrukcie sú v Jave veľmi podobné ako v C/C++:

* Podmienky: <tt>if</tt>, <tt>else</tt> a <tt>switch</tt>.
* Cykly: <tt>for</tt>, <tt>while</tt>, <tt>do ... while</tt>.
* Príkazy <tt>break</tt> a <tt>continue</tt>.

Drobný rozdiel pri ich použití vyplýva zo skutočnosti, že v Jave nedochádza k automatickému pretypovaniu z napr. číselných typov na <tt>boolean</tt>. Napríklad nasledujúci kus kódu, ktorý by bol v C/C++ korektný, vyústi v Jave chybu.

<syntaxhighlight lang="java">
int n = 1;
if (n) {  // incompatible types: int cannot be converted to boolean
    // ...           
}
</syntaxhighlight>

Nápravu dosiahneme nahradením celočíselného výrazu <tt>n</tt> výrazom logickým.

<syntaxhighlight lang="java">
int n = 1;
if (n != 0) {
    // ...           
}
</syntaxhighlight>

=== Jednorozmerné polia ===

V Jave sa oproti C/C++ používa trochu iná syntax pre deklaráciu poľa.
<syntaxhighlight lang="java">
int[] a; // Deklaracia premennej a reprezentujucej pole celych cisel
</syntaxhighlight>   
Samotné vytvorenie poľa a priradenie referencie naň do premennej <tt>a</tt> následne možno realizovať podobne ako pri dynamicky alokovaných poliach v C++.
<syntaxhighlight lang="java">
a = new int[10]; 
</syntaxhighlight>   
Pamäť alokovanú pri vytvorení poľa nie je potrebné manuálne uvoľňovať; stará sa o to automatický &bdquo;smetiarsky&rdquo; mechanizmus (angl. ''garbage collection''). Prípadne tiež možno spojiť deklaráciu premennej s vytvorením poľa do jediného príkazu.
<syntaxhighlight lang="java">
int[] a = new int[rozsah]; 
</syntaxhighlight>   
Namiesto <tt>int[] a</tt> možno písať aj <tt>int a[]</tt>; prvý spôsob je ale prirodzenejší, keďže typom premennej <tt>a</tt> je v oboch prípadoch <tt>int[]</tt>.

Pri vytvorení poľa sa všetky jeho prvky automaticky inicializujú &ndash; a to na 0 pri poliach čísel resp. znakov (kde ide o znak s kódom 0, nie o znak '0'), na <tt>false</tt> pri poliach booleovských hodnôt a na <tt>null</tt> pri poliach objektov a polí (poľami takéhoto typu sa budeme zaoberať až neskôr). V prípade potreby inicializovať pole vopred známej dĺžky na iné hodnoty možno použiť nasledujúcu skratku.
<syntaxhighlight lang="java">
int[] a = {0, 1, 2, 3, 4, 5}; 
</syntaxhighlight>   
Týmto príkazom sa do premennej <tt>a</tt> priradí referencia na šesťprvkové pole obsahujúce postupne hodnoty <tt>0, 1, 2, 3, 4, 5</tt>. Takéto priradenie možno realizovať ''iba na riadku, na ktorom je príslušná premenná deklarovaná''. Neskôr možno do premennej <tt>a</tt> priradiť takto &bdquo;vymenované&rdquo; pole nasledovne.
<syntaxhighlight lang="java">
int[] a;

// ...

a = new int[]{0, 1, 2, 3, 4, 5}; 
</syntaxhighlight>

Súčasťou poľa je v Jave aj informácia o jeho dĺžke, ku ktorej možno pre pole <tt>a</tt> pristúpiť cez <tt>a.length</tt>. Nasledujúci kus kódu tak napríklad do stoprvkového poľa <tt>a</tt> uloží postupnosť čísel <tt>0, 1, 2, ..., 99</tt>.
<syntaxhighlight lang="java">
int[] a = new int[100];
for (int i = 0; i <= a.length - 1; i++) {
    a[i] = i;
}
</syntaxhighlight>
V prípade pokusu o prístup k prvku poľa mimo jeho rozsah Java za behu programu vyhodí výnimku <tt>java.lang.ArrayIndexOutOfBoundsException</tt>. Mechanizmom výnimiek a ich spracovaním sa na tomto predmete budeme zaoberať neskôr; v tomto momente je podstatná skutočnosť, že v Jave nie je možné pomocou prístupu k danému poľu prepísať pamäť mimo jeho rozsah (čo je jedna z najnepríjemnejších chýb v C/C++).

=== Hodnoty vs. referencie v jazyku Java ===

Napriek tomu, že v jazyku Java neexistuje mechanizmus smerníkov (ani žiadna obdoba smerníkovej aritmetiky), sú všetky premenné okrem premenných primitívnych typov v skutočnosti referenciami predstavujúcimi adresy v pamäti. Presnejšie:
* Premenné primitívnych typov obsahujú ''hodnoty'' týchto primitívnych typov.
* Premenné všetkých zvyšných typov obsahujú ''referencie'' na pole alebo na objekt (aj polia sú v skutočnosti veľmi špeciálne objekty, ale to teraz ponechajme bokom).

Premenné obsahujúce referencie &ndash; zatiaľ vieme pracovať iba s premennými ukazujúcimi na pole &ndash; sa tak správajú veľmi podobne ako smerníky v C/C++. Operátor <tt>=</tt> aplikovaný na takéto premenné nekopíruje hodnoty, ale referencie; podobne operátor <tt>==</tt> neporovnáva hodnoty, ale referencie. 
<syntaxhighlight lang="java">
int[] a = {1, 2, 3, 4, 5};
int[] b = a;                   // Premenne a, b ukazuju na to iste patprvkove pole
b[0] = 10;
System.out.println(a[0]);      // Vypise 10
b = new int[a.length];         // Premenne a, b uz teraz ukazuju na dve rozne polia
for (int i = 0; i <= b.length - 1; i++) {
    b[i] = a[i];               // Hodnoty v oboch poliach su odteraz rovnake, polia ako take su rozne
}
System.out.println(a == b);    // Vypise false
</syntaxhighlight>
Premenná obsahujúca referenciu môže nadobúdať špeciálnu hodnotu <tt>null</tt>; v takom prípade referencia neukazuje na žiadnu pamäť.

=== Cyklus <tt>for each</tt> ===

V Jave existuje špeciálny variant cyklu <tt>for</tt>, tzv. cyklus <tt>for each</tt>, umožňujúci postupne prejsť cez všetky hodnoty prvkov poľa <tt>a</tt> aj bez indexovej premennej. Napríklad kus kódu 
<syntaxhighlight lang="java">int[] a = {6, 5, 4, 3, 2, 1};
for (int x : a) {
    System.out.println(x);
}
</syntaxhighlight>
je ekvivalentný nasledujúcemu kódu.
<syntaxhighlight lang="java">int[] a = {6, 5, 4, 3, 2, 1};
for (int i = 0; i <= a.length - 1; i++) {
    System.out.println(a[i]);
}
</syntaxhighlight>
Vo všeobecnosti možno povedať, že cyklus <tt>for each</tt> s iteračnou premennou <tt>x</tt> pracuje nasledovne:
* Prechádza postupne pole od začiatku po jeho koniec.
* V každej iterácii najprv skopíruje hodnotu na danej pozícii poľa do premennej <tt>x</tt> a následne vykoná príkazy v tele cyklu.

Z toho vyplýva, že ''pomocou cyklu <tt>for each</tt> nemožno meniť hodnoty prechádzaného poľa.'' Napríklad v cykle
<syntaxhighlight lang="java">for (int x : a) {
    x = 0;
}
</syntaxhighlight>
sa nemenia jednotlivé prvky poľa, ale iba lokálna premenná <tt>x</tt>. Avšak v prípade, že sú prvkami poľa referencie, možno pomocou cyklu <tt>for each</tt> meniť hodnoty, na ktoré tieto referencie ukazujú (to je vlastnosť, ktorú oceníme až neskôr).

=== Viacrozmerné polia ===

Popri jednorozmerných poliach možno v Jave pracovať aj s dvojrozmernými poľami, ktoré sa správajú podobne ako polia smerníkov resp. smerníky na smerníky v C/C++. V javovskej terminológii môžeme povedať, že dvojrozmerné pole je poľom polí. Obdĺžnikové pole vytvoríme napríklad nasledovne.
<syntaxhighlight lang="java">int[][] a = new int[3][4];  // Vytvori pole s troma riadkami a troma stĺpcami
</syntaxhighlight>
Takéto pole si možno predstaviť ako trojprvkové pole jednorozmerných polí dĺžky 4. Napríklad <tt>a[0]</tt> je teda jednorozmerné pole zodpovedajúce nultému riadku dvojrozmerného poľa <tt>a</tt>. S dvojrozmerným poľom potom pracujeme prirodzeným spôsobom.
<syntaxhighlight lang="java">for (int i = 0; i <= a.length - 1; i++) {
    for (int j = 0; j <= a[i].length - 1; j++) {
        a[i][j] = i + j;
    }
}
</syntaxhighlight>
Výsledné pole je znázornené na nasledujúcom obrázku.

[[Súbor:JPamat1.png]]

Alternatívne možno najprv inicializovať iba pole jednotlivých riadkov a následne každý z riadkov zvlášť. Takto môžeme vytvoriť aj iné ako obdĺžnikové polia, napríklad &bdquo;trojuholník&rdquo; z nasledujúceho príkladu.
<syntaxhighlight lang="java">int[][] a = new int[3][]; // V tomto momente su a[0], a[1] aj a[2] rovne null (vdaka automatickej inicializacii prvkov pola)
for (int i = 0; i <= a.length - 1; i++) {
    a[i] = new int[i + 1];
}
for (int i = 0; i <= a.length - 1; i++) {
    for (int j = 0; j <= a[i].length - 1; j++) {
        a[i][j] = j;
    }
}
</syntaxhighlight>
Výsledné pole je znázornené na nasledujúcom obrázku.

[[Súbor:JPamat2.png]]

Z tejto predstavy o reprezentácii dvojrozmerných polí by malo byť zrejmé, že napríklad inicializácia <tt>int[][] a = new int[][10];</tt> nie je korektná.

Rovnako ako s dvojrozmernými poľami možno v Jave pracovať aj s poľami o ľubovoľnom konečnom počte rozmerov. Pri inicializácii takýchto polí platí, že je potrebné určiť ''prvých niekoľko'' rozmerov (kde &bdquo;niekoľko&rdquo; v tomto prípade znamená &bdquo;aspoň jeden&rdquo;).
<syntaxhighlight lang="java">int[][][] a = new int[3][4][5]; // OK
int[][][] b = new int[3][4][];  // OK
int[][][] c = new int[3][][];   // OK
int[][][] d = new int[][4][5];  // Chyba
int[][][] e = new int[3][][5];  // Chyba
int[][][] f = new int[][][];    // Chyba
</syntaxhighlight>

== Statické metódy ==

Obdobou funkcií, ako ich poznáme z minulého semestra, sú v jazyku Java ''statické metódy'' triedy.
* Definujú sa vždy vo vnútri nejakej triedy s použitím podobnej syntaxe ako v C/C++. Pred návratový typ je potrebné napísať kľúčové slovo <tt>static</tt>, vďaka ktorému pôjde o ''statickú'' metódu triedy (čiže zjednodušene povedané &bdquo;obyčajnú funkciu&rdquo;) a nie o metódu inštancie triedy, čo je koncept objektovo orientovaného programovania, s ktorým sa zoznámime na budúcej prednáške.
* Pred klúčové slovo <tt>static</tt> ešte možno pridať ''modifikátor prístupu'' ako napr. <tt>public</tt> alebo <tt>private</tt> hovoriaci o viditeľnosti metódy z iných tried a balíkov. Modifikátormi prístupu sa budeme detailnejšie zaoberať neskôr.
* Statické metódy voláme rovnako ako funkcie v C/C++ (pri statickej metóde <tt>metoda</tt> z inej triedy <tt>Trieda</tt> pri jej volaní píšeme <tt>Trieda.metoda</tt>). Kľúčové slovo <tt>return</tt> sa tiež správa podobne ako v C/C++, avšak program obsahujúci metódu s návratovým typom rôznym od <tt>void</tt> a chýbajúcim príkazom <tt>return</tt> nie je možné skompilovať. Rovnako ako v C/C++ funguje aj rekurzia.

''Príklad'':
<syntaxhighlight lang="java">public class Trieda {

    static long faktorial(int n) {
        if (n == 0) {
            return 1;
        } else {
            return n * faktorial(n - 1);
        }
    }

    public static void main(String[] args) {
        System.out.println(faktorial(18));
    }
}
</syntaxhighlight>

=== Metóda <tt>main</tt> ===

* Špeciálnou statickou metódou je metóda <tt>main</tt>, ktorá sa vykoná bezprostredne po spustení programu (presnejšie danej triedy). Tá musí mať návratový typ <tt>void</tt>, modifikátor prístupu <tt>public</tt> a jediný argument typu <tt>String[]</tt> reprezentujúci pole argumentov programu z príkazového riadku (prípadné metódy <tt>main</tt> s inou hlavičkou sa považujú za &bdquo;obyčajné&rdquo; metódy a po spustení programu sa nevykonávajú).

<syntaxhighlight lang="java">public class Trieda {

    public static void main() {
        System.out.println("Tento text sa nikdy nevypise.");
    }

    public static void main(String[] args) {
        System.out.println("Pocet argumentov: " + args.length);
    }
}
</syntaxhighlight>

* Každá trieda, od ktorej po skompilovaní očakávame spustiteľnosť na JVM, musí mať definovanú hlavnú metódu <tt>main</tt>; často však píšeme aj triedy, ktoré slúžia len na použitie z iných tried.
* V IDE ako napr. IntelliJ je zvyčajne potrebné vybrať hlavnú triedu projektu, čo je trieda, ktorú sa prostredie bude snažiť spúšťať po spustení celého projektu. Táto trieda tak musí mať definovanú metódu <tt>main</tt>.

=== Predávanie argumentov metód ===

Argumenty metód sa v jazyku Java ''vždy predávajú hodnotou''.
* Pre argumenty sa tedy vždy vytvoria nové lokálne premenné, do ktorých sa skopírujú hodnoty argumentov, s ktorými bola metóda volaná. 
* ''Nie je teda možné napísať metódu, ktorá pozmení premenné z volajúcej metódy''. Ak sú ale argumentmi metódy referencie (polia alebo objekty), je možné pozmeniť hodnoty, na ktoré táto referencia ukazuje (t.j. napríklad zmeniť obsah poľa alebo premenné objektu).

''Príklad'':
<syntaxhighlight lang="java">public class Trieda {

    static void f(int n, int[] a) {
        n = 6;
        a[0] = 7;
        a = new int[]{8, 9, 10, 11, 12};
    }

    public static void main(String[] args) {
        int n = 0;
        int[] a = {1, 2, 3, 4, 5};
        f(n, a);
        System.out.println(n);     // Vypise 0
        System.out.println(a[0]);  // Vypise 7
    }
}
</syntaxhighlight>
* Špeciálne napríklad v Jave nie je možné napísať funkciu <tt>swap</tt>, ktorá vymení hodnoty dvoch premenných primitívnych typov.

== Práca s reťazcami ==

Zvyšok tejto prednášky sčasti presahuje jej rámec tým, že začneme pracovať s niektorými špeciálnymi objektmi bez toho, aby sme si vysvetlili mechanizmus objektov vo všeobecnosti. Už pomerne elementárne úkony, ako práca s reťazcami alebo so vstupom a výstupom, sa totiž v Jave realizujú s využitím objektov. Zvyšok tejto prednášky je motivovaný praktickou potrebou zvládnutia týchto úkonov; hlbšie pochopenie nasledujúceho materiálu nadobudneme budúci týždeň. 

=== Trieda <tt>String</tt> ===

Reťazce znakov sú v Jave objektmi triedy <tt>String</tt>. Premenné typu <tt>String</tt> teda majú charakter referencií na samotný objekt. Objekty triedy <tt>String</tt> sú konštantné reťazce &ndash; po vytvorení ich už teda nemožno meniť. Premennú typu <tt>String</tt> ale samozrejme môžeme meniť tak, že do nej priradíme referenciu na iný objekt typu <tt>String</tt>.

* Text ohraničený úvodzovkami sa považuje za reťazec typu <tt>String</tt>.
* Operátor <tt>+</tt> realizuje zreťazenie reťazcov. Stačí dokonca, aby bol aspoň jeden z operandov reťazec, zvyšné sa na <tt>String</tt> skonvertujú automaticky.

''Príklad'':
<syntaxhighlight lang="java">String s = "Hello, World!";
System.out.println(s);

int n = 42;
s = "Hodnota premennej n je " + n + ".";
System.out.println(s);
</syntaxhighlight>

Keďže sú premenné typu <tt>String</tt> referenciami na objekt, operátor <tt>=</tt> tiež kopíruje iba referencie a operátor <tt>==</tt> neporovnáva hodnoty reťazcov (t.j. samotné texty), ale adresy v pamäti. Vzhľadom na konštantnosť reťazcov je tu častejším zdrojom chýb nesprávne použitie operátora <tt>==</tt>.  
Porovnanie reťazcov správne realizuje metóda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/String.html#equals(java.lang.Object) <tt>equals</tt>].

<syntaxhighlight lang="java">String str1 = "nejaky text";
String str2 = str1;             // str2 a str1 ukazuju na to iste miesto v pamati
String str3 = str1 + "";        // str3 a str1 ukazuju na rozne miesta v pamati, ktore obsahuju rovnake retazce
String str4 = new String(str1); // str4 a str1 ukazuju na rozne miesta v pamati, ktore obsahuju rovnake retazce
if (str2 == str1) {
    System.out.println("str2 == str1");
}
if (str3 == str1) {
    System.out.println("str3 == str1");
}
if (str4 == str1) {
    System.out.println("str4 == str1");
}
if (str2.equals(str1)) {
    System.out.println("str2.equals(str1)");
}
if (str3.equals(str1)) {
    System.out.println("str3.equals(str1)");
}
if (str4.equals(str1)) {
    System.out.println("str4.equals(str1)");
}
</syntaxhighlight>

Z ďalších metód triedy <tt>String</tt>, ktoré možno použiť na manipuláciu s reťazcami, spomeňme aspoň tieto:
* Metóda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/String.html#length() <tt>length</tt>] vráti dĺžku daného reťazca. ''Pozor'': keďže ide o metódu (bez argumentov), na rozdiel od polí pre reťazec <tt>s</tt> píšeme <tt>s.length()</tt> so zátvorkami na konci.
* Metóda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/String.html#charAt(int) <tt>charAt</tt>] s jedným celočíselným argumentom vráti znak na danej pozícii.

<syntaxhighlight lang="java">String s = "retazec";
for (int i = 0; i <= s.length() - 1; i++) {
    System.out.println(s.charAt(i));
}
</syntaxhighlight>
* Množstvo ďalších metód na prácu s reťazcami možno nájsť v [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/String.html dokumentácii k triede <tt>String</tt>].

=== Trieda <tt>StringBuilder</tt> ===

V prípade potreby daný reťazec často modifikovať by bolo s použitím triedy <tt>String</tt> potrebné pri každej modifikácii vytvoriť nový objekt, čo je pomerne pomalé. Rýchlejšou alternatívou je použitie triedy [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/StringBuilder.html <tt>StringBuilder</tt>] reprezentujúcej ''modifikovateľný'' reťazec, ktorý je tiež konvertovateľný na <tt>String</tt>. 

Napríklad reťazec <tt>abc...z</tt> obsahujúci všetky písmená malej anglickej abecedy tak môžeme vytvoriť dvoma rôznymi spôsobmi: buď pomocou pomalého vytvárania 27 rôznych <tt>String</tt>-ov
<syntaxhighlight lang="java">
String abeceda = "";
for (char c = 'a'; c <= 'z'; c++) {
    abeceda = abeceda + c;  
}
</syntaxhighlight>
alebo pomocou rýchlejšieho vytvorenia jedného objektu typu <tt>StringBuilder</tt>, jeho postupných modifikácií a následného vytvorenia jedného objektu typu <tt>String</tt>.
<syntaxhighlight lang="java">
StringBuilder buffer = new StringBuilder();
for (char c = 'a'; c <= 'z'; c++) {
     buffer.append(c);  
}
String abeceda = buffer.toString();  
</syntaxhighlight>
Reťazec reprezentovaný objektom typu <tt>StringBuilder</tt> môžeme aj priamo vypísať na konzolu.
<syntaxhighlight lang="java">
System.out.println(buffer);
</syntaxhighlight>
Naopak v prípadoch, keď reťazec nie je potrebné modifikovať, je implementácia cez <tt>String</tt> o niečo efektívnejšia.

== Vstup a výstup ==

Zameriame sa teraz na základy práce s textovým vstupom a výstupom &ndash; či už na konzole, alebo v podobe textových súborov.  

=== Výstupné prúdy: trieda <tt>PrintStream</tt> ===

Textový výstup možno v Jave najjednoduchšie produkovať pomocou triedy [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/io/PrintStream.html <tt>PrintStream</tt>], ktorú je nutné importovať z balíka <tt>java.io</tt>; prípadne je možné importovať aj kompletný balík <tt>java.io</tt>.
<syntaxhighlight lang="java">
import java.io.*; // alebo: import java.io.PrintStream;

public class Trieda {
    
    public static void main(String[] args) {
        // ...
    }
}
</syntaxhighlight> 

Výstupný prúd pre zápis do textového súboru <tt>vystup.txt</tt> vytvoríme napríklad nasledovne.
<syntaxhighlight lang="java">
PrintStream out = new PrintStream("vystup.txt");
</syntaxhighlight>
* V prípade, že súbor <tt>vystup.txt</tt> existuje, premaže sa týmto volaním jeho obsah; v prípade potreby zapisovať na koniec existujúceho súboru možno použiť <tt>PrintStream out = new PrintStream(new FileOutputStream("vystup.txt", true))</tt>, kde o pridávaní na koniec súboru hovorí booleovský parameter <tt>true</tt> (viac v dokumentácii).  
* Adresár, od ktorého sa počíta takáto relatívna adresa súboru, závisí od prostredia. Pri spúšťaní programu z príkazového riadku sa súbor <tt>vystup.txt</tt> vytvorí v adresári, z ktorého bol spustený interpreter <tt>java</tt>. Pri práci s IntelliJ ide pri východzích nastaveniach o koreňový adresár projektu (obsahujúci podadresáre ako <tt>src</tt> a <tt>out</tt>). 
* Vytvorenie inštancie triedy <tt>PrintStream</tt> môže spôsobiť výnimku typu <tt>IOException</tt>, ktorú je nutné ošetriť. Spracovaním výnimiek sa na tomto predmete budeme zaoberať až neskôr &ndash; zatiaľ teda zvolíme najjednoduchšie riešenie, pri ktorom iba do hlavičky volajúcej metódy (v príklade nižšie ide o metódu <tt>main</tt>) pridáme upozornenie, že v nej môže vzniknúť neošetrená výnimka typu <tt>IOException</tt> (v prípade, že sme neimportovali celý balík <tt>java.io</tt>, je z neho potrebné importovať triedu <tt>java.io.IOException</tt>).
<syntaxhighlight lang="java">
public static void main(String[] args) throws IOException {
    PrintStream out = new PrintStream("vystup.txt");
    // ...
}
</syntaxhighlight>
Po vytvorení výstupného prúdu môžeme používať jeho metódy na zápis do súboru, ako napríklad nasledujúce.
* <tt>print</tt>: zapíše do súboru svoj argument (prakticky ľubovoľného typu).
* <tt>println</tt>: to isté, len s novým riadkom na konci (pri volaní bez argumentov vypíše iba znak pre nový riadok).
* <tt>format</tt> alebo <tt>printf</tt>: zapíše text podľa formátovacieho reťazca podobného ako v C (viac [https://docs.oracle.com/javase/tutorial/essential/io/formatting.html tu]).
* <tt>close</tt>: metóda bez argumentu, ktorá zavrie otvorený výstupný prúd a je potrebné ju zavolať akonáhle so súborom prestaneme pracovať.

Kompletný program zapisujúci do súboru <tt>vystup.txt</tt> tak môže vyzerať napríklad nasledovne.
<syntaxhighlight lang="java">import java.io.*; 

public class Trieda {

    public static void main(String[] args) throws IOException {
        PrintStream out = new PrintStream("subor.txt");
        out.print("Nejaky text");
        out.println();
        out.println("Nejaky iny text");
        out.close();
    }
}
</syntaxhighlight>

Špeciálnym výstupným prúdom typu <tt>PrintStream</tt> je aj štandardný výstupný prúd [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/System.html#out <tt>System.out</tt>]. Pri práci s ním tak možno používať rovnaké metódy ako vyššie. Nie je pritom potrebné importovať triedu <tt>PrintStream</tt> (pretože pracujeme iba s jej inštanciou <tt>System.out</tt> a trieda <tt>System</tt> sa importuje automaticky), ani špecifikovať <tt>throws IOException</tt> (pretože nevoláme konštruktor triedy <tt>PrintStream</tt>, ktorý túto výnimku môže spôsobiť).

<syntaxhighlight lang="java">public class Trieda {

    public static void main(String[] args) {
        System.out.print("Nejaky text");
        System.out.println();
        System.out.println("Nejaky iny text");
    }
}
</syntaxhighlight>

=== Vstupné prúdy ===

Základná trieda pre vstupné prúdy je v Jave [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/io/InputStream.html <tt>InputStream</tt>]. Tohto typu je aj štandardný vstupný prúd [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/System.html#in <tt>System.in</tt>] pre čítanie z konzoly. Vstupné prúdy pre čítanie zo súboru sú reprezentované triedou [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/io/FileInputStream.html <tt>FileInputStream</tt>]; pre účely tejto prednášky možno <tt>FileInputStream</tt> považovať za špeciálny prípad <tt>InputStream</tt>. Obe tieto triedy sú definované v balíku <tt>java.io</tt>.

Používanie týchto vstupných prúdov však nie je veľmi pohodlné, pretože umožňujú iba čítanie po bytoch. Preto sa zvyknú používať nadstavbové triedy, ktoré tieto jednoduché vstupné prúdy &bdquo;obalia&rdquo; a programátorovi poskytnú aj pokročilejšie funkcie na prácu so vstupom. V nasledujúcom preskúmame dve z takýchto nadstavbových tried: [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Scanner.html <tt>Scanner</tt>] a [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/io/BufferedReader.html <tt>BufferedReader</tt>].

=== Trieda <tt>Scanner</tt> ===

Trieda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Scanner.html <tt>Scanner</tt>] &ndash; definovaná v balíku <tt>java.util</tt>, z ktorého je nutné túto triedu importovať &ndash; umožňuje rozkladať vstupný prúd na reťazce oddelené bielymi znakmi, pričom kompatibilné reťazce dokáže konvertovať aj na číselné typy. Alternatívne možno <tt>Scanner</tt> použiť aj na čítanie vstupu po riadkoch.

<tt>Scanner</tt> možno vytvoriť na základe vstupného prúdu typu [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/io/InputStream.html <tt>InputStream</tt>], ktorým môže byť napríklad štandardný vstupný prúd <tt>System.in</tt> pre čítanie z konzoly, alebo inštancia triedy [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/io/FileInputStream.html <tt>FileInputStream</tt>] pre čítanie z textového súboru; <tt>Scanner</tt> čítajúci zo vstupného súboru možno vytvoriť aj priamo na základe inštancie triedy [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/io/File.html <tt>File</tt>] reprezentujúcej cestu k súboru. Triedy <tt>FileInputStream</tt> aj <tt>File</tt> sú definované v balíku <tt>java.io</tt>, z ktorých ich je potrebné importovať. Pri obidvoch spôsoboch vytvárania <tt>Scanner</tt>-u ''pre textový súbor'' môže vzniknúť výnimka typu <tt>IOException</tt>, ktorú je potrebné ošetriť (napríklad cez <tt>throws IOException</tt> v hlavičke volajúcej metódy). V prípade čítania z textového súboru je tiež potrebné na konci <tt>Scanner</tt> zavrieť jeho metódou [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Scanner.html#close() <tt>close</tt>].

<syntaxhighlight lang="java">import java.util.*; // Kvoli triede Scanner

public class Trieda {
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // ...
    } 
}
</syntaxhighlight>

<syntaxhighlight lang="java">import java.io.*;   // Kvoli triede FileInputStream
import java.util.*; // Kvoli triede Scanner

public class Trieda {
    
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(new FileInputStream("vstup.txt"));
        // ...
        scanner.close(); 
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">import java.io.*;   // Kvoli triede File
import java.util.*; // Kvoli triede Scanner

public class Trieda {
    
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(new File("vstup.txt"));
        // ...
        scanner.close();
    }
}
</syntaxhighlight>
Inak je použitie <tt>Scanner</tt>-a prakticky totožné, nech už čítame z konzoly alebo zo súboru. Kompletný zoznam metód poskytovaných touto triedou možno nájsť [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Scanner.html v jej dokumentácii]. Tu spomeňme aspoň nasledujúce metódy:
* <tt>next</tt>: vráti nasledujúci reťazec oddelený od zvyšku vstupu bielymi znakmi; ak žiaden neexistuje, vyhodí výnimku (pri čítaní z konzoly sa to môže stať len pri manuálnom zadaní znaku konca súboru; v IntelliJ sa koniec súboru zadáva ako Ctrl+D bez ohľadu na operačný systém, t.j. aj pod Windowsom, avšak časť vstupu &bdquo;nepotvrdená&rdquo; klávesou <tt>Enter</tt> sa v takom prípade odignoruje).
* <tt>hasNext</tt>: zistí, či na vstupe zostáva neprečítaný nebiely reťazec, ktorý by mohla vrátiť funkcia <tt>next</tt> (pri čítaní z konzoly sa samozrejme vždy čaká na ďalší vstup zadaný používateľom).
* <tt>nextInt</tt>: prečíta nasledujúci reťazec oddelený od zvyšku vstupu bielymi znakmi, pričom ale predpokladá, že ide o celé číslo a na výstup vráti tento reťazec už skonvertovaný na číslo; ak nasledujúci reťazec nebielych znakov neexistuje, alebo nie je korektnou reprezentáciou celého čísla, vyhodí výnimku.
* <tt>hasNextInt</tt>: zistí, či na vstupe nasleduje reťazec interpretovateľný ako celé číslo, ktorý by mohla prečítať funkcia <tt>nextInt</tt>.
* Podobne napríklad <tt>nextLong</tt>, <tt>nextDouble</tt>, <tt>hasNextLong</tt>, <tt>hasNextDouble</tt>, atď.
* <tt>nextLine</tt>: prečíta riadok až po jeho koniec a výsledný reťazec (bez prípadného <tt>\n</tt> na konci) vráti na výstupe.
* <tt>hasNextLine</tt>: zistí, či na vstupe nasleduje ďalší riadok.

''Príklad 1'': nasledujúci program prečíta z konzoly prirodzené číslo <tt>n</tt> a za ním <tt>n</tt> reťazcov oddelených bielymi znakmi, ktoré uloží do pola <tt>a</tt>. Následne na konzolu vypíše tieto reťazce, každý na osobitnom riadku, v opačnom poradí ako na vstupe.
<syntaxhighlight lang="java">import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        String[] a = new String[n];
        for (int i = 0; i <= n - 1; i++) {
            a[i] = scanner.next();
        }
        for (int i = n - 1; i >= 0; i--) {
            System.out.println(a[i]);
        }
    }
}
</syntaxhighlight>

''Príklad 2'': nasledujúci program číta textový súbor <tt>vstup.txt</tt> obsahujúci niekoľko čísel oddelených bielymi znakmi. Po prečítaní celého vstupného súboru vypíše súčet týchto čísel na konzolu.

<syntaxhighlight lang="java">import java.io.*;
import java.util.*;

public class Trieda {

    public static void main(String[] args) throws IOException {
        int sucet = 0;
        Scanner scanner = new Scanner(new File("vstup.txt"));
        while (scanner.hasNextInt()) {
            sucet += scanner.nextInt();
        }
        scanner.close();
        System.out.println(sucet);
    }
}
</syntaxhighlight>

=== Trieda <tt>BufferedReader</tt> ===

Trieda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/io/BufferedReader.html <tt>BufferedReader</tt>] &ndash; definovaná v balíku <tt>java.io</tt> &ndash; umožňuje čítať vstup po znakoch a po riadkoch. Jej metódy spravidla vyhadzujú výnimky typ <tt>IOException</tt>, ktoré je nutné ošetriť (aspoň cez <tt>throws IOException</tt> v hlavičke volajúcej funkcie).

* Vytvorenie inštancie triedy <tt>BufferedReader</tt> pre čítanie z konzoly:
<syntaxhighlight lang="java">BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
// ...
</syntaxhighlight>
* Vytvorenie inštancie triedy <tt>BufferedReader</tt> pre čítanie zo súboru:
<syntaxhighlight lang="java">BufferedReader in = new BufferedReader(new FileReader("vstup.txt"));
// ...
in.close();
</syntaxhighlight>
Trieda <tt>BufferedReader</tt> pritom poskytuje dve kľúčové metódy:
* <tt>read</tt>: prečíta jeden znak zo vstupu a vráti ho na výstupe (v prípade konca súboru vráti -1); jej návratový typ je <tt>int</tt>.
* <tt>readLine</tt>: prečíta jeden riadok zo vstupu; jej návratový typ je <tt>String</tt> (reťazec bez prípadného <tt>\n</tt> na konci riadku).

''Príklad 1'': nasledujúci program prečíta z konzoly jeden riadok a následne na konzolu vypíše ten istý riadok, pričom ale malé písmená abecedy prevedie na veľké.

<syntaxhighlight lang="java">import java.io.*;

public class Trieda {

    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String s = in.readLine();
        System.out.println(s.toUpperCase());
    }
}
</syntaxhighlight>

''Príklad 2'': nasledujúci program prečíta textový súbor <tt>vstup.txt</tt> po znakoch a jeho obsah vypíše na konzolu.

<syntaxhighlight lang="java">import java.io.*;

public class Trieda {

    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new FileReader("vstup.txt"));
        int c;
        while ((c = in.read()) != -1) {
            System.out.print((char) c);
        }
        in.close();
    }
}
</syntaxhighlight>

== Ďalšie užitočné štandardné triedy ==

* Trieda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/Math.html <tt>Math</tt>] obsahuje množštvo statických metód realizujúcich matematické funkcie a operácie, napríklad:
<syntaxhighlight lang="java">public class Trieda {

    public static void main(String[] args) {
        System.out.println(Math.pow(2, 0.5));
        System.out.println(Math.cos(Math.PI));
        System.out.println(Math.log(Math.E));
        System.out.println(Math.max(1, 2));
        System.out.println(Math.abs(-1));
        System.out.println(Math.toDegrees(Math.acos(Math.sqrt(3) / 2)));
        // ..
    }
}
</syntaxhighlight>
* Trieda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Random.html Random] reprezentuje generátor náhodných čísel. Je definovaná v balíku <tt>java.util</tt>. Napríklad nasledujúci program simuluje 10 hodov vyváženou hracou kockou.
<syntaxhighlight lang="java">import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        Random random = new Random();
        for (int i = 1; i <= 10; i++) {
            System.out.println(random.nextInt(6) + 1); // vygeneruj nahodne prirodzene cislo MENSIE ako 6 a zvys ho o 1
        }
    }
}
</syntaxhighlight>
* Trieda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Arrays.html Arrays] z balíka <tt>java.util</tt> obsahuje statické metódy na prácu s poľami; napr. <tt>equals</tt> na porovnávanie polí (a nie iba referencií), <tt>copyOf</tt> na kopírovanie polí (a nie iba referencií), <tt>sort</tt> na utriedenie poľa, <tt>binarySearch</tt> na binárne vyhľadávanie, atď.
=Letný semester, cvičenia č. 1=
* Úvod cvičenia: dokončenie [[#Letný semester, prednáška č. 1|prvej prednášky]]. Videozáznam bude k dispozícii v MS Teams.
* Na [http://prog.dcs.fmph.uniba.sk/ testovači] zverejnených päť nebodovaných cvičení a jedna bonusová úloha s odovzdaním ''do stredy 24. februára, 11:30''.
=Letný semester, pravidlá=
''Na úspešné absolvovanie predmetu je potrebné'':
* Získať za semester a praktickú časť skúšky dohromady aspoň 50 bodov z plného počtu 100 bodov.
* Uspieť na skúške.

''Body budú prideľované podľa nasledujúceho kľúča'':
* Najviac 35 bodov za praktické testy na cvičeniach (5 testov po 7 bodov).
* Najviac 35 bodov za domáce úlohy (5 úloh po 7 bodov).
* Najviac 30 bodov za praktickú časť skúšky.
* Kladný počet bodov za bonusové úlohy.

Všetky zadania na tomto predmete musia byť riešené individuálne.

== Testy na cvičeniach ==

''Počas'' piatich spomedzi ''stredajších cvičení'' bude prebiehať praktický test, za ktorý bude možné získať najviac 7 bodov.
* Test bude pozostávať z niekoľkých (typicky troch) programátorských úloh s odovzdávaním riešení na testovač.
* (Podobný princíp ako rozcvičky v zimnom semestri, avšak bude potrebné vyriešiť viac ako jednu úlohu a pomoc od vyučujúcich bude limitovaná na otázky konkrétneho charakteru.)
* ''Termíny testov:'' 10. marca, 24. marca, 7. apríla, 14. apríla, 28. apríla.  
* Na každom z testov sa môžu objaviť úlohy k ľubovoľnej v tom čase už prebranej látke (upresní sa neskôr).
* Na získanie bodov z testu je potrebná účasť na cvičeniach v danom týždni. To v online forme znamená účasť na príslušnom stretnutí v MS Teams počas práce na riešení testu.

Koncom semestra budú ''počas stredajších cvičení'' dva náhradné termíny testov:
* Ide predovšetkým o náhradu za prípadné neabsolvované testy, ale možno ich využiť aj na opravu absolvovaného testu.
* ''Termíny náhradných testov:'' 5. mája, 12. mája (študenti BIN môžu druhý náhradný test namiesto 12. mája absolvovať počas prvého riadneho skúškového termínu). 
* Maximálne teda možno riešiť sedem testov, pričom v takom prípade sa do hodnotenia započíta päť najlepších výsledkov. Je ale potrebné využiť výhradne riadne a náhradné termíny uvedené vyššie.
* Na náhradných testoch sa môžu objaviť úlohy k ľubovoľnej v tom čase už prebranej látke. Nepôjde teda o náhradu konkrétneho z piatich riadnych testov.

V prípade ''odôvodnenej a ospravedlnenej'' neúčasti na viac ako dvoch testoch bude mechanizmus ich náhrady stanovený individuálne.

== Domáce úlohy ==

Počas semestra bude zverejnených päť bežných domácich úloh, pričom za každú bude možné získať najviac 7 bodov.
* Riešenia sa budú odovzdávať na testovač.
* Termín odovzdania bude vždy aspoň 10 dní po zverejnení úlohy. Prvá domáca úloha bude zverejnená v pondelok 1. marca.

Okrem toho bude počas semestra zverejnených niekoľko bonusových úloh (za rôzne počty bodov a s rôznymi termínmi odovzdania). 

== Skúška ==  

Skúška bude pozostávať z:
* Praktickej časti spočívajúcej v riešení programátorských úloh s odovzdávaním na testovač. Za praktickú časť skúšky bude možné získať najviac 30 bodov do celkového hodnotenia.
* Ústnej časti spočívajúcej v diskusii o praktickej časti skúšky a o teórii z prednášok.

Na úspešné absolvovanie ''skúšky'' je potrebné:
* Získať aspoň 15 bodov z praktickej časti.
* Uspieť na ústnej časti skúšky.

Prípadné opakovanie skúšok sa riadi študijným poriadkom. Body z praktickej časti skúšky sa do prípadných ďalších termínov neprenášajú (v prípade opakovania skúšky je teda vždy nutné opakovať aj praktickú časť).

== Výsledná známka z predmetu ==

Po úspešnom absolvovaní (oboch častí) skúšky sa výsledná známka z predmetu za daný skúškový termín stanoví, na základe celkového počtu bodov získaných za semester a praktickú časť skúšky, podľa nasledujúceho kľúča:
{|- 
| 
| 90 bodov a viac
| style="width: 20px;" |
| A
|-
| 
| aspoň 80 a menej ako 90 bodov
| style="width: 20px;" |
| B
|-
| 
| aspoň 70 a menej ako 80 bodov
| style="width: 20px;" |
| C
|-
| 
| aspoň 60 a menej ako 70 bodov
| style="width: 20px;" |
| D
|-
| 
| aspoň 50 a menej ako 60 bodov
| style="width: 20px;" |
| E
|-
| 
| menej ako 50 bodov
| style="width: 20px;" |
| FX
|-
|}
V ojedinelých prípadoch môže byť táto známka na základe ústnej časti skúšky pozmenená o jeden stupeň. V prípade neúspechu na skúške získava študent v rámci daného skúškového termínu hodnotenie FX.

== Režim pre pokročilých ==

Počas druhých cvičení, t.j. ''v stredu 24. februára o 11:30'', sa bude konať ''praktický'' test pre pokročilých.
* V prípade záujmu je potrebné sa na test aspoň 24 hodín vopred prihlásiť cez AIS. 
* Forma rovnaká ako pri piatich bežných testoch.
* Úlohy môžu byť zamerané na ľubovoľnú tému zo syláb predmetu.
* Každý, kto z testu získa aspoň 80%, bude mať možnosť predmet absolvovať v režime pre pokročilých.

Študenti v režime pre pokročilých:
* Počas semestra nemusia získať žiadne body a nemusia sa zúčastniť ani na praktickej časti skúšky.
* Namiesto toho počas semestra vypracujú softvérový projekt, ktorého prezentácia bude súčasťou ústnej skúšky.
** Projekt musí byť napísaný v jazyku Java s použitím platformy JavaFX.
** Rozsah a náročnosť projektu musia byť primerané tomu, že pôjde o celosemestrálnu prácu.
** Očakáva sa tiež istá úroveň programátorského štýlu a objektovo orientovaného návrhu, rozumná miera prehľadnosti kódu a dodržiavanie základných konvencií jazyka Java.
* Najneskôr do začiatku cvičení 3. marca prostredníctvom testovača odovzdajú krátky neformálny návrh projektu a najneskôr do začiatku cvičení 10. marca sa na definitívnej téme projektu dohodnú s prednášajúcim. V opačnom prípade zvyšok semestra absolvujú v štandardnom režime.
* Zdrojový kód projektu odovzdajú najneskôr 48 hodín pred začiatkom skúšky prostredníctvom testovača a projekt v rámci ústnej skúšky predvedú na svojom počítači.
=Letný semester, softvér=
Pre účely tohto predmetu budeme potrebovať nasledujúci softvér:
* [https://www.oracle.com/java/technologies/javase-jdk15-downloads.html Java SE Development Kit 15] (stačí ľubovoľná verzia od 11 vyššie); pod Linuxom možno použiť aj balíky <tt>openjdk</tt>.
* [https://gluonhq.com/products/javafx/ Platformu JavaFX 15] SDK (na stránke ako &bdquo;Latest Release&rdquo;, ale opäť by mala stačiť aj verzia 11) pre vývoj aplikácií s grafickým používateľským rozhraním.
* Vývojové prostredie [https://www.jetbrains.com/idea/download/ IntelliJ IDEA Community Edition 3.2], prípadne vhodnú alternatívu ako napríklad Eclipse alebo Visual Studio Code.

Odporúčame pracovať vo vývojom prostredí, avšak je dôležité naučiť sa kompilovať a spúšťať programy aj z príkazového riadku (minimálne za účelom riešenia rôznych problémov).

== Inštalácia softvéru ==

* Stiahnite si Java SE Development Kit 15 [https://www.oracle.com/java/technologies/javase-jdk15-downloads.html odtiaľto] a postupujte podľa inštalačných pokynov.
* Zistite, či inštalácia správne pridala adresár obsahujúci javovský kompilátor a interpreter do systémovej premennej <tt>PATH</tt>. V prípade úspechu by napríklad nasledujúce príkazy zadané do príkazového riadku mali vypísať verziu javovského kompilátora resp. interpretra zhodnú s nainštalovanou verziou Javy.
<pre>
javac --version
java --version
</pre>
* V prípade, že tieto príkazy nefungujú, alebo sa vypísala stará verzia Javy, pridajte adresár obsahujúci programy <tt>javac</tt> a <tt>java</tt> do systémovej premennej <tt>PATH</tt> manuálne (a prípadný adresár starej verzie Javy odtiaľ odoberte).
* Stiahnite si ZIP archív s JavaFX [https://gluonhq.com/products/javafx/ odtiaľto] (pre najnovšiu verziu Javy odporúčame &bdquo;Latest Release&rdquo;, čiže verziu 15) a rozbaľte ho do vhodného priečinka. Žiadne ďalšie úkony nie sú v rámci inštalácie JavaFX nutné, ale zapamätajte si adresu podadresára <tt>lib</tt>, keďže ju neskôr budete potrebovať. Nižšie v tomto texte budeme na túto cestu odkazovať ako na <tt><cesta k lib></tt>.
* Stiahnite si IntelliJ IDEA Community Edition 3.2 [https://www.jetbrains.com/idea/download/ odtiaľto] a postupujte podľa inštalačných pokynov.
* IntelliJ by mal automaticky rozoznať nainštalovanú verziu Javy. V prípade, že sa tak neudeje, pridajte ju manuálne podľa pokynov [https://www.jetbrains.com/help/idea/sdk.html tu].

== Skompilovanie a spustenie programu v Jave ==

Tento oddiel opisuje proces skompilovania a spustenia javovskej triedy <tt>Hello</tt> vypisujúcej na konzolu text <tt>Hello, World!</tt> v dvoch variantoch:
* V prvom je trieda <tt>Hello</tt> súčasťou nepomenovaného balíka.
* V druhom je trieda <tt>Hello</tt> súčasťou balíka <tt>somepackage</tt>.

=== Z príkazového riadku ===

Uvažujme najprv prípad, keď je trieda <tt>Hello</tt> súčasťou nepomenovaného balíka, t.j. jej zdrojový kód vyzerá nasledovne.

<syntaxhighlight lang="java">public class Hello {

    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }

}
</syntaxhighlight>
* Trieda <tt>Hello</tt> musí byť uložená v súbore <tt>Hello.java</tt> (názov súboru bez prípony <tt>.java</tt> sa musí zhodovať s názvom triedy).

Postup skompilovania a spustenia triedy <tt>Hello</tt> z príkazového riadku je potom nasledovný:

# V príkazovom riadku sa nastavíme do priečinka obsahujúceho súbor <tt>Hello.java</tt>.
# Triedu skompilujeme príkazom <tt>javac Hello.java</tt>, v dôsledku čoho by mal v rovnakom priečinku vzniknúť súbor <tt>Hello.class</tt> spustiteľný na JVM.
# Triedu <tt>Hello</tt> spustíme príkazom <tt>java Hello</tt> (prípadné argumenty môžeme triede <tt>Hello</tt> zadávať obvyklým spôsobom). 
: ''Pozor'': kým pri volaní kompilátora <tt>javac</tt> je potrebné uviesť aj príponu kompilovaného súboru <tt>.java</tt>, pri volaní interpretra <tt>java</tt> príponu spúšťanej triedy <tt>.class</tt> nepíšeme (kým argumentom kompilátora je bežná cesta k súboru, argumentom interpretra je tzv. ''classpath'' danej triedy).

Ďalej uvažujme prípad, keď je trieda <tt>Hello</tt> súčasťou balíka <tt>somepackage</tt> a jej kód tak vyzerá nasledovne.

<syntaxhighlight lang="java">package somepackage;

public class Hello {

    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }

}
</syntaxhighlight>
* V tomto prípade by mala byť trieda <tt>Hello</tt> opäť uložená v súbore <tt>Hello.java</tt>, ktorý by mal navyše byť uložený v priečinku <tt>somepackage</tt>. 

Skompilovanie a spustenie triedy <tt>Hello</tt> &ndash; alebo presnejšie <tt>somepackage.Hello</tt> &ndash; z príkazového riadku realizujeme nasledovne:
# Nastavíme sa do priečinka obsahujúceho priečinok <tt>somepackage</tt>.
# Triedu skompilujeme príkazom <tt>javac somepackage/Hello.java</tt> (s príponou).
# Triedu spustíme príkazom <tt>java somepackage.Hello</tt> (ide o tzv. ''classpath'' triedy <tt>Hello</tt>).

=== V IntelliJ IDEA ===

# Vytvoríme nový projekt pomocou voľby ''New Project''. V prvých dvoch krokoch použijeme východzie nastavenia (jazyk Java, bez použitia šablóny ani ďalších voliteľných možností), v treťom kroku zadáme ľubovoľný názov projektu.
# Ak sa nezobrazuje, zobrazíme panel so štruktúrou projektu cez <tt>View --> Tool Windows --> Project</tt> (alebo s použitím klávesovej skratky <tt>Alt + 1</tt>).
# Rozbalíme modul pomenovaný rovnako ako projekt (tučným) a zvolíme priečinok <tt>src</tt>.
# V ponuke <tt>File --> New</tt> (prípadne v podponuke <tt>New</tt> kontextovej ponuky, ktorá sa zobrazí po kliknutí na <tt>src</tt> pravou myšou) by sa teraz mala objavovať možnosť <tt>Java Class</tt>.
# Po zvolení tejto možnosti zadáme názov triedy (presnejšie celú ''classpath'' vrátane balíkov), t.j. <tt>Hello</tt> pre triedu v nepomenovanom balíku a <tt>somepackage.Hello</tt> pre triedu v balíku <tt>somepackage</tt>.
# V závislosti od vybranej alternatívy skopírujeme do editora vhodnú variantu triedy <tt>Hello</tt> z predchádzajúceho oddielu.
# Triedu skompilujeme a spustíme napríklad kliknutím na zelenú šípku vedľa hlavičky metódy <tt>main</tt> a zvolením možnosti <tt>Run 'trieda.main()'</tt>. Následné ďalšie spustenia možno realizovať skratkou <tt>Shift + F10</tt>.

Dôvod, prečo skratka <tt>Shift + F10</tt> (ekvivalentná možnosti <tt>Run --> Run 'Hello'</tt>) nefunguje hneď od začiatku je ten, že sme zatiaľ nevytvorili tzv. konfiguráciu behu, v ktorej sa napríklad zadáva verzia Javy použitá pri kompilovaní, hlavná trieda projektu (t.j. trieda, ktorá sa má spustiť po spustení projektu), prípadné argumenty z príkazového riadku, parametre pre kompilátor a interpreter, atď. V prípade kliknutia na zelenú šípku vedľa metódy main a zvolenia príslušnej možnosti sa automaticky vytvorí tzv. dočasná konfigurácia, pri ktorej sa spustí daná trieda s východzími nastaveniami. 

Pre neskoršie účely je dôležité vedieť vytvárať aj vlastné (a permanentné) konfigurácie behu (v jednom projekte možno definovať aj viacero konfigurácií, medzi ktorými sa potom možno prepínať pomocou prepínača v pravej časti nástrojovej lišty). Postup vytvorenia novej konfigurácie behu je nasledujúci:
# Zvolíme <tt>Run --> Edit Configurations...</tt>. 
# Klikneme na tlačidlo <tt>+</tt> a zvolíme možnosť <tt>Application</tt>.
# Následne môžeme v hlavnej časti okna napravo zadať názov konfigurácie, napríklad <tt>Konfiguracia</tt>.
# Zadáme potrebné údaje: predvolená by mala byť správna verzia Javy (napr. <tt>java 15</tt>), do políčka <tt>Main class</tt> zadáme názov hlavnej triedy projektu (napr. <tt>Hello</tt>), do políčka <tt>Program arguments</tt> môžeme zadať prípadné argumenty pre spúšťanú triedu z príkazového riadku (políčko môžeme ponechať prázdne). Prípadné ďalšie možnosti môžeme pridať kliknutím na <tt>Modify options</tt>.
# Ukončíme dialóg tlačidlom <tt>OK</tt>.
# Na nástrojovej lište sa uistíme, že je vybraná práve vytvorená konfigurácia a projekt spustíme skratkou <tt>Shift + F10</tt>.

Viac sa o konfiguráciách behu možno dočítať [https://www.jetbrains.com/help/idea/run-debug-configuration.html tu].

== Skompilovanie a spustenie programu v JavaFX ==

Ukážeme si teraz, ako z príkazového riadku a v IntelliJ IDEA skompilovať a spustiť nasledujúcu triedu pracujúcu s JavaFX, ktorá by mala zobraziť okno s titulkom <tt>Hello, World!</tt>. Táto trieda musí byť uložená v súbore <tt>HelloFX.java</tt>.

<syntaxhighlight lang="java">import javafx.application.*;
import javafx.stage.*;
import javafx.scene.*;
import javafx.scene.layout.*;

public class HelloFX extends Application {
    @Override
    public void start(Stage primaryStage) {
        Pane pane = new Pane();
        Scene scene = new Scene(pane, 300, 250);
        
        primaryStage.setTitle("Hello, World!");
        primaryStage.setScene(scene);
        primaryStage.show();
    }
    
    public static void main(String[] args) {
        launch(args);
    }
}
</syntaxhighlight>

V nasledujúcom <tt><cesta k lib></tt> odkazuje na cestu k adresáru <tt>lib</tt> rozbaleného ZIP archívu JavaFX, o ktorej sme sa už zmienili vyššie. Viac detailov možno nájsť [https://openjfx.io/openjfx-docs/ tu].

=== Z príkazového riadku ===

# Nastavíme sa do priečinku obsahujúceho súbor <tt>HelloFX.java</tt>.
# Triedu skompilujeme príkazom
<pre>
javac --module-path <cesta-k-lib> --add-modules javafx.controls,javafx.fxml HelloFX.java
</pre>
<ol start=3>
<li>Triedu spustíme príkazom</li>
</ol>
<pre>
java --module-path <cesta-k-lib> --add-modules javafx.controls,javafx.fxml HelloFX
</pre>

=== V IntelliJ IDEA ===
# Vytvoríme projekt a v ňom triedu <tt>HelloFX</tt> rovnakým spôsobom ako vyššie (dá sa prípadne vytvoriť aj projekt typu <tt>Java FX</tt>).
# Otvoríme dialóg <tt>File --> Project Structure...</tt>. V ňom otvoríme záložku <tt>Libraries</tt>, klikneme na tlačidlo <tt>+</tt> a zvolíme možnosť <tt>Java</tt>. Otvorí sa dialógové okno umožňujúce vytvoriť knižnicu z priečinka. Za tento priečinok vyberieme priečinok <tt><cesta k lib></tt>.
# Vytvoríme konfiguráciu behu podobným spôsobom ako vyššie. Za hlavnú triedu vyberieme <tt>HelloFX</tt>.
# Klikneme na <tt>Modify options</tt> a zaškrtneme možnosť <tt>Add VM options</tt>.
# Následne by sa malo objaviť políčko <tt>VM options</tt>, do ktorého zadáme
<pre>
--module-path <cesta-k-lib> --add-modules javafx.controls,javafx.fxml
</pre>
<ol start=6>
<li>Dialóg potvrdíme kliknutím na <tt>OK</tt>.</li>
<li>Projekt spustíme klávesovou skratkou <tt>Shift + F10</tt>.</li>
</ol>
=Letný semester, prednáška č. 2=
== Oznamy ==

* Na test pre pokročilých sa v prípade záujmu treba prihlásiť <i>do utorka 23. februára, 11:30</i>.
* Prvú bonusovú úlohu treba odovzdať <i>do stredy 24. februára, 11:30</i>.

== Základné koncepty objektovo orientovaného programovania ==

=== Objekty a triedy ===

Dvoma najzákladnejšími konceptmi objektovo orientovaného programovania (OOP) sú ''triedy'' a ''objekty''.
* ''Trieda'' (angl. ''class'') je typ, ktorý podobne ako <tt>struct</tt> v C/C++ môže združovať údaje rôznych typov. Okrem toho ale obvykle obsahuje aj definície ''metód'' na manipuláciu s týmito údajmi.
* ''Objekt'' (angl. ''object'') je ''inštancia triedy'' &ndash; obsahuje teda už nejakú konkrétnu sadu údajov vyhovujúcu definícii triedy, na ktorú možno aplikovať metódy triedy. 
* Triedu teda možno chápať ako &bdquo;vzor&rdquo;, podľa ktorého sa vytvárajú objekty. 

''Príklad'': nasledujúca trieda <tt>Fraction</tt> reprezentuje zlomky. Obsahuje dve premenné <tt>numerator</tt> a <tt>denominator</tt> zodpovedajúce čitateľu a menovateľu zlomku a metódu na vyhodnotenie zlomku.

<syntaxhighlight lang="java">
public class Fraction {
    int numerator;
    int denominator;

    double evaluate() {
        return (double) numerator / denominator;
    }
}
</syntaxhighlight> 

Inštanciami tejto triedy, t.j. objektmi typu <tt>Fraction</tt>, sú konkrétne realizácie triedy <tt>Fraction</tt> (napr. zlomok s čitateľom 2 a menovateľom 3). O spôsobe ich vytvorenia si povieme o chvíľu. Avšak v prípade, že už máme nejakú inštanciu <tt>fraction</tt> triedy <tt>Fraction</tt> vytvorenú, môžeme hodnotu zlomku vypísať napríklad nasledovne:
<syntaxhighlight lang="java">
Fraction fraction;

// Sem pride vytvorenie instancie triedy Fraction a jej priradenie do premennej fraction.

System.out.println(fraction.evaluate());
</syntaxhighlight> 

''Príklad'': časť triedy reprezentujúcej zásobník implementovaný pomocou poľa (čo je v Jave značne suboptimálne riešenie) by mohla vyzerať napríklad nasledovne.
<syntaxhighlight lang="java">
public class MyStack {
    int data[];
    int count;

    int pop() {
       count--;
       return data[count];
    }

    // Dalsie metody (napr. push) ...
}
</syntaxhighlight>
Ak si opäť odmyslíme vytvorenie samotného zásobníka, môžeme so zásobníkom typu <tt>MyStack</tt> pracovať napríklad takto:
<syntaxhighlight lang="java">
MyStack stack;

// Sem pride vytvorenie zasobnika a napriklad niekolko prikazov push.

int x = s.pop();
</syntaxhighlight>

Neskôr uvidíme, že medzi štandardnými triedami jazyka Java možno nájsť aj množstvo dátových štruktúr a medzi nimi aj triedu <tt>Stack</tt> pre zásobníky. Príklad vyššie je teda iba ilustračný a tvorbe tried podobného druhu je vo všeobecnosti lepšie sa vyvarovať.

''Príklad'': v Jave sú inštancie všetkých typov okrem primitívnych objektmi a samotné tieto typy sú často triedami. S výnimkou veľmi špecifického prípadu polí (o ktorom si viac povieme neskôr) viac-menej pôjde o triedy a objekty v podobe, v akej si ich predstavíme na tejto prednáške.

=== Referencie na objekty ===

Premenná, ktorej typom je trieda, obsahuje ''referenciu'' na objekt, ktorý je inštanciou tejto triedy. 
* Podľa toho sa teda správajú operátory <tt>=</tt> a <tt>==</tt>.
* K premenným a metódam objektu, na ktorý príslušná referencia ukazuje, pristupujeme pomocou operátora <tt>.</tt> a píšeme napríklad <tt>fraction.numerator</tt> alebo <tt>fraction.evaluate()</tt>.
<syntaxhighlight lang="java">
Fraction fraction1, fraction2;

// ...

fraction1 = fraction2;    // Obidve premenne ukazuju na to iste miesto v pamati.
fraction1.numerator = 3;  // Zmeni sa aj hodnota fraction2.numerator.
</syntaxhighlight>
* Do premennej, ktorej typom je trieda, možno priradiť hodnotu <tt>null</tt> &ndash; v takom prípade ide o referenciu, ktorá neukazuje na žiaden objekt.

=== Konštruktory a inicializácia objektov ===

Často je potrebné súčasne s vytvorením objektu vykonať rôzne inicializačné úkony &ndash; napríklad pri zásobníku typu <tt>MyStack</tt> alokovať pole, pri zlomkoch typu <tt>Fraction</tt> inicializovať premenné na vhodné hodnoty, a pod. Na takúto inicializáciu objektov v Jave slúžia špeciálne kusy kódu podobné metódam &ndash; takzvané ''konštruktory''. Volanie konštruktorov je neodmysliteľne späté s vytváraním objektov.
* Názov konštruktora je vždy rovnaký ako názov triedy, ku ktorej patrí (na rozdiel od bežných metód teda ich názov podľa konvencie začína veľkým písmenom).
* ''Do hlavičky konštruktora sa nepíše návratový typ'' (konštruktor žiaden nemá; ''nepíše sa ale ani <tt>void</tt>''). V opačnom prípade pôjde o bežnú metódu (nie o konštruktor), čo môže viesť k pomerne nepríjemným chybám.
* Prípadné argumenty sa zapisujú rovnako ako pri bežných metódach.
* Pre jednu triedu možno definovať aj viacero konštruktorov, ktoré sa však musia líšiť postupnosťou typov argumentov (aby bolo pri volaní jasné, o ktorý z konštruktorov ide).

''Príklad'': pre triedu <tt>Fraction</tt> môžeme napísať napríklad nasledujúce dva konštruktory.

<syntaxhighlight lang="java">
public Fraction() {
    numerator = 0;
    denominator = 1;
}

public Fraction(int num, int denom) { // Neskor uvidime, ze nie je nutne pre argumenty konstruktora a premenne instancie volit ine nazvy
    numerator = num;
    denominator = denom;
}
</syntaxhighlight>
* ''Ak pre triedu nedefinujeme žiaden konštruktor'', automaticky sa vytvorí konštruktor bez parametrov, ktorý v princípe sám o sebe neurobí nič, ale je možné ho zavolať (bez čoho objekt nevytvoríme).

Samotné vytvorenie inštancie triedy sa realizuje pomocou operátora <tt>new</tt>, za ktorým nasleduje volanie niektorého konštruktora.

<syntaxhighlight lang="java">
Fraction f1 = new Fraction();
Fraction f2;
f2 = new Fraction(2, 3);

System.out.println(f1.evaluate());
System.out.println(f2.evaluate());
</syntaxhighlight>

* Operátor <tt>new</tt> dynamicky alokuje pamäť pre objekt, zavolá príslušný konštruktor a vráti referenciu na vytvorený objekt.
* Nie je potrebné starať sa o neskoršie odalokovanie pamäte &ndash; túto úlohu v JVM vykonáva tzv. ''garbage collector''.

Na rozdiel od lokálnych premenných sú premenné inštancií alokované automaticky, a to na hodnoty <tt>0</tt>, <tt>false</tt>, alebo <tt>null</tt> v závislosti od typu premennej. Prípadne je možné niektoré premenné inštancií inicializovať aj explicitne na odlišné hodnoty:

<syntaxhighlight lang="java">
public class Fraction {
    int numerator;        // Inicializuje sa na nulu.
    int denominator = 1;

    // ...
}
</syntaxhighlight>

Alternatívne možno premenné inicializovať v rámci konštruktora, rovnako ako v jednom z vyššie uvedených príkladov. Pri vytváraní inštancie triedy pomocou operátora <tt>new</tt> sa jednotlivé procesy vykonajú v nasledujúcom poradí:
* Najprv sa vykoná automatická alebo explicitná inicializácia premenných (a to aj v prípade, že nebol definovaný žiaden konštruktor triedy a je tak volaný jej východzí konštruktor bez parametrov).
* Až následne sa spustí volaný konštruktor.

=== Kľúčové slovo <tt>this</tt> ===

V rámci (nestatických) metód a konštruktorov tried možno používať kľúčové slovo <tt>this</tt>, ktoré sa pre každú inštanciu tejto triedy interpretuje ako ''referencia na seba'', t.j. na objekt, na ktorom bola metóda obsahujúca toto kľúčové slovo volaná. Kľúčové slovo <tt>this</tt> sa používa predovšetkým nasledujúcimi troma spôsobmi:
* Pre ľubovoľnú premennú <tt>premenna</tt> alebo metódu <tt>metoda</tt> inštancie triedy možno na prístup k tejto premennej resp. metóde použiť zápis <tt>this.premenna</tt> resp. <tt>this.metoda</tt>. Často sú teda tieto zápisy ekvivalentné kratším zápisom <tt>premenna</tt> resp. <tt>metoda</tt>. Niekedy sa však môže stať, že sa niektorá premenná inštancie prekryje napríklad argumentom alebo lokálnou premennou s rovnakým názvom. V takom prípade možno k premennej inštancie pristúpiť iba prostredníctvom <tt>this.premenna</tt>. Naša trieda <tt>Fraction</tt> by teda napríklad mohla vyzerať aj takto:
<syntaxhighlight lang="java">
public class Fraction {
    int numerator;
    int denominator = 1;

    public Fraction() {

    }

    public Fraction(int numerator, int denominator) {
        this.numerator = numerator;
        this.denominator = denominator;
    }

    public double evaluate() {
        return (double) numerator / denominator;
    }
}
</syntaxhighlight>
* Kľúčové slovo <tt>this</tt> možno využiť aj na predanie danej inštancie ako argument nejakej metódy.
<syntaxhighlight lang="java">
public class Fraction {
    // ... 

    @Override                      // Tuto znacku si zatial nevsimajme, kod by fungoval aj bez nej.
    public String toString() {
        return numerator + " / " + denominator;
    }

    public void print() {
        System.out.println(this);  // Rovnake spravanie ako s argumentom toString() resp. this.toString().
    }
}
</syntaxhighlight>
* Na ''prvom riadku konštruktora'' možno pomocou <tt>this( ... )</tt> zavolať iný konštruktor tej istej triedy. Často napríklad potrebujeme spraviť niektoré úkony pri inicializácii objektu vždy, t.j. v ľubovoľnom konštruktore, zatiaľ čo iné sú žiadúce iba v niektorých konštruktoroch. V takom prípade by z návrhového hľadiska nebolo rozumné opakovať spoločné časti kódu v každom z konštruktorov. (Čo sa stane v prípade, keď v tomto kóde bude treba niečo zmeniť?) Namiesto toho je vhodnejšie v &bdquo;pokročilejších&rdquo; konštruktoroch zavolať nejaký &bdquo;menej pokročilý&rdquo; konštruktor (ale iba na prvom riadku).
<syntaxhighlight lang="java">
public class Circle {
    double centerX = 0; // Netreba explicitnu inicializaciu, ale moze to byt prehladnejsie
    double centerY = 0; // Netreba explicitnu inicializaciu, ale moze to byt prehladnejsie
    double radius = 1;
    
    public Circle() {
        System.out.println("Vytvaram kruh.");
    }   
    
    public Circle(double centerX, double centerY) {
        this();                  
        this.centerX = centerX;
        this.centerY = centerY;
    }
    
    public Circle(double centerX, double centerY, double radius) {
        this(centerX, centerY);
        this.radius = radius;
    }
}
</syntaxhighlight>

Občas ale môže byť užitočné použiť kľúčové slovo <tt>this</tt> aj iným spôsobom, napríklad vrátiť <tt>this</tt> na výstupe.

=== Modifikátory prístupu ===

Premenným a metódam, ako aj triedam samotným, možno v Jave nastavovať tzv. ''modifikátory prístupu'' určujúce viditeľnosť týchto súčastí z iných tried. Modfikátory prístupu sú v Jave štyri:
* <tt>private</tt>: k premennej alebo metóde možno pristúpiť iba v rámci jej triedy; na triedy sa tento modifikátor použiť nedá.
* (žiadny modifikátor): premenná, metóda, alebo trieda je viditeľná len v rámci jej balíka.
* <tt>protected</tt>: podobné ako v predchádzajúcom prípade; rozdiel uvidíme na budúcej prednáške.
* <tt>public</tt>: premennú, metódu, alebo triedu možno použiť z ľubovoľnej triedy.

Každá trieda <tt>Trieda</tt> s modifikátorom <tt>public</tt> musí byť uložená v zdrojovom súbore, ktorého názov musí byť <tt>Trieda.java</tt>. Názvy tried s inými modifikátormi prístupu sa nemusia zhodovať s názvom súboru a jeden zdrojový súbor môže obsahovať aj viacero tried (najviac jedna z nich však môže byť <tt>public</tt>, pričom v takom prípade sa názov tejto triedy musí zhodovať s názvom súboru). Za dobrú prax sa ale považuje pre ''každú'' triedu vytvoriť samostatný súbor, ktorého názov sa zhoduje s názvom triedy.

Ako sme už spomenuli na minulej prednáške, modifikátor prístupu statickej metódy <tt>main</tt> musí byť vždy <tt>public</tt>.

== Zapuzdrenie ==

Jedným z hlavných metodických princípov objektovo orientovaného programovania je ''zapuzdrenie'' (angl. ''encapsulation''). Ide o &bdquo;zabalenie&rdquo; dát a metód na manipuláciu s nimi do spoločného &bdquo;puzdra&rdquo; &ndash; inštancie nejakej triedy. 
* Kód z iných tried by mal s dátami &bdquo;zabalenými&rdquo; v objekte manipulovať iba pomocou jeho metód na to určených.
* To sa obvykle zabezpečí tak, že sa modifikátor <tt>public</tt> priradí iba tým metódam, ktoré sú určené na použitie &bdquo;zvonka&rdquo;. Premenným a pomocným metódam sa priradí iný modifikátor, napríklad <tt>private</tt>.
* Verejné metódy tak tvoria akúsi &bdquo;sadu nástrojov&rdquo;, ktorú trieda poskytuje iným triedam na prácu s jej inštanciami. Napríklad trieda pre zásobník by mohla mať (okrem konštruktora) verejné metódy <tt>push</tt>, <tt>pop</tt>, <tt>isEmpty</tt> a <tt>peek</tt>, pričom jej premenné a prípadné pomocné metódy by boli súkromné.
* Výhodou tohto prístupu je, že možno zmeniť vnútornú implementáciu triedy bez toho, aby to nejako ovplyvnilo ostatné triedy. Jediné, čo musí zostať zachované, je správanie verejných funkcií (čo zvyčajne ide zariadiť aj pri zmenenej implementácii zvyšku triedy). Napríklad v triede pre zásobník by sme mohli namiesto poľa použiť spájaný zoznam a zvyšné triedy by to nijak neovplyvnilo.
* Zapuzdrenie tak umožňuje rozdeliť projekt na relatívne nezávislé logické celky s dobre definovaným rozhraním.

=== Metódy <tt>get</tt> a <tt>set</tt> ===

Premenné inštancií tried sú teda zvyčajne súkromné. Existujú však prípady, keď je opodstatnené k niektorým z nich umožniť prístup aj iným triedam. Napríklad v našom príklade so zlomkami by sa v prípade nemožnosti pristúpiť k čitateľu alebo k menovateľu zlomku podstatne obmedzila funkcionalita triedy <tt>Fraction</tt>. Obvyklé riešenie takýchto situácií je ponechať samotnú premennú súkromnú, ale poskytnúť verejné metódy na čítanie a zmenu hodnoty tejto premennej. Takéto metódy pre premennú <tt>hodnota</tt> sa zvyknú konvenčne pomenúvať ako <tt>getHodnota</tt> a <tt>setHodnota</tt>. Podstatná časť našej triedy <tt>Fraction</tt> by tak mohla vyzerať napríklad nasledovne:

<syntaxhighlight lang="java">
public class Fraction {
    private int numerator;
    private int denominator = 1;

    public Fraction() {

    }

    public Fraction(int numerator, int denominator) {
        this.numerator = numerator;
        this.denominator = denominator;
    }

    public int getNumerator() {
        return numerator;
    }

    public void setNumerator(int numerator) {
        this.numerator = numerator;
    }

    public int getDenominator() {
        return denominator;
    }

    public void setDenominator(int denominator) {
        this.denominator = denominator;
    }

    public double evaluate() {
        return (double) numerator / denominator;
    }
}
</syntaxhighlight>
* Určite nie je vhodné bezmyšlienkovite vytvárať metódy <tt>get</tt> a <tt>set</tt> pre všetky premenné. Opodstatnené to je iba vtedy, keď je daná premenná podstatnou charakteristikou triedy navonok, t.j. pokiaľ prístup k nej môže byť zaujímavý aj v prípade, že sa na samotnú triedu pozeráme ako na &bdquo;čiernu skrinku&rdquo;.

Výhody použitia metód <tt>get</tt> a <tt>set</tt> oproti použitiu verejných premenných sú napríklad nasledujúce:
* Môžeme poskytnúť iba metódu <tt>get</tt>. Tým sa premenná stane &bdquo;určenou iba na čítanie&rdquo;. Ak by sme napríklad v našej triede <tt>Fraction</tt> zmazali metódy <tt>setNumerator</tt> a <tt>setDenominator</tt>, dostali by sme triedu reprezentujúcu nemodifikovateľné zlomky (podobne ako napríklad <tt>String</tt> reprezentuje nemodifikovateľné reťazce).
* V rámci metódy <tt>set</tt> možno kontrolovať, či sa do premennej ukladá rozumná hodnota. Napríklad metóda <tt>setDenominator</tt> vyššie by mohla vyhodiť výnimku (ešte nevieme ako) v prípade, že by sme sa pokúsili nastaviť menovateľ na nulu.
* Metódy <tt>get</tt> a <tt>set</tt> nemusia presne korešpondovať s premennými, a teda môžu ostať zachované aj po zmene vnútornej reprezentácie triedy. Uvažujme napríklad podstatnú časť našej triedy <tt>Circle</tt> z príkladu vyššie, v ktorej premenné nastavíme na súkromné a pridáme metódy <tt>get</tt>.
<syntaxhighlight lang="java">
public class Circle {
    private double centerX = 0; 
    private double centerY = 0; 
    private double radius = 1;
    
    public double getCenterX() {
        return centerX;
    }
    
    public void setCenterX(double centerX) {
        this.centerX = centerX;
    }

    public double getCenterY() {
        return centerY;
    }

    public void setCenterY(double centerY) {
        this.centerY = centerY;
    }
    
    public double getRadius() {
        return radius;
    }
    
    public void setRadius(double radius) {
        this.radius = radius;
    }

    // ...
}
</syntaxhighlight>
: Predpokladajme, že sa rozhodneme kruh reprezentovať namiesto jeho stredom a polomerom napríklad jeho stredom a ľubovoľným bodom na jeho hranici (čo je tiež jednoznačná reprezentácia kruhu). V takom prípade určite nie je dobré ponechať aj premennú <tt>radius</tt>, pretože by sme v celej triede museli zabezpečiť jej konzistenciu s premennými pre bod na hranici kruhu, a to by mohlo byť potenciálnym zdrojom chýb. Keby sme teda polomer ostatným triedam zverejňovali priamo ako premennú, spôsobila by naša malá zmena v implementácii triedy <tt>Circle</tt> nutnosť zmeny aj vo všetkých triedach s triedou <tt>Circle</tt> pracujúcich, čo je známkou zlého návrhu. Metódy <tt>getRadius</tt> a <tt>setRadius</tt> však ľahko prerobíme tak, aby pracovali zmysluplným spôsobom aj pri novom spôsobe reprezentácie kruhu.
<syntaxhighlight lang="java">
public class Circle {
    private double centerX = 0;
    private double centerY = 0;
    private double boundaryPointX = 1;
    private double boundaryPointY = 0;

    private double distance(double aX, double aY, double bX, double bY) {
        return Math.sqrt((aX - bX) * (aX - bX) + (aY - bY) * (aY - bY));
    }

    public double getRadius() {
        return distance(centerX, centerY, boundaryPointX, boundaryPointY);
    }

    public void setRadius(double radius) {
        double currentRadius = getRadius();
        boundaryPointX = centerX + (boundaryPointX - centerX) * radius / currentRadius;
        boundaryPointY = centerY + (boundaryPointY - centerY) * radius / currentRadius;
    }

    // ...
}
</syntaxhighlight>
: Možnosť takéhoto zmysluplného prerobenia metódy <tt>get</tt> alebo <tt>set</tt> je ale do veľkej miery daná tým, že polomer je prirodzeným parametrom kruhu; stále teda platí, že metódy <tt>get</tt> a <tt>set</tt> treba implementovať s mierou. Pokiaľ ide o zvyšok triedy, zmena reprezentácie kruhu by si pravdepodobne vyžadovala pridanie nových konštruktorov (hoci možno polomer vypočítať z bodu na hranici kruhu, opačne by to bolo minimálne nejednoznačné; po úprave teda trieda reprezentuje viac informácií a bolo by preto vhodné pridať konštruktor umožňujúci bod na hranici kruhu pri jeho vytvorení zadať). Konštruktor na báze polomeru, opísaný v týchto poznámkach vyššie, však nie je potrebné mazať &ndash; jeho nová implementácia by napríklad mohla využívať metódu <tt>setRadius</tt>.

== Preťažovanie metód ==

Podobne ako môže mať trieda viacero konštruktorov, môže obsahovať aj viacero metód s rovnakým názvom. Podmienkou aj tu je, aby mali metódy s rovnakými názvami rôzne postupnosti typov argumentov (t. j. rôzne signatúry). Takéto vytváranie viacerých metód s rovnakým názvom sa nazýva ich ''preťažovaním'' (angl. ''overloading'').

''Príklad:''
<syntaxhighlight lang="java">
public class Circle {
    
    public void draw() {
        // ...
    }
    
    public void draw(String color) {
        // ...
    }
    
    public void draw(int r, int g, int b) {
        // ...
    }
    
    public void draw(String color, int penWidth) {
        // ...
    }

    public void draw(int r, int g, int b, int penWidth) {
        // ...
    }
    
    // ...
}    
</syntaxhighlight>

''(Veľmi ľahké) cvičenie'': nájdite príklady preťažovania metód v štandardných triedach jazyka Java.

== Statické vs. nestatické metódy a premenné ==

Doposiaľ sme sa na tejto prednáške zaoberali výhradne metódami a premennými ''inštancií'', t.j. ''nestatickými'' metódami a premennými. Na minulej prednáške sme naopak tvorili ''statické'' metódy a podobne možno definovať aj statické ''premenné'' &ndash; statickosť pritom znamená, že nepôjde o metódy resp. premenné ''inštancií'', ale o metódy resp. premenné samotných tried, ktoré sa v mnohom správajú ako bežné funkcie a globálne premenné, ako ich poznáme z minulého semestra.
Statickú metódu alebo premennú definujeme pomocou modifikátora <tt>static</tt>; bez jeho použitia sa metóda alebo premenná považuje za nestatickú.

V jednej triede možno kombinovať statické metódy a premenné s nestatickými. 
* Nestatické prvky príslušia inštanciám tejto triedy a statické samotnej triede.
* Uvažujme teda napríklad triedu <tt>Trieda</tt>, jej inštanciu <tt>instancia</tt>, statickú metódu <tt>public static void statickaMetoda()</tt> a nestatickú metódu <tt>public void nestatickaMetoda()</tt>. Potom možno písať <tt>instancia.nestatickaMetoda()</tt> a <tt>Trieda.statickaMetoda()</tt>, zápis <tt>Trieda.nestatickaMetoda()</tt> ale nedáva zmysel a nemal by sa používať ani zápis <tt>instancia.statickaMetoda()</tt> (hoci technicky je ekvivalentný zápisu <tt>Trieda.statickaMetoda()</tt>).
* Zo statických metód (v statickom kontexte) nemôžeme pristupovať k nestatickým premenným a volať nestatické metódy.
* Z nestatických metód môžeme pristupovať ako k nestatickým prvkom (ktoré sa týkajú príslušnej inštancie), tak aj k prvkom statickým (ktoré sa týkajú triedy samotnej).

''Príklad 1'':
<syntaxhighlight lang="java">
public class Trieda {

    static int a = 1;
    int b = 2;

    static void f() {
        System.out.println("Som staticka funkcia f.");
    }

    void g() {
        System.out.println("Som nestaticka funkcia g.");
    }

    public static void main(String[] args) {
        f();
        Trieda.f();     // To iste ako na predchadzajucom riadku, ale pouzitelne aj z inych tried.
        Trieda instancia = new Trieda();
        instancia.g();
        
        instancia.f();  // To iste ako iba f(), ale IDE O VELMI SKAREDY ZAPIS, pretoze f je staticka a "patri" triede
        // g();         // Chyba: non-static method g() cannot be referenced from a static context

        System.out.println(a);
        System.out.println(instancia.b);
    }
}
</syntaxhighlight>
''Príklad 2'': v Jave neskôr narazíme na situácie, keď je potrebné za každých okolností pracovať s objektmi. Aj za týmto účelom Java definuje špeciálne ''&bdquo;baliace&rdquo; triedy'' (angl. ''wrapper classes'') pre všetky hodnoty primitívnych typov, na ktoré sa možno pozerať ako na &bdquo;primitívne typy zabalené do objektov&rdquo;. &bdquo;Baliaca&rdquo; trieda pre typ <tt>int</tt> má názov <tt>Integer</tt>, pre typ <tt>char</tt> má názov <tt>Character</tt> a pre ostatné primitívne typy ide o názov daného typu, avšak s veľkým začiatočným písmenom.

V Jave funguje automatická konverzia medzi primitívnymi typmi a príslušnými &bdquo;baliacimi&rdquo; triedami, tzv. ''boxing'' a ''unboxing''. Možno teda písať napríklad
<syntaxhighlight lang="java">
Integer i1 = 1;
int i2 = 2;
i1 = i2; // boxing
i2 = i1; // unboxing
</syntaxhighlight>
''Avšak pozor'': operátory <tt>==</tt> a <tt>!=</tt> síce možno použiť na porovnanie &bdquo;zabaleného&rdquo; celého čísla typu <tt>Integer</tt> s &bdquo;nezabaleným&rdquo; celým číslom typu <tt>int</tt>, avšak pri aplikácii na dva objekty <tt>i,j</tt> typu <tt>Integer</tt> sa, rovnako ako pri ľubovoľnej inej dvojici objektov, porovnávajú referencie. Správne sa porovnanie týchto hodnôt realizuje napríklad prostredníctvom <tt>i.equals(j)</tt>.

[https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/Integer.html Pohľad do dokumentácie triedy <tt>Integer</tt>] ukazuje, že táto trieda obsahuje tri metódy <tt>toString</tt> konvertujúce celé čísla na reťazce:
<syntaxhighlight lang="java">public String toString();
public static String toString(int i);
public static String toString(int i, int radix);
</syntaxhighlight>
Prvá z týchto metód je nestatická a možno ju teda aplikovať na inštancie triedy <tt>Integer</tt>:
<syntaxhighlight lang="java">Integer n = 42;
String s = n.toString(); // s teraz obsahuje textovu reprezentaciu cisla n
</syntaxhighlight>
Druhá z nich je naopak statická a ako parameter berie celé číslo, ktoré prevedie na reťazec:
<syntaxhighlight lang="java">int n = 42;
String s = Integer.toString(n); // s teraz obsahuje textovu reprezentaciu cisla n
</syntaxhighlight>
Posledná je tiež statická; ako parameter berie okrem čísla aj základ pozičnej číselnej sústavy a výsledný reťazec bude reprezentáciou daného čísla v sústave o danom základe:
<syntaxhighlight lang="java">int n = 42;
String s = Integer.toString(n, 12); // s teraz obsahuje textovu reprezentaciu cisla n v dvanastkovej sustave
</syntaxhighlight>

== Odkazy ==

* [http://docs.oracle.com/javase/tutorial/java/javaOO/index.html Tutoriál jazyka Java: Classes and Objects]
=Letný semester, prednáška č. 3=
== Oznamy ==

* Dnes po prednáške bude zverejnené zadanie prvej domácej úlohy, ktorej riešenia bude potrebné odovzdať najneskôr ''do pondelka 15. marca, 9:00'' (čiže do začiatku piatej prednášky).

==Opakovanie: triedy a objekty==
* ''Objekt'' je predovšetkým súborom rôznych dát a metód na manipuláciu s nimi. Na objekty sa odkazuje pomocou ich identifikátorov, ktoré sú ''referenciami'' na ich &bdquo;pamäťové adresy&rdquo;.
* Každý objekt je ''inštanciou'' nejakej ''triedy'' (angl. ''class''). Triedu možno chápať ako &bdquo;vzor&rdquo;, podľa ktorého sa vytvárajú objekty. Trieda tiež reprezentuje typ jej objektov.
* Trieda sa teda podobá na <tt>struct</tt> z jazykov C a C++ v tom, že môže obsahovať niekoľko hodnôt rôznych typov. Ide však o omnoho bohatší koncept &ndash; môže obsahovať metódy (funkcie) na prácu s dátami uloženými v inštancii danej triedy, umožňuje nastaviť viditeľnosť jednotlivých premenných a metód pomocou ''modifikátorov'', atď. 
* ''Konštruktory'' sú špeciálne kusy kódu slúžiace na vytvorenie objektu (inštancie triedy). 
* Základným princípom objektovo orientovaného programovania je ''zapuzdrenie'' (angl. ''encapsulation''): spojenie dát a súvisiaceho kódu do koherentného logického celku. 
** Trieda väčšinou navonok ukazuje iba vhodne zvolenú časť metód. 
** Premenné a pomocné metódy sú skryté &ndash; je ich tak možné meniť bezo zmeny kódu využívajúceho triedu.

== Dedenie ==
Trieda môže byť podtriedou inej triedy. Napríklad trieda <tt>Pes</tt> môže byť podtriedou všeobecnejšej triedy <tt>Zviera</tt>: každý objekt, ktorý je inštanciou triedy <tt>Pes</tt> je potom súčasne aj inštanciou triedy <tt>Zviera</tt>. 
Tento vzťah medzi triedami vyjadrujeme kľúčovým slovom <tt>extends</tt> v definícii triedy: píšeme teda napríklad 
<syntaxhighlight lang="java">
class Pes extends Zviera { 
    ...
}
</syntaxhighlight>
Hovoríme tiež, že trieda <tt>Pes</tt> ''dedí'' od triedy <tt>Zviera</tt>, alebo že trieda <tt>Pes</tt> triedu <tt>Zviera</tt> ''rozširuje''. V prípade vhodne zvolených prístupových modifikátorov (detaily neskôr) totiž inštancia triedy <tt>Pes</tt> zdedí metódy a premenné (nie konštruktory) definované v triede <tt>Zviera</tt> a tie sa potom správajú tak, ako keby boli priamo definované aj v triede <tt>Pes</tt>.

Dedenie umožňuje vyhnúť sa nutnosti písať podobný kód viackrát. Namiesto implementácie podobných metód v niekoľkých triedach možno vytvoriť nadtriedu týchto tried a spoločné časti kódu presunúť tam.

===Príklad===
Uvažujme triedy reprezentujúce rôzne geometrické útvary, ktoré môžeme posúvať v rovine. Takto by mohli vyzerať časti tried bez dedenia:

<syntaxhighlight lang="java">
public class Rectangle {
    private double x, y;           // Suradnice laveho horneho rohu
    private double width, height;  // Vyska a sirka obdlznika

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public void move(double deltaX, double deltaY) {
        x += deltaX;
        y += deltaY;
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Circle {
    private double x, y;    // Suradnice stredu
    private double radius;  // Polomer kruznice

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public void move(double deltaX, double deltaY) {
        x += deltaX;
        y += deltaY;
    }
}
</syntaxhighlight>

Vidíme, že obidve triedy obsahujú pomerne veľa spoločného kódu. Teraz to isté s dedením &ndash; spoločné premenné a metódy presunieme do spoločnej nadtriedy <tt>Shape</tt>:
<syntaxhighlight lang="java">
public class Shape {
    private double x, y;  // Suradnice nejakeho vyznacneho bodu geometrickeho utvaru

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }

    public void move(double deltaX, double deltaY) {
        x += deltaX;
        y += deltaY;
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Rectangle extends Shape {
    private double width, height;

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    // Pripadne dalsie metody pre obdlznik
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Circle extends Shape {
    private double radius;

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    // Pripadne dalsie metody pre kruznicu
}

</syntaxhighlight>

V rámci triedy možno používať aj verejné metódy a premenné nadtriedy, ako keby boli jej vlastné &ndash; a často aj metódy a premenné s inými modifikátormi rôznymi od <tt>private</tt> (o tom neskôr). V metódach a konštruktoroch triedy <tt>Circle</tt> tak napríklad môžeme používať metódy <tt>getX</tt>, <tt>setX</tt>, <tt>getY</tt>, <tt>setY</tt> a <tt>move</tt>.

<syntaxhighlight lang="java">
class Rectangle extends Shape {
    // ...
    
    public Rectangle(double x, double y, double width, double height) {
        setX(x);
        setY(y);
        setWidth(width);
        setHeight(height);
    }

    // ...
}
</syntaxhighlight>

<syntaxhighlight lang="java">
class Circle extends Shape {
    // ...
    
    public Circle(double x, double y, double radius) {
        setX(x);
        setY(y);
        setRadius(radius);
    }
    
    @Override                    // Vyznam tejto znacky si vysvetlime o chvilu
    public String toString() {
        return "Stred: [" + getX() + "," + getY() + "]; Polomer: " + getRadius() + ".";
    }

    // ...
}
</syntaxhighlight>

* Inštanciu <tt>c</tt> triedy <tt>Circle</tt> teraz môžeme nielen vypísať na konzolu cez <tt>System.out.println(c)</tt> (použije sa metóda <tt>toString</tt>), ale môžeme pre ňu zavolať aj ľubovoľnú metódu triedy <tt>Shape</tt>, napríklad <tt>c.move(1, 1)</tt> alebo <tt>c.setX(2)</tt>.

===Dedenie a typy===

* Premenná typu <tt>Shape</tt> môže obsahovať referenciu na objekt triedy <tt>Shape</tt> alebo jej ľubovoľnej podtriedy. Vždy teda treba rozlišovať medzi ''typom referencie'' (premennej obsahujúcej referenciu na objekt) a samotným ''typom objektu'': 
<syntaxhighlight lang="java">
Circle circle = new Circle(0, 0, 5);
Shape shape = circle;     // toto je korektne priradenie
// circle = shape;        // toto neskompiluje, kedze shape nemusi byt kruznica
circle = (Circle) shape;  // po pretypovani to uz skompilovat pojde; ak shape nie je instanciou Circle alebo null, vyhodi sa vynimka
</syntaxhighlight>

* Istejší prístup je pri priraďovaní premennej typu <tt>Shape</tt> do premennej typu <tt>Circle</tt> najprv overiť, či premenná typu <tt>Shape</tt> obsahuje referenciu na inštanciu triedy <tt>Circle</tt>. Na to slúži operátor <tt>instanceof</tt>. Platí pritom, že ak je objekt inštanciou nejakej triedy, je súčasne aj inštanciou ľubovoľnej jej nadtriedy (samotný typ objektu je však daný iba najnižšou triedou v tomto usporiadaní). Napríklad podmienka <tt>shape instanceof Shape</tt> je splnená kedykoľvek je splnená podmienka <tt>shape instanceof Circle</tt>. Pre ľubovoľnú triedu <tt>Trieda</tt> má výraz <tt>null instanceof Trieda</tt> vždy hodnotu <tt>false</tt> (a rovnako pre premennú obsahujúcu <tt>null</tt>).
<syntaxhighlight lang="java">
if (shape instanceof Circle) {  
    circle = (Circle) shape;
}
</syntaxhighlight>

* Vďaka tejto črte možno rôzne typy útvarov spracúvať tým istým kódom. Napríklad nasledujúca funkcia dostane pole útvarov (môžu v ňom byť útvary rôznych typov) a posunie každý z nich o daný vektor (<tt>deltaX</tt>, <tt>deltaY</tt>):

<syntaxhighlight lang="java">
public static void moveAll(Shape[] shapes, double deltaX, double deltaY) {
    for (Shape x : shapes) {
        x.move(deltaX, deltaY);
    }
}
</syntaxhighlight>

* ''Cvičenie'': čo vypíše nasledujúci kód?
<syntaxhighlight lang="java">
Shape[] shapes = new Shape[2];
shapes[0] = new Rectangle(0, 0, 1, 2);
shapes[1] = new Circle(0, 0, 1);

moveAll(shapes, 2, 2);

for (Shape x : shapes) {
    if (x instanceof Circle) {
        System.out.println("Je to kruh.");
        Circle c = (Circle) x;  // O chvilu uvidime, ze toto pretypovanie kvoli nasledujucemu riadku nie je nutne
        System.out.println(c);
    }
    if (x instanceof Shape) {
        System.out.println("Je to utvar.");
    }
}
</syntaxhighlight>

===Dedenie a konštruktory===

* Typickou úlohou konštruktora je správne nainicializovať objekt.
* Pri dedení si väčšinou každá trieda inicializuje &bdquo;svoje&rdquo; premenné.
* Napríklad krajší spôsob realizácie konštruktorov pre geometrické útvary je nasledovný: <tt>Shape</tt> inicializuje <tt>x</tt> a <tt>y</tt>, pričom napríklad <tt>Circle</tt> nechá inicializáciu <tt>x</tt> a <tt>y</tt> na <tt>Shape</tt> a inicializuje už len <tt>radius</tt>.
* Prvý príkaz konštruktora môže pozostávať z volania konštruktora predka pomocou kľúčového slova <tt>super</tt> (z angl. ''superclass'', t.j. nadtrieda).
<syntaxhighlight lang="java">
public class Shape {
    // ...    

    public Shape(double x, double y) {
        this.x = x; // alebo setX(x);
        this.y = y; // alebo setY(y);
    }
    
    // ...
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Rectangle extends Shape {
    // ...
    
    public Rectangle(double x, double y, double width, double height) {
        super(x, y);
        this.width = width;   // alebo setWidth(width);
        this.height = height; // alebo setHeight(height);
    }
    
    // ...
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Circle extends Shape {
    // ...         
    
    public Circle(double x, double y, double radius) {
        super(x, y);
        this.radius = radius; // alebo setRadius(radius);
    }
    
    // ...
}
</syntaxhighlight>
* Ak nezavoláme konštruktor nadtriedy ručne, automaticky sa zavolá konštruktor bez parametrov, t.j. <tt>super()</tt>. To môže pri kompilovaní vyústiť v chybu v prípade, keď nadtrieda nemá definovaný konštruktor bez parametrov (či už explicitne jeho implementáciou, alebo implicitne tým, že sa neuvedie implementácia ''žiadneho'' konštruktora nadtriedy). Napríklad v horeuvedenom príklade je teda volanie konštruktora nadtriedy nutnou podmienkou úspešnej kompilácie. 
* Výnimkou je prípad, keď sa na prvom riadku volá iný konštruktor tej istej triedy pomocou <tt>this(...)</tt> &ndash; vtedy sa volanie konštruktora nadtriedy nechá na práve zavolaný konštruktor.

== Prekrývanie metód a polymorfizmus ==

Podtrieda môže ''prekryť'' (angl. ''override'') niektoré zdedené metódy, aby sa chovali inak ako v predkovi.

Napríklad môžeme mať útvar <tt>Segment</tt> (úsečka), ktorý je zadaný dvoma koncovými bodmi a v metóde <tt>move</tt> treba posunúť oba. Metódu z predka môžeme zavolať pomocou <tt>super.move</tt>, ale nemusí to byť na prvom riadku a nemusí byť použitá vôbec:
<syntaxhighlight lang="java">
public class Segment extends Shape {
    private double x2, y2;

    // ...

    public Segment(double x, double y, double x2, double y2) {
        super(x, y);
        this.x2 = x2;
        this.y2 = y2;
    }

    @Override
    public void move(double deltaX, double deltaY) {
        super.move(deltaX, deltaY);
        x2 += deltaX;
        y2 += deltaY;
    }
}
</syntaxhighlight>
Anotácia <tt>@Override</tt> je nepovinná, ale odporúčaná. Ide o informáciu pre kompilátor, ktorou sa vyjadruje snaha o prekrytie zdedenej metódy. Ak sa v predkovi nenachádza metóda s rovnakou hlavičkou, kompilátor vyhlási chybu. Tým sa dá predísť obzvlášť nepríjemným chybám. 

S prekrývaním metód súvisí ''polymorfizmus'', pod ktorým sa v programovaní (hlavne pri OOP) rozumie schopnosť metód chovať sa rôzne: 
* S určitou formou polymorfizmu sme sa už stretli, keď sme mali viacero metód s rovnakým menom, avšak s rôznymi typmi parametrov (tzv. ''preťažovanie'' metód, angl. ''overloading'').
* Pri dedení sa navyše môže metóda chovať rôzne v závislosti od triedy, ku ktorej táto metóda patrí.
* To, ktorá verzia metódy sa zavolá, záleží od toho, akého typu je objekt, nie akého typu je referencia naň.
* Takto to ale funguje iba pri nestatických metódach (keďže statické metódy príslušia samotným triedam, rozdiel medzi typom referencie a typom inštancie tam nemožno využiť). Pri statických metódach preto nehovoríme o ich prekrývaní, ale o ich ''skrývaní''.
<syntaxhighlight lang="java">
  Shape s = new Segment(0, 0, 1, -5);
  s.move(1, 1);  // zavola prekrytu metodu z triedy Segment
  s = new Circle(0, 0, 1);
  s.move(1, 1);  // zavola metodu z triedy Shape, lebo v Circle nie je prekryta

  Shape[] shapes = new Shape[3];

  //...

  for(Shape x : shapes) {
      x.move(deltaX, deltaY);  // kazdy prvok pola sa posuva svojou metodou move, ak ju ma
  }
</syntaxhighlight>

Vo všeobecnosti sa pri volaní <tt>o.f(par1,...,parn)</tt> pre objekt <tt>o</tt> typu <tt>T</tt> aplikuje nasledujúci princíp:
* Ak má trieda <tt>T</tt> svoju implementáciu metódy <tt>f</tt> s vhodnými parametrami, vykoná sa táto verzia metódy.
* V opačnom prípade sa vhodná verzia metódy <tt>f</tt> hľadá v nadtriede triedy <tt>T</tt>, v prípade neúspechu v nadtriede nadtriedy <tt>T</tt>, atď.

''Polymorfizus môže byť schovaný aj hlbšie'' &ndash; neprekrytá metóda z predka môže vo svojom tele volať prekryté metódy, čím sa jej správanie mení v závislosti od typu objektu:
<syntaxhighlight lang="java">
public class SuperClass {
    void doX() { 
        System.out.println("doX in Super");
    }
   
    void doXTwice() { 
        doX();
        doX();
    }    
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class SubClass extends SuperClass {
    void doX() { 
        System.out.println("doX in Sub");
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
// v metode main:
SuperClass a = new SubClass();
a.doXTwice();  // vypise 2x doX in Sub
</syntaxhighlight>
Zmysluplnejším príkladom takéhoto správania bude metóda <tt>approximateArea</tt> v príklade nižšie.

== Abstraktné triedy a metódy ==
Aby sa metóda chovala v určitej skupine tried polymorfne, musí byť definovaná v ich spoločnej nadtriede. V tejto nadtriede však nemusí existovať jej zmysluplná implementácia. 
* Uvažujme napríklad metódu <tt>area()</tt>, ktorá zráta plochu geometrického útvaru.
* Pre triedy <tt>Rectangle</tt>, <tt>Circle</tt>, resp. <tt>Segment</tt> je implementácia takejto metódy zrejmá. Zmysluplná implementácia v ich spoločnej nadtriede <tt>Shape</tt> by však bola prinajmenšom problematická.

Vzniknutú situáciu možno riešiť nasledovne:
* Metódu <tt>area()</tt> v triede <tt>Shape</tt>, ako aj triedu <tt>Shape</tt> samotnú, označíme za ''abstraktnú'' modifikátorom <tt>abstract</tt>. 
* Abstraktná metóda pozostáva iba z hlavičky bez samotnej implementácie a je určená na prekrytie v podtriedach (musí ísť o nestatickú metódu). 
* Abstraktná trieda je trieda, ktorá môže obsahovať abstraktné metódy. Zo zrejmých dôvodov z nej nemožno tvoriť inštancie (napríklad v našom príklade by tieto inštancie &bdquo;nevedeli, čo robiť&rdquo; pri volaní metódy <tt>area()</tt>), ale za účelom volania z podtried môže obsahovať definície konštruktorov. Abstraktná trieda slúži iba na dedenie, stále však môže byť typom ''referencie'' na objekt.
* Podtriedy abstraktnej triedy, ktoré nie sú abstraktné, musia implementovať všetky abstraktné metódy svojho predka.

''Príklad'': 
<syntaxhighlight lang="java">
public abstract class Shape {
    // ...
    
    public abstract double area();

    public double approximateArea() {
        return Math.round(area());
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Rectangle extends Shape {
    // ...
    
    @Override
    public double area() {
        return width * height;
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Circle extends Shape {
    // ...
    
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Segment extends Shape {
    // ...
    
    @Override
    public double area() {
        return 0;
    }
}
</syntaxhighlight>

Napríklad program 
<syntaxhighlight lang="java">
public static void main(String[] args) {
    Shape[] shapes = new Shape[3];
    shapes[0] = new Rectangle(0, 0, 1, 2);
    shapes[1] = new Circle(0, 0, 1);
    shapes[2] = new Segment(1, 1, 2, 2);
    
    for (Shape x : shapes) {
        System.out.println(x.area() + " " + x.approximateArea());
    }
}
</syntaxhighlight>
potom vypíše nasledujúci výstup:
<pre>
2.0 2.0
3.141592653589793 3.0
0.0 0.0
</pre>

== Hierarchia tried a trieda Object ==

* V Jave môže každá trieda dediť iba od jednej triedy (na rozdiel od niektorých iných jazykov, kde je možné dedenie od viacerých tried).
* Dedenie je však možné &bdquo;viacúrovňovo&rdquo;:

<syntaxhighlight lang="java">
class Pes extends Zviera {
}

class Civava extends Pes { // Hierarchia tried nemusi verne zodpovedat realite
}
</syntaxhighlight>

* Všetky triedy sú automaticky potomkami triedy [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/Object.html <tt>Object</tt>]; tá sa tiež považuje za priamu nadtriedu tried, ktoré explicitne nerozširujú žiadnu triedu. 
* Trieda <tt>Object</tt> obsahuje metódy &ndash; napríklad <tt>toString</tt> alebo <tt>equals</tt> &ndash; ktoré je často užitočné prekrývať.
* To vysvetľuje, prečo sme pri metóde <tt>toString</tt> triedy <tt>Circle</tt> použili anotáciu <tt>Override</tt>: prekryli sme totiž jej definíciu z triedy <tt>Object</tt>.
* Vypisovanie kružnice <tt>Circle circle</tt> cez <tt>System.out.println(circle)</tt> je zas ukážkou polymorfizmu. Ide tu o použitie verzie metódy <tt>println</tt>, ktorá ako argument očakáva inštanciu triedy <tt>Object</tt> a na výpis používa metódu <tt>toString</tt> tejto inštancie. V prípade, že metódu <tt>println</tt> zavoláme pre inštanciu podtriedy triedy <tt>Object</tt>, použije sa pri výpise prekrytá verzia metódy <tt>toString</tt>.
* Veľmi špeciálnym druhom objektov v Jave sú polia, pričom polia typu <tt>T</tt> (kde <tt>T</tt> je trieda alebo primitívny typ) sa považujú za inštancie triedy <tt>T[]</tt>, ktorá je podtriedou triedy <tt>Object</tt>. Aj na polia teda v princípe možno aplikovať metódu <tt>toString</tt> triedy <tt>Object</tt>, ''avšak od jej použitia nemožno očakávať žiadne rozumné správanie, keďže nebola zmysluplným spôsobom prekrytá''.

== Rozhrania ==

Rozhranie (angl. ''interface'') je podobným konceptom ako abstraktná trieda. Existuje však medzi nimi niekoľko rozdielov, z ktorých najpodstatnejšie sú tieto:
* Rozhranie slúži predovšetkým ako zoznam ''abstraktných'' metód &ndash; kľúčové slovo <tt>abstract</tt> tu netreba uvádzať. Pri triedach implementujúcich rozhranie je garantované, že na prácu s nimi bude možné použiť metódy deklarované v rozhraní (odtiaľ aj termín &bdquo;rozhranie&rdquo;). Napríklad rozhranie pre zásobníky by mohlo deklarovať metódy ako <tt>push</tt>, <tt>pop</tt> a <tt>isEmpty</tt> a triedy pre zásobníky implementované pomocou polí resp. spájaných zoznamov by toto rozhranie mohli implementovať. 
* Naopak implementované metódy musia byť v rozhraní označené kľúčovým slovom <tt>default</tt>, prípadne musia byť statické (obidve tieto možnosti sa však typicky využívajú iba vo veľmi špeciálnych situáciách).
* Rozhranie nemôže definovať konštruktory, ani iné ako finálne premenné (t. j. konštanty).
* Kým od tried sa dedí pomocou kľúčového slova <tt>extends</tt>, rozhrania sa ''implementujú'' pomocou kľúčového slova <tt>implements</tt>. Rozdiel je predovšetkým v tom, že implementovať možno aj viacero rozhraní. Jedno rozhranie môže navyše rozširovať iné (dopĺňať ho o ďalšie požadované metódy): v takom prípade používame kľúčové slovo <tt>extends</tt>.
* Všetky položky v rozhraní sa chápu ako verejné (modifikátor <tt>public</tt> teda nie je potrebné explicitne uvádzať). 
* Podobne ako abstraktná trieda, môže byť aj rozhranie typom referencie.
* Hoci nejde o prekrývanie v pravom slova zmysle, možno aj pri implementovaní metód z rozhraní použiť anotáciu <tt>@Override</tt>.

''Príklad použitia'':

<syntaxhighlight lang="java">
public interface Movable {
    void move(double deltaX, double deltaY);
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public interface Measurable {
    double area();
    double approximateArea();
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public abstract class Shape implements Movable, Measurable {
    // ...

    @Override
    public void move(double deltaX, double deltaY) {
        x += deltaX;
        y += deltaY;
    }

    @Override
    public abstract double area();

    @Override
    public double approximateArea() {
        return Math.round(area());
    }

    // ...
}
</syntaxhighlight>

<syntaxhighlight lang="java">
    public static void main(String[] args) {
        Measurable[] elements = new Shape[3];  // Podobne ako abstraktne triedy mozu byt aj rozhrania typmi referencie
        elements[0] = new Rectangle(0, 0, 1, 2);
        elements[1] = new Circle(0, 0, 1);
        elements[2] = new Segment(1, 1, 2, 2);

        for (Measurable x : elements) {
            System.out.println(x.area() + " " + x.approximateArea());
        }
    }
</syntaxhighlight>

== Prehľad niektorých modifikátorov tried, premenných a metód ==

''Modifikátory prístupu'':
* <tt>public</tt>: triedy, rozhrania a ich súčasti prístupné odvšadiaľ.
* (žiaden modifikátor): viditeľnosť len v rámci balíčka (<tt>package</tt>).
* <tt>protected</tt>: viditeľnosť v triede, jej podtriedach a v rámci balíčka.
* <tt>private</tt>: viditeľnosť len v danej triede (nedá sa aplikovať na triedu samotnú).

''Iné modifikátory'':
* <tt>abstract</tt>: neimplementovaná metóda alebo trieda s neimplementovanými metódami.
* <tt>final</tt>: 
** Ak je trieda <tt>final</tt>, nedá sa z nej ďalej dediť.
** Ak je metóda <tt>final</tt>, nedá sa v podtriede prekryť.
** Ak je premenná alebo parameter <tt>final</tt>, ide o &bdquo;konštantu&rdquo;, ktorú nemožno meniť (možno ju ale inicializovať aj za behu).
* <tt>static</tt>:
** Statické premenné a metódy príslušia triede samotnej, nie jej inštanciám.
** Statické triedy vo vnútri inej triedy nie sú viazané na jej konkrétnu inštanciu (viac neskôr).

== Aritmetický strom s využitím dedenia ==

V minulom semestri sme upozorňovali na návrhový nedostatok pri realizácii aritmetického stromu: niektoré položky uložené v <tt>struct</tt>-och sa využívali len v niektorých uzloch stromu (hodnoty iba v listoch a operátory iba vo vnútorných uzloch). Tomuto sa vieme vyhnúť pomocou dedenia.
* Jednotlivé typy vrcholov budú podtriedy abstraktnej triedy <tt>Node</tt>
* Namiesto použitia príkazu <tt>switch</tt> na typ vrchola tu prekryjeme potrebné funkcie, napríklad <tt>evaluate</tt>.
<syntaxhighlight lang="java">
abstract class Node {
    public abstract int evaluate();
}
</syntaxhighlight>

<syntaxhighlight lang="java">
abstract class NullaryNode extends Node {
}
</syntaxhighlight>

<syntaxhighlight lang="java">
abstract class UnaryNode extends Node {
    private Node child;
    
    public Node getChild() {
        return child;
    }

    public UnaryNode(Node child) {
        this.child = child; 
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
abstract class BinaryNode extends Node {
    private Node left;
    private Node right;

    public Node getLeft() {
        return left;
    }

    public Node getRight() {
        return right;
    }

    public BinaryNode(Node left, Node right) { 
        this.left = left;
        this.right = right; 
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
class Constant extends NullaryNode {
    private int value;
    
    public Constant(int value) { 
        this.value = value;
    }

    @Override 
    public int evaluate() { 
        return value;
    }

    @Override
    public String toString() { 
        return Integer.toString(value);
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
class UnaryMinus extends UnaryNode {
    public UnaryMinus(Node child){
        super(child); 
    }

    @Override 
    public int evaluate() { 
        return -getChild().evaluate();
    }

    @Override 
    public String toString() { 
        return "(-" + getChild().toString() + ")";
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
class Plus extends BinaryNode { 
    public Plus(Node left, Node right) { 
        super(left, right);
    }

    @Override
    public int evaluate() { 
        return getLeft().evaluate() + getRight().evaluate();
    }

    @Override 
    public String toString() { 
        return "(" + getLeft().toString() + "+" + getRight().toString() + ")";
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Expressions {

    public static void main(String[] args) {
        Node expr = new Plus(new UnaryMinus(new Constant(2)),
			     new Constant(3));
        System.out.println(expr);
        System.out.println(expr.evaluate());
    }
}
</syntaxhighlight>

== Odkazy ==

* [http://docs.oracle.com/javase/tutorial/java/javaOO/index.html Java tutoriál: Classes and Objects]
* [http://docs.oracle.com/javase/tutorial/java/IandI/index.html Java tutoriál: Interfaces and Inheritance]
=Letný semester, prednáška č. 4=
== Oznamy ==

* Počas najbližších cvičení, čiže ''v stredu 10. marca od 11:30 do 13:00'' bude prebiehať prvý test. Bude pozostávať z troch úloh zameraných na látku ''z prvých troch týždňov'', ktorých riešenia bude potrebné odovzdávať na testovač. Po dobu riešenia testu je potrebná účasť na stretnutí &bdquo;Cvičenia&rdquo; v MS Teams.
* V stredu tiež budú zverejnené dve nebodované úlohy k štvrtým cvičeniam, zamerané na látku z dnešnej prednášky. Ďalšie podobne zamerané úlohy budú zverejnené na cvičeniach budúci týždeň.
* Prvú domácu úlohu je potrebné odovzdať najneskôr do začiatku budúcej prednášky, čiže ''do pondelka 15. marca, 9:00''.

== Výnimky ==

Mechanizmus ''výnimiek'' (angl. ''exceptions'') slúži v Jave na spracovanie chýb a iných výnimočných udalostí, ktoré môžu počas vykonávania programu nastať. Doposiaľ sme v našich programoch takéto situácie viac-menej ignorovali &ndash; napríklad sme obvykle predpokladali, že vstup vždy spĺňa požadované podmienky, že súbor, z ktorého sa pokúšame čítať, vždy existuje, atď. Dôvodom bola predovšetkým prílišná prácnosť ošetrovania chýb pomocou podmienok a neprehľadnosť programov, ktoré takéto podmienky obsahujú.  

Uvažujme napríklad nasledujúci jednoduchý program, ktorý zo vstupu načíta prirodzené číslo <tt>n</tt> nasledované <tt>n</tt> celými číslami, ktoré postupne poukladá do poľa dĺžky <tt>n</tt>. Následne číta zo vstupu postupnosť indexov v rozmedzí <tt>0</tt> až <tt>n-1</tt> a po každom načítaní indexu <tt>i</tt> zvýši hodnotu <tt>a[i]</tt> o jedna. Načítavanie vstupu sa ukončí po načítaní reťazca <tt>"KONIEC"</tt>.
<syntaxhighlight lang="java">
public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    int a[] = new int[n];
    for (int i = 0; i <= n - 1; i++) {
        a[i] += scanner.nextInt();
    }
    String next = scanner.next();
    while (!next.equals("KONIEC")) {
        a[Integer.parseInt(next)]++;
        next = scanner.next();
    }
}
</syntaxhighlight> 
Vykonávanie tohto programu môže skončiť chybou viacerými rôznymi spôsobmi: používateľ napríklad môže namiesto niektorého čísla zadať nečíselný reťazec; číslo <tt>n</tt> môže ďalej zadať ako záporné, čím vznikne chyba pri pokuse o alokovanie poľa; niektorý z ním zadaných indexov do poľa tiež nemusí byť v požadovanom rozmedzí. Po pokuse o ošetrenie týchto chýb pomocou podmienok dostávame nasledujúci horibilný program.
<syntaxhighlight lang="java">
/** Nasledujuci kod je ukazkou toho, ako sa osetrovanie chyb v Jave NEMA robit. */

/** Metoda, ktora zisti, ci je retazec nebielych znakov reprezentaciou celeho cisla. */
private static boolean isInteger(String s) {
    Scanner stringScanner = new Scanner(s);
    return stringScanner.hasNextInt();
}

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int n = 0;
    if (scanner.hasNextInt()) {
        n = scanner.nextInt();
        if (n < 0) {
            System.err.println("Pocet prvkov pola nemoze byt zaporny.");
            System.exit(2);
        }
    } else {
        System.err.println("Vstup sa nezacina cislom.");
        System.exit(1);
    }
    int a[] = new int[n];
    for (int i = 0; i <= n - 1; i++) {
        if (scanner.hasNextInt()) {
            a[i] += scanner.nextInt();
        } else {
            System.err.println("Niektory z prvkov pola nebol zadany ako cele cislo.");
            System.exit(3);
        }
    }
    String next = scanner.next();
    while (!next.equals("KONIEC")) {
        if (isInteger(next)) {
            int i = Integer.parseInt(next);
            if (i >= 0 && i <= n - 1) {
                a[i]++;
            } else {
                System.err.println("Niektory z indexov do pola je mimo povoleneho rozmedzia.");
                System.exit(5);
            }
        } else {
            System.err.println("Niektory z indexov do pola nebol zadany ako cele cislo.");
            System.exit(4);
        }
        next = scanner.next();
    }
}
</syntaxhighlight>
Vidíme, že už aj pri takto jednoduchej úlohe dostávame pomerne rozsiahly program, v ktorom väčšinu kódu zaberá práve spracovanie chýb. Ešte nepríjemnejšou je však skutočnosť, že ošetrovanie chýb je potrebné implementovať v mieste programu, kde táto chyba vznikla. To vedie k prelínaniu podstatných častí programu s časťami, ktoré slúžia iba na spracovanie chýb, v dôsledku čoho sa kód stáva veľmi neprehľadným. Z uvedených dôvodov sme až doposiaľ podobné chybové udalosti väčšinou ignorovali.

V praxi je ale nutné podobné chyby náležite poošetrovať &ndash; nie je totiž napríklad prípustné, aby textový editor spadol zakaždým, keď sa jeho používateľ pokúsi otvoriť súbor s neexistujúcim názvom. Výnimky poskytujú spôsob, ako spracovanie chybových udalostí realizovať podstatne efektívnejším spôsobom, než v ukážke vyššie. Medzi ich základné prednosti totiž patria:
* Možnosť oddelenia kódu na spracovanie chýb od zvyšku kódu.
* Možnosť jednoduchým spôsobom ponechať spracovanie chyby na volajúcu metódu v prípade, že sa to javí ako vhodnejšie riešenie.
* Možnosť využívať pri spracúvaní chýb prostriedky objektovo orientovaného programovania.

=== Mechanizmus výnimiek v Jave ===

Pod ''výnimkou'' (angl. ''exception'') sa v Jave rozumie inštancia špeciálnej triedy <tt>Exception</tt>, prípadne jej nadtriedy <tt>Throwable</tt>, reprezentujúca nejakú výnimočnú udalosť. Trieda <tt>Exception</tt> má pritom množstvo podtried reprezentujúcich rôzne typy chybových udalostí.   
* Výnimka môže počas vykonávania nejakej metódy <tt>f</tt> vzniknúť buď tak, že ju vyhodí JVM (napríklad pri delení nulou alebo pri prístupe k neexistujúcemu prvku poľa), alebo tak, že ju vyhodí sama táto metóda pomocou príkazu <tt>throw</tt> (detaily nižšie). 
* Vzniknutá výnimka môže byť priamo odchytená a ošetrená v rámci danej metódy <tt>f</tt>. V opačnom prípade je vykonávanie metódy ukončené a výnimka je posunutá metóde <tt>g</tt>, ktorá metódu <tt>f</tt> volala (posunieme sa teda v zásobníku volaní metód o úroveň nižšie).
* V metóde <tt>g</tt> sa na celú situáciu dá pozerať tak, akoby výnimka vznikla pri vykonávaní príkazu, v rámci ktorého sa volala metóda <tt>f</tt>. Opäť teda môže byť výnimka buď odchytená a ošetrená, alebo rovnakým spôsobom predaná metóde, ktorá volala metódu <tt>g</tt> (aj v takom prípade hovoríme, že metóda <tt>g</tt> vyhodila výnimku, hoci reálne výnimka vznikla už v metóde <tt>f</tt>). 
* Takto sa v zásobníku volaní metód pokračuje nižšie a nižšie, až kým je nájdená metóda, ktorá danú výnimku odchytí a spracuje.
* Ak sa takáto metóda na zásobníku volaní nenájde &ndash; čiže je výnimka vyhodená aj metódou <tt>main</tt> na jeho dne &ndash; typicky dôjde k ukončeniu vykonávania programu a k vypísaniu informácií o výnimke (vrátane zásobníka volaní metód) na štandardný chybový výstup; ide tu ale o zjednodušenie.

[[Súbor:Vynimky.png|center]]

=== Chytanie a ošetrovanie výnimiek ===

Odchytenie a spracovanie výnimky možno v Jave realizovať nasledujúcim spôsobom:
* Kód, v ktorom môže výnimka nastať, obalíme do bloku <tt>try</tt>.
* Kód spracúvajúci výnimku umiestnime do bezprostredne nasledujúceho bloku <tt>catch</tt>. Za samotným kľúčovým slovom <tt>catch</tt> nasleduje jeden argument reprezentujúci výnimku, ktorá sa má odchytiť. Napríklad blok <tt>catch (Exception e)</tt> odchytí ľubovoľnú výnimku, ktorá je inštanciou triedy <tt>Exception</tt> (alebo nejakej jej podtriedy).
* Kedykoľvek nastane v bloku <tt>try</tt> výnimka, okamžite sa vykonávanie tohto bloku ukončí. Ak je vzniknutá výnimka kompatibilná s argumentom bloku <tt>catch</tt>, pokračuje sa blokom <tt>catch</tt> a výnimka sa považuje za odchytenú. (Ak výnimka s týmto argumentom nie je kompatibilná, bude správanie rovnaké ako pri absencii bloku <tt>try</tt>.)

''Príklad'': Uvažujme program, ktorý prečíta zo vstupného súboru <tt>vstup.txt</tt> prirodzené číslo <tt>n</tt> a za ním <tt>n</tt> celých čísel. Napokon vypíše na konzolu súčet načítaných čísel. V takomto programe môže nastať výnimka predovšetkým z dvoch dôvodov: súbor <tt>vstup.txt</tt> nemusí existovať alebo môže nastať iná chyba pri pokuse o vytvorenie inštancie triedy <tt>Scanner</tt>; nemusí byť dodržaný požadovaný formát vstupného súboru a môže tak vzniknúť výnimka pri volaní metódy <tt>nextInt</tt> triedy <tt>Scanner</tt>. Kód teda môžeme obaliť do bloku <tt>try</tt> a prípadnú výnimku môžeme spracovať napríklad jednoduchým výpisom textu <tt>"Nieco sa pokazilo."</tt> do štandardného chybového výstupu. Všetok kód nasledujúci za blokom <tt>catch</tt> sa vykoná bez ohľadu na to, či výnimka nastala alebo nenastala.
<syntaxhighlight lang="java">
import java.io.*;
import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner(new File("vstup.txt"));
            int n = scanner.nextInt();
            int sum = 0;
            for (int i = 1; i <= n; i++) {
                sum += scanner.nextInt();
            }
            System.out.println("Sucet je: " + sum + ".");
            scanner.close();
        } catch (Exception e) {
            System.err.println("Nieco sa pokazilo.");
        }
        System.out.println("Aj po odchytenej vynimke pokracujem dalej a vypisem tento text...");
    }
}
</syntaxhighlight>
Namiesto výpisu textu <tt>"Nieco sa pokazilo."</tt> by sme napríklad mohli vypísať aj informácie o vzniknutej výnimke použitím metódy
<syntaxhighlight lang="java">
e.printStackTrace();
</syntaxhighlight>
Uvedené riešenie má ale dva menšie nedostatky:
* V prípade vyhodenia výnimky nikdy nedôjde uzatvoreniu vstupného súboru, pretože vykonávanie bloku <tt>try</tt> sa preruší ešte predtým, než príde na rad príslušný príkaz. O niečo vhodnejšou alternatívou by bolo presunutie príkazu na zatvorenie <tt>scanner</tt>-a až za koniec bloku <tt>try</tt>; ale aj vtedy by sa mohlo stať, že sa tento príkaz nevykoná kvôli nejakej výnimke, ktorá nebola odchytená (napríklad inštancia typu <tt>Throwable</tt>, alebo výnimka vyhodená v bloku <tt>catch</tt>). Riešením je pridať za bloky <tt>catch</tt> blok <tt>finally</tt>, ktorý sa vykoná bez ohľadu na to, či nastala výnimka a či sa nám ju podarilo odchytiť (dokonca sa vykoná aj v prípade, že sa v <tt>try</tt> bloku úspešne vykonal príkaz <tt>return</tt>).
<syntaxhighlight lang="java>
import java.io.*;
import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        Scanner scanner = null;
        try {
            scanner = new Scanner(new File("vstup.txt"));
            int n = scanner.nextInt();
            int sum = 0;
            for (int i = 1; i <= n; i++) {
                sum += scanner.nextInt();
            }
            System.out.println("Sucet je: " + sum + ".");
        } catch (Exception e) {
            System.err.println("Nieco sa pokazilo.");
        } finally {
            if (scanner != null) {
                scanner.close();
            }
        }
        System.out.println("Aj po odchytenej vynimke pokracujem dalej a vypisem tento text...");
    }
}
</syntaxhighlight>
* Nerozlišujeme medzi dvoma najpravdepodobnejšími príčinami vyhodenia výnimky: medzi chybou nejakým spôsobom súvisiacou s manipuláciou so súborom <tt>vstup.txt</tt> a medzi chybou spôsobenou zlým formátom vstupu. To sa dá napraviť s využitím skutočnosti, že výnimky pre rôzne udalosti sú typicky rôzneho typu (vždy ale ide o inštancie podtried <tt>Throwable</tt> a zvyčajne aj <tt>Exception</tt>). V prvom prípade sa vyhodí výnimka, ktorá je inštanciou triedy <tt>IOException</tt> z balíka <tt>java.io</tt> alebo nejakej jej podtriedy (napríklad <tt>FileNotFoundException</tt>). V druhom prípade pôjde o výnimku typu <tt>NoSuchElementException</tt> z balíka <tt>java.util</tt>, vyhodenú metódou <tt>nextInt</tt> triedy <tt>Scanner</tt>. Za blok <tt>try</tt> môžeme pridať aj viacero blokov <tt>catch</tt> pre viacero typov výnimiek. V prípade, že je niektorá výnimka &bdquo;kompatibilná&rdquo; s viacerými takýmito blokmi, bude odchytená prvým z nich.
<syntaxhighlight lang="java">
import java.io.*;
import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        Scanner scanner = null;
        try {
            scanner = new Scanner(new File("vstup.txt"));
            int n = scanner.nextInt();
            int sum = 0;
            for (int i = 1; i <= n; i++) {
                sum += scanner.nextInt();
            }
            System.out.println("Sucet je: " + sum + ".");
        } catch (IOException e) {
            System.err.println("Chyba suvisiaca s pristupom k suboru vstup.txt.");
        } catch (NoSuchElementException e) {
            System.err.println("Zly format vstupneho suboru.");
        } catch (Exception e) {
            // Takto spracovat vynimku, o ktorej nic netusime, nie je uplne najlepsi napad (takze len na ukazku).
            System.err.println("Nejaka ina vynimka.");   
        } finally {
            if (scanner != null) {
                scanner.close();
            }
        }
        System.out.println("Aj po odchytenej vynimke pokracujem dalej a vypisem tento text...");
    }
}
</syntaxhighlight>
* Pokiaľ používateľ zadá číslo <tt>n</tt> ako záporné, správa sa program rovnako ako keby bolo <tt>n</tt> rovné nule. Možno vhodnejšie by ale aj v takom prípade bolo vyhodiť chybu, ktorá by používateľa upozornila na to, že zadal zlý vstup. Túto fukncionalitu doplníme neskôr, pretože budeme potrebovať vedieť hádzať &bdquo;úplne nové&rdquo; výnimky.

=== Hierarchia výnimiek ===

V Jave existuje množstvo tried pre rôzne druhy výnimiek. Malá časť hierarchie týchto tried je znázornená na nasledujúcom obrázku.

[[Súbor:Vynimky_hierarchia.png|center|750px]]

Všetky výnimky v Jave dedia od triedy [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/Throwable.html <tt>Throwable</tt>]. Tá má dve podtriedy:
* [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/Exception.html <tt>Exception</tt>], od ktorej dedí väčšina &bdquo;bežných&rdquo; výnimiek.
* [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/Error.html <tt>Error</tt>], od ktorej dedia triedy reprezentujúce závažné, v rámci aplikácie ťažko predpovedateľné systémové chyby (napríklad nedostatok pamäte). Jednou z najznámejších podtried triedy <tt>Error</tt> je [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/StackOverflowError.html <tt>StackOverflowError</tt>].

Podtriedy triedy <tt>Exception</tt> možno ďalej rozdeliť na dve základné kategórie:
* [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/RuntimeException.html <tt>RuntimeException</tt>] a jej podtriedy. Výnimky tohto typu obvykle reprezentujú rozličné programátorské chyby, ako napríklad prístup k neexistujúcemu prvku poľa ([https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/ArrayIndexOutOfBoundsException.html <tt>ArrayIndexOutOfBoundsException</tt>]), delenie nulou ([https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/ArithmeticException.html <tt>ArithmeticException</tt>]), použitie kódu &bdquo;očakávajúceho&rdquo; objekt na referenciu <tt>null</tt> ([https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/NullPointerException.html <tt>NullPointerException</tt>]), atď. Do tejto kategórie patria aj výnimky typu [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/NoSuchElementException.html <tt>NoSuchElementException</tt>], hoci tie sme v príklade vyššie možno trochu zneužili na ošetrenie zlého formátu vstupného súboru. Vo všeobecnosti platí, že výnimky tohto typu by buď nemali vôbec nastať (programátorské chyby, ktoré je nutné odladiť), alebo by mali byť ošetrené priamo v metóde, v ktorej vzniknú (ako napríklad <tt>NoSuchElementException</tt> v našom príklade vyššie).
* Zvyšné podtriedy triedy <tt>Exception</tt>. Tie často reprezentujú neočakávateľné udalosti, ktorým sa na rozdiel od výnimiek typu <tt>RuntimeException</tt> nedá úplne vyhnúť (napríklad [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/io/FileNotFoundException.html <tt>FileNotFoundException</tt>] a jej nadtrieda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/io/IOException.html <tt>IOException</tt>]). Dobre napísaný program by sa mal vedieť z výnimiek tohto typu zotaviť (nie je napríklad dobré ukončiť program vždy, keď sa mu nepodarí otvoriť súbor).

S týmto rozdelením podľa druhov chýb reprezentovaných jednotlivými výnimkami súvisí aj nasledujúca nutnosť:
* Výnimka ľubovoľného typu okrem <tt>RuntimeException</tt>, <tt>Error</tt> a ich podtried musí byť v metóde, v ktorej môže vzniknúť, vždy buď odchytená, alebo v opačnom prípade ich musí táto metóda deklarovať vo svojej hlavičke ako neodchytené. Napríklad:
<syntaxhighlight lang="java">
void f() throws FileNotFoundException, UnsupportedEncodingException {
    // ...
}
</syntaxhighlight>
* Popri vykonaní príkazu <tt>return</tt> je totiž vyhodenie výnimky ďalším možným spôsobom ukončenia vykonávania volanej metódy. Preto musí byť táto možnosť v hlavičke metódy explicitne špecifikovaná rovnako ako napríklad návratový typ.
* Pri inštanciách triedy <tt>RuntimeException</tt> a jej podtried sa od tejto požiadavky upúšťa, pretože &ndash; ako bolo spomenuté vyššie &ndash; ide väčšinou o programátorské chyby, ktoré je nutné odladiť, alebo sú tieto výnimky odchytené priamo v metóde, v ktorej vzniknú. Pri inštanciách triedy <tt>Error</tt> a jej podtried zas často ide o systémové chyby, zotavenie z ktorých principiálne nie je možné. Často je teda najlepším riešením ukončiť samotný program.
* Hoci môže hádzané výnimky prostredníctvom <tt>throws</tt> deklarovať aj metóda <tt>main</tt> (s príkladmi sme sa už stretli), pri reálnych programoch sa to nepovažuje za dobrú prax &ndash; všetky výnimky, ktoré sú inštanciami <tt>Exception</tt>, by mali byť ošetrené.

=== Hádzanie výnimiek a výnimky nových typov ===

Vyhodenie novej výnimky možno pre inštanciu <tt>e</tt> triedy <tt>Throwable</tt> alebo jej podtried realizovať príkazom
<syntaxhighlight lang="java">
throw e;
</syntaxhighlight>
Najčastejšie sa pritom <tt>throw</tt> aplikuje na novovytvorenú inštanciu nejakej triedy, napríklad
<syntaxhighlight lang="java">
throw new IOException();
</syntaxhighlight>
alebo
<syntaxhighlight lang="java">
throw new IOException("Sprava");
</syntaxhighlight>
Pre úplne nové typy chybových udalostí sa vo všeobecnosti neodporúča používať výnimky existujúcich typov. Naopak je vhodnejšie napísať novú podtriedu triedy <tt>Exception</tt> reprezentujúcu výnimky požadovaného typu a následne pomocou <tt>throw</tt> vyhadzovať inštancie tejto triedy. Napríklad pre účely nášho ukážkového programu vyššie môžeme napísať triedu výnimiek <tt>NegativeElementCountException</tt>, ktorej inštancie budeme vyhadzovať zakaždým, keď používateľ zadá ako počet čísel zápornú hodnotu. Táto trieda môže vyzerať napríklad nasledovne.

<syntaxhighlight lang="java">
public class NegativeElementCountException extends Exception {
    Integer number;

    public NegativeElementCountException() {
        number = null;  // Netreba
    }

    public NegativeElementCountException(int number) {
        this.number = number;
    }

    @Override
    public String getMessage() {
        if (number != null) {
            return "Zaporny pocet cisel: " + number + ".";
        } else {
            return "Zaporny pocet cisel.";
        }
    }
}
</syntaxhighlight>

Použitie tejto výnimky v samotnom programe potom môže vyzerať napríklad takto.

<syntaxhighlight lang="java">
import java.io.*;
import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        Scanner scanner = null;
        try {
            scanner = new Scanner(new File("vstup.txt"));
            int n = scanner.nextInt();
            if (n < 0) {
                throw new NegativeElementCountException(n);
            }
            int sum = 0;
            for (int i = 1; i <= n; i++) {
                sum += scanner.nextInt();
            }
            System.out.println("Sucet je: " + sum + ".");
        } catch (IOException e) {
            System.err.println("Chyba suvisiaca s pristupom k suboru vstup.txt.");
        } catch (NoSuchElementException e) {
            System.err.println("Zly format vstupneho suboru.");
        } catch (NegativeElementCountException e) {
            System.err.println(e);
        } finally {
            if (scanner != null) {
                scanner.close();
            }
        }
        System.out.println("Aj po odchytenej vynimke pokracujem dalej a vypisem tento text...");
    }
}
</syntaxhighlight>

== Generické programovanie ==

V minulom semestri sme videli viacero abstraktných dátových typov a dátových štruktúr, ako napríklad zásobník alebo rad hodnôt typu <tt>T</tt>, či binárny strom uchovávajúci v uzloch hodnoty typu <tt>T</tt>. Typ <tt>T</tt> mohol byť často ľubovoľný, inokedy sa naň kládli určité podmienky (napríklad pri binárnych vyhľadávacích stromoch mohla byť takouto podmienkou existencia úplného usporiadania na <tt>T</tt>). Zakaždým sme ale boli schopní napísať implementácie týchto dátových štruktúr iba pre jeden pevne zvolený typ; v C++ sme síce pomocou <tt>typedef</tt> tento typ vedeli rýchlo meniť, ale mohli sme sa dostať do problémov v situáciách, keď sme potrebovali pracovať s dvoma inštanciami tej istej dátovej štruktúry pre dva rozdielne typy.  

Pri využití nástrojov objektovo orientovaného programovania sa ponúka jedno rýchle východisko z tejto situácie: mohli by sme napríklad napísať zásobník, rad, alebo strom uchovávajúci inštancie triedy <tt>Object</tt> &ndash; inštanciami triedy <tt>Object</tt> sú totiž úplne všetky objekty. Aj tento prístup má ale svoje veľké nevýhody: napríklad pri zásobníku reťazcov by sme museli všetky objetky vyberané zo zásobníka pretypovať na <tt>String</tt>, čo by bolo nielen prácne, ale aj náchylné na chyby (niekto napríklad mohol omylom vložiť na zásobník objekt, ktorý nie je inštanciou triedy <tt>String</tt>). Ukážeme si teraz elegantnejšie riešenie podobných situácií pomocou ''generického programovania'', ktoré umožňuje parametrizovať triedy a metódy typovými parametrami. Tento nástroj vo veľkej miere využívajú aj dátové štruktúry zo štandardnej knižnice tried jazyka Java.

=== Generické triedy ===

Triedu, ktorá závisí od typového parametra <tt>T</tt> &ndash; takzvanú ''generickú triedu'' &ndash; možno v Jave napísať takto:
<syntaxhighlight lang="Java">
public class GenerickaTrieda<T> {
    // ...
}
</syntaxhighlight>
Trieda môže závisieť aj od viacerých typových parametrov, napríklad:
<syntaxhighlight lang="Java">
public class GenerickaTrieda<T1, T2, T3, T4> {
    // ...
}
</syntaxhighlight>
Vo vnútri generickej triedy možno ''v nestatickom kontexte'' s typovými parametrami pracovať podobne, ako keby išlo o bežnú triedu (pri určitých obmedzeniach; nemožno napríklad tvoriť nové inštancie typového parametra). Napríklad:
<syntaxhighlight lang="Java">
import java.util.*;

public class GenerickaTrieda<T> {
    private T[] a;

    public GenerickaTrieda(T[] a) {
        this.a = Arrays.copyOf(a, a.length);
    }

    // ...
}
</syntaxhighlight>
Pri vytváraní inštancií generickej triedy za typový parameter dosadíme typový argument, ktorým môže byť ľubovoľný ''neprimitívny'' typ (čiže napríklad trieda alebo rozhranie):
<syntaxhighlight lang="Java">
Integer a[] = {1, 2, 3, 4, 5};
GenerickaTrieda<Integer> g = new GenerickaTrieda<Integer>(a);
</syntaxhighlight>
alebo skrátene
<syntaxhighlight lang="Java">
Integer a[] = {1, 2, 3, 4, 5};
GenerickaTrieda<Integer> g = new GenerickaTrieda<>(a);
</syntaxhighlight>
* Zápis <tt><></tt> (takzvaný ''diamant'') možno použiť kedykoľvek je typový argument zrejmý z kontextu (využíva sa tu mechanizmus automatickej inferencie typov).

Pre každú konkrétnu triedu <tt>KonkretnaTrieda</tt> teda máme parametrizovaný typ <tt>GenerickaTrieda<KonkretnaTrieda></tt>, ktorý sa chová podobne ako trieda (možno z neho tvoriť inštancie a pod., ale existujú určité drobné obmedzenia jeho použitia). 
* Ak je pritom <tt>KonkretnaTrieda</tt> podtriedou triedy <tt>InaKonkretnaTrieda</tt>, tak každý objekt typu <tt>KonkretnaTrieda</tt> je súčasne aj inštanciou triedy <tt>InaKonkretnaTrieda</tt>. Táto relácia sa ''neprenáša'' na typy <tt>GenerickaTrieda<KonkretnaTrieda></tt> a <tt>GenerickaTrieda<InaKonkretnaTrieda></tt>.
* Napríklad inštanciu typu <tt>GenerickaTrieda<Integer></tt> teda ''nemožno'' použiť v situácii, keď sa očakáva inštancia typu <tt>GenerickaTrieda<Object></tt>.
* Aj generická trieda ale môže dediť od inej triedy, rovnako ako každá iná trieda:
<syntaxhighlight lang="Java">
class Trieda1 {
    
}

class Trieda2<T> extends Trieda1 {  
    // OK, v tele triedy mozeme pouzivat typovy parameter T.
} 

class Trieda3<T> extends Trieda2<T> {  
    // OK, pre kazde T je instancia parametrizovanej triedy Trieda3<T> sucasne aj instanciou Trieda2<T>.
}

class Trieda4<T> extends Trieda2<Integer> {  
    // OK, pre vsetky T je instancia Trieda4<T> sucasne aj instanciou Trieda2<Integer>.
    // Parameter T pre Trieda4 nijak nesuvisi s parametrom T pre Trieda2.
}

class Trieda5 extends Trieda2<Integer> {
    // OK.
}

class Trieda6 extends Trieda2<T> {
    // CHYBA: nie je jasne, co je T.
}
</syntaxhighlight>
* Podobne ako generické triedy možno tvoriť aj generické rozhrania.

=== ''Príklad'': uzol binárneho stromu ako generická trieda ===

Základ generickej triedy <tt>Node<T></tt> reprezentujúcej uzol binárneho stromu uchovávajúci inštanciu <tt>value</tt> nejakej triedy <tt>T</tt> môže vyzerať napríklad nasledovne.
<syntaxhighlight lang="Java">
public class Node<T> {
    private T value;
    private Node<T> left, right;

    public Node(T value, Node<T> left, Node<T> right) {
        this.value = value;
        this.left = left;
        this.right = right;
    }

    @Override
    public String toString() {
        String leftString = "";
        String rightString = "";
        if (left != null) {
            leftString = "(" + left.toString() + ") ";
        }
        if (right != null) {
            rightString = " (" + right.toString() + ")";
        }
        return leftString + this.value + rightString;
    }
}
</syntaxhighlight>
* Trieda <tt>Node<T></tt> teda poskytuje konštruktor, ktorý ako parameter berie uchovávanú inštanciu triedy <tt>T</tt> a referencie na ľavého a pravého syna.
* Trieda taktiež implementuje metódu <tt>toString</tt>, ktorá vráti &bdquo;infixovú textovú reprezentáciu&rdquo; stromu. 

Program využívajúci triedu <tt>Node<T></tt> môže vyzerať napríklad takto:
<syntaxhighlight lang="Java">
public static void main(String[] args) {
    Node<Integer> integerRoot = new Node<>(4,
            new Node<>(3,
                    new Node<>(9, null, null),
                    new Node<>(2, null, new Node<>(5, null, null))),
            new Node<>(0, null, null));
    Node<String> stringRoot = new Node<>("koren",
            new Node<>("lavy syn korena",
                    new Node<>("nieco", null, null),
                    new Node<>("nieco ine", null, new Node<>("nieco este ine", null, null))),
            new Node<>("pravy syn korena", null, null));
    System.out.println(integerRoot);
    System.out.println(stringRoot);
}
</syntaxhighlight>

=== Generické metódy ===

Podobne ako generické triedy možno tvoriť aj jednotlivé generické metódy, pri ktorých sa typové parametre píšu ''pred návratový typ''. Tieto parametre sú &bdquo;viditeľné&rdquo; iba v rámci danej metódy. Pri volaní metódy možno za tieto parametre buď explicitne dosadiť konkrétne triedy, alebo sa o to postará automatický mechanizmus inferencie typov.

''Príklad'': nasledujúca generická statická metóda <tt>createFullTree</tt> vytvorí plný binárny strom danej výšky <tt>height</tt>, ktorého uzly všetky obsahujú rovnakú inštanciu <tt>value</tt> triedy dosadenej ako argument za typový parameter <tt>T</tt>.
<syntaxhighlight lang="Java">
public class Trieda {

    public static <T> Node<T> createFullTree(int height, T value) {
        if (height == 0) {
            return new Node<>(value, null, null);
        } else {
            return new Node<>(value, createFullTree(height - 1, value), createFullTree(height - 1, value));
        }
    }

    public static void main(String[] args) {
        Node<Integer> root1 = Trieda.<Integer>createFullTree(4, 0);
        Node<String> root2 = createFullTree(4, "retazec");  // Skrateny zapis spoliehajuci sa na automaticku inferenciu typu
        System.out.println(root1);
        System.out.println(root2);
    }
}
</syntaxhighlight>

=== Ohraničené typové parametre ===

Často nastáva situácia, keď typový parameter nemôže byť úplne ľubovoľný, ale musí spĺňať určité podmienky. Predpokladajme napríklad, že by sme do našej generickej triedy <tt>Node<T></tt> chceli pridať metódu, ktorá nájde ''najmenší'' prvok typu <tt>T</tt> uložený v niektorom z uzlov podstromu, ktorého je daný uzol koreňom. Takáto úloha dáva zmysel iba vtedy, keď je na <tt>T</tt> definované úplné usporiadanie &ndash; čiže keď možno inštancie triedy <tt>T</tt> navzájom porovnávať. V štandardných triedach jazyka Java býva táto možnosť vyjadrená tým, že daná trieda <tt>T</tt> implementuje rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/Comparable.html <tt>Comparable<T></tt>].

Trieda <tt>T</tt> implementujúca <tt>Comparable<&#85;></tt> pre nejakú &ndash; vo všeobecnosti aj inú &ndash; triedu <tt>U</tt>, musí poskytovať metódu
<syntaxhighlight lang="Java">
public int CompareTo(U o);
</syntaxhighlight>
ktorá vráti záporné číslo, nulu, alebo kladné číslo podľa toho, či je inštancia <tt>this</tt> triedy <tt>T</tt> menšia, rovná, alebo väčšia ako inštancia <tt>o</tt> triedy <tt>U</tt>. To samozrejme dáva najväčší zmysel, keď je <tt>U</tt> to isté ako <tt>T</tt> &ndash; v takom prípade je možné inštancie triedy <tt>T</tt> porovnávať medzi sebou. Triedy <tt>T</tt> implementujúce rozhranie <tt>Comparable<T></tt> vždy poskytujú metódu
<syntaxhighlight lang="Java">
public int CompareTo(T o);
</syntaxhighlight>
s významom opísaným vyššie.

Chceli by sme teda obmedziť typový parameter pre generickú triedu <tt>Node<T></tt> tak, aby zaň mohla byť dosadená iba inštancia triedy <tt>T</tt> implementujúcej rozhranie <tt>Comparable<T></tt>. To možno urobiť pomocou takzvaného ''ohraničeného typového parametra''. Pre ľubovoľnú triedu <tt>AnyClass</tt> a pre ľubovoľné rozhranie <tt>AnyInterface</tt> možno typový parameter písať ako
<syntaxhighlight lang="Java">
<T extends AnyClass>
</syntaxhighlight>
resp.
<syntaxhighlight lang="Java">
<T extends AnyInterface>
</syntaxhighlight>
čím sa vyjadrí, že typový parameter <tt>T</tt> musí byť podtriedou triedy <tt>AnyClass</tt> resp. musí implementovať rozhranie <tt>AnyInterface</tt> (aj pri rozhraniach sa naozaj píše slovo <tt>extends</tt>).

Upravená trieda pre uzol binárneho stromu tak môže vyzerať napríklad nasledovne.
<syntaxhighlight lang="Java">
public class Node<T extends Comparable<T>> {
    private T value;
    private Node<T> left, right;

    public Node(T value, Node<T> left, Node<T> right) {
        this.value = value;
        this.left = left;
        this.right = right;
    }

    @Override
    public String toString() {
        String leftString = "";
        String rightString = "";
        if (left != null) {
            leftString = "(" + left.toString() + ") ";
        }
        if (right != null) {
            rightString = " (" + right.toString() + ")";
        }
        return leftString + this.value + rightString;
    }

    public T minValue() {
        T result = value;
        if (left != null && result.compareTo(left.minValue()) > 0) {
            result = left.minValue();
        }
        if (right != null && result.compareTo(right.minValue()) > 0) {
            result = right.minValue();
        }
        return result;
    }
}
</syntaxhighlight>

<syntaxhighlight lang="Java">
public class Trieda {

    public static <T extends Comparable<T>> Node<T> createFullTree(int height, T value) {
        if (height == 0) {
            return new Node<>(value, null, null);
        } else {
            return new Node<>(value, createFullTree(height - 1, value), createFullTree(height - 1, value));
        }
    }

    public static void main(String[] args) {
        // ...
        System.out.println(root.minValue());
    }
}
</syntaxhighlight>

=== Divoké karty ===

Vieme už, že ak je trieda <tt>SubClass</tt> podtriedou triedy <tt>SuperClass</tt>, tak napríklad inštancia parametrizovanej triedy <tt>Node<SubClass></tt> už nebude inštanciou parametrizovanej triedy <tt>Node<SuperClass></tt>. Hoci teda každý uzol prvého typu svojím spôsobom reprezentuje aj uzol druhého typu, nemožno v situácii, keď sa požaduje inštancia typu <tt>Node<SuperClass></tt> použiť inštanciu typu <tt>Node<SubClass></tt>. Keby sme teda napríklad chceli napísať (bežnú negenerickú) metódu <tt>f</tt>, ktorá berie ako argument uzol binárneho stromu uchovávajúci inštanciu triedy <tt>SuperClass</tt>, alebo niektorej jej podtriedy, ''nestačilo'' by napísať metódu 
<syntaxhighlight lang="Java">
public static void f(Node<SuperClass> root) {
    // ...
}
</syntaxhighlight>  
Keby sme totiž skúsili zavolať túto metódu s parametrom typu <tt>Node<SubClass></tt>, program by neskompiloval. Riešením v takýchto situáciách je použitie tzv. ''divokej karty'' (angl. <tt>wildcard</tt>) reprezentovanej symbolom &bdquo;<tt>?</tt>&rdquo;. Napríklad <tt>Node<? extends SuperClass> root</tt> reprezentuje argument metódy ľubovoľného z typov <tt>Node<SomeClass></tt>, kde <tt>SomeClass</tt> je podtriedou <tt>SuperClass</tt> kompatibilnou s ohraničením typového parametra danej generickej triedy. Rovnako ako s nadtriedami môžeme použiť túto notáciu aj s rozhraniami, ktoré majú byť implementované.
<syntaxhighlight lang="Java">
public static void f(Node<? extends SuperClass> root) {
    SuperClass minValue = root.minValue();  
    // ...
}
</syntaxhighlight>
Spolu s takýmito &bdquo;zhora ohraničenými&rdquo; divokými kartami možno používať aj &bdquo;zdola ohraničené&rdquo; divoké karty v tvare <tt><? super SubClass></tt>, ktorými sa vyjadrí požiadavka, že <tt>T</tt> je ľubovoľná nadtrieda triedy <tt>SubClass</tt> kompatibilná s ohraničením typového parametra danej generickej triedy. Podobne možno používať aj &bdquo;neohraničenú&rdquo; divokú kartu <tt><?></tt> vyjadrujúcu ľubovoľnú triedu kompatibilnú s ohraničením typového parametra danej generickej triedy (pre generickú triedu <tt>Node<T extends Comparable></tt> je teda napríklad parameter <tt>Node<?> root</tt> ekvivalentný parametru <tt>Node<? extends Comparable> root</tt>).

== Úvod do Java Collections ==

V štandardných knižniciach jazyka Java možno nájsť viacero generických tried reprezentujúcich rôzne užitočné dátové štruktúry. Tieto triedy sú spoločne známe ako ''Java Collections'', sú poväčšine definované v balíku <tt>java.util</tt> a vyznačujú sa predovšetkým tým, že implementujú generické rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Collection.html <tt>Collection<E></tt>] reprezentujúce nejakú skupinu objektov. Je užitočné tieto triedy poznať a v čo najväčšej miere ich používať. Na tejto prednáške si iba v rýchlosti predstavíme niektoré z nich; podrobnejšie sa nimi budeme zaoberať na nasledujúcej prednáške. Nebudeme tu uvádzať obsiahle zoznamy metód poskytovaných jednotlivými týmito triedami &ndash; tieto informácie možno ľahko dohľadať v dokumentácii &ndash; a namiesto toho sa zakaždým sústredíme iba na krátku ukážku ich použitia.

=== Trieda <tt>ArrayList</tt> ===

Generická trieda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/ArrayList.html <tt>ArrayList<E></tt>] reprezentuje ''dynamické'' pole prvkov typu <tt>E</tt>. Toto pole mení svoju veľkosť podľa momentálnej potreby.
* Prvok na koniec poľa pridáva metóda <tt>add</tt>.
* Prvok na danej pozícii dostaneme metódou <tt>get</tt>. 
* Metóda <tt>set</tt> mení prvok na danej pozícii na určenú hodnotu.
* Dĺžku poľa vracia metóda <tt>size</tt>.

''Príklad'':
<syntaxhighlight lang="Java">
import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        ArrayList<Integer> a = new ArrayList<>();
        for (int i = 0; i <= 9; i++) {
            a.add(i);
        }
        for (int i = 0; i <= a.size() - 1; i++) {
            a.set(i, i + 1);
        }
        for (int i = 0; i <= a.size() - 1; i++) {
            System.out.print(a.get(i) + " ");
        }
    }
}
</syntaxhighlight>

=== Rozhranie <tt>List</tt> a trieda <tt>LinkedList</tt> ===

Veľká časť metód poskytovaných inštanciami triedy <tt>ArrayList</tt> je deklarovaná v rozhraní <tt>List</tt>, ktoré je implementované triedami reprezentujúcimi nejaký typ zoznamu. Popri triede <tt>ArrayList<E></tt> je ďalšou triedou implementujúcou toto rozhranie trieda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/LinkedList.html <tt>LinkedList<E></tt>] reprezentujúca obojsmerne spájaný zoznam. 
* Keďže implementuje rovnaké rozhranie <tt>List<E></tt> ako <tt>ArrayList<E></tt>, možno na prácu s ním používať podobné metódy. Dokonca je často užitočné zvoliť za typ vstupného argumentu metódy očakávajúcej zoznam priamo rozhranie <tt>List</tt>; v takom prípade možno metódu volať ako pre <tt>ArrayList</tt>, tak aj pre <tt>LinkedList</tt>.
* Treba však pamätať na to, že odlišná implementácia tried <tt>ArrayList</tt> a <tt>LinkedList</tt> má za následok aj rozdiely v efektívnosti jednotlivých vykonávaných operácií. V spájanom zozname je oproti poľu podstatne efektívnejšie pridávanie prvkov na jeho začiatok alebo koniec, podobne aj ich odoberanie (<tt>LinkedList</tt> tu oproti rozhraniu <tt>List</tt> a triede <tt>ArrayList</tt> poskytuje aj niekoľko metód navyše). Naopak omnoho menej efektívny je prístup k prvku na danej pozícii pomocou metódy <tt>get</tt>.
* Vypísanie všetkých prvkov spájaného zoznamu by sme teda v princípe mohli realizovať aj rovnako ako pre polia:
: <syntaxhighlight lang="Java">
LinkedList<Integer> list = new LinkedList<>();
// ...
for (int i = 0; i <= list.size() - 1; i++) {
    System.out.print(list.get(i) + " ");
}
</syntaxhighlight>
: Omnoho efektívnejšie je ale použitie ''iterátora'' (o tom viac nabudúce):
: <syntaxhighlight lang="Java">
LinkedList<Integer> list = new LinkedList<>();
// ...
for (Iterator<Integer> it = list.iterator(); it.hasNext(); ) {
    System.out.print(it.next() + " ");
}
</syntaxhighlight>
: Prípadne tiež možno použiť ekvivalentnú konštrukciu
: <syntaxhighlight lang="Java">
LinkedList<Integer> list = new LinkedList<>();
// ...
for (Integer x : list) {
    System.out.print(x + " ");
}
</syntaxhighlight>

=== Niektoré ďalšie dátové štruktúry ===

Java Collections obsahuje aj množstvo ďalších tried a rozhraní. Napríklad:
* Rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Set.html <tt>Set<E></tt>] pre množiny a jeho implementácie ako napríklad [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/HashSet.html <tt>HashSet<E></tt>].
* Rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Map.html <tt>Map<K,V></tt>] pre zobrazenia (resp. slovníky alebo asociatívne polia), pri ktorých sú kľúče typu <tt>K</tt> zobrazované na hodnoty typu <tt>V</tt>. Implementáciou tohto rozhrania je napríklad trieda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/HashMap.html <tt>HashMap<K,V></tt>].
* Trieda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Stack.html <tt>Stack<E></tt>] reprezentujúca zásobník a rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Queue.html <tt>Queue<E></tt>] pre rad, ktoré okrem iného implementuje aj trieda <tt>LinkedList<E></tt>. Triedu <tt>LinkedList<E></tt> možno použiť aj ako zásobník, pretože implementuje rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Deque.html <tt>Deque<E></tt>] pre ''obojstranný rad'', ktoré okrem iného deklaruje metódy <tt>push</tt> a <tt>pop</tt> (trieda <tt>LinkedList</tt> je efektívnejšia ako <tt>Stack</tt>).  
* ...

== Odkazy ==

* [https://docs.oracle.com/javase/tutorial/essential/exceptions/index.html Java tutoriál: Exceptions]
* [https://docs.oracle.com/javase/tutorial/java/generics/index.html Java tutoriál: Generics]
* [https://docs.oracle.com/javase/tutorial/collections/index.html Java tutoriál: Collections]
=Riešenia testu č. 1=
== Úloha č. 1 ==

<syntaxhighlight lang="java">
import java.util.*;

public class CyclicArray {
    private int a[];

    public CyclicArray(int a[]) {
        this.a = Arrays.copyOf(a, a.length);
    }

    public int get(int index) {
        return a[index % a.length];
    }

    public void set(int index, int value) {
        a[index % a.length] = value;
    }

    public int[] toArray() {
        return Arrays.copyOf(a, a.length);
    }
}
</syntaxhighlight>

== Úloha č. 2 ==

<syntaxhighlight lang="java">
package arithmetic;

abstract class Node {

    public abstract int evaluate(int x);

}
</syntaxhighlight>

<syntaxhighlight lang="java">
package arithmetic;

class Plus extends BinaryNode {

    // ...

    @Override
    public int evaluate(int x) {
        return getLeft().evaluate(x) + getRight().evaluate(x);
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package arithmetic;

class Times extends BinaryNode {

    // ...

    @Override
    public int evaluate(int x) {
        return getLeft().evaluate(x) * getRight().evaluate(x);
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package arithmetic;

class Constant extends NullaryNode {
    
    // ...

    @Override
    public int evaluate(int x) {
        return value;
    }
}

</syntaxhighlight>

<syntaxhighlight lang="java">
package arithmetic;

class VariableX extends NullaryNode {

    // ...

    @Override
    public int evaluate(int x) {
        return x;
    }
}
</syntaxhighlight>

== Úloha č. 3 ==

<syntaxhighlight lang="java">
import java.util.*;

public class Node {
    private int value;
    private Node[] children;

    public Node(int value, Node[] children) {
        this.value = value;
        this.children = Arrays.copyOf(children, children.length);
    }

    public Node(int height, int degree, int value) {
        this(value, new Node[0]);
        if (height >= 1) {
            children = new Node[degree];
            for (int i = 0; i <= degree - 1; i++) {
                children[i] = new Node(height - 1, degree, value);
            }
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (Node node : children) {
            sb.append("(");
            sb.append(node);
            sb.append(") ");
        }
        sb.append(value);
        return sb.toString();
    }
}
</syntaxhighlight>
=Letný semester, prednáška č. 5=
== Oznamy ==

* Dnes po prednáške bude zverejnené zadanie druhej domácej úlohy, ktorú bude potrebné odovzdať ''do pondelka 29. marca, 9:00'' (čiže do začiatku siedmej prednášky).
* Na stredajších cvičeniach bude &ndash; okrem niekoľkých nebodovaných úloh zameraných na látku z tejto a minulej prednášky &ndash; zverejnené aj zadanie druhej bonusovej úlohy s odovzdávaním ''do stredy 24. marca, 11:30'' (čiže najneskôr do začiatku šiestych cvičení).

== Java Collections ==

Detailnejšie teraz preskúmame štandardné dátové štruktúry implementované v balíku <tt>java.util</tt> a známe pod súhrnným názvom ''Java Collections''. Na nasledujúcom obrázku je znázornený diagram niekoľkých spomedzi najdôležitejších tried a rozhraní, ktoré sú súčasťou Java Collections. Plná šípka v tomto diagrame reprezentuje dedenie (aj medzi rozhraniami) a prerušovaná šípka znázorňuje implementáciu rozhrania triedou.

[[Súbor:Collections.png|center|750px]]

=== Rozhranie <tt>Collection</tt> ===

Veľká časť tried pre dátové štruktúry, ktoré sú súčasťou Java Collections &ndash; presnejšie triedy reprezentujúce zoskupenia objektov nejakého typu <tt>E</tt> &ndash; implementuje generické rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Collection.html <tt>Collection<E></tt>]. Metódy tohto rozhrania sú tak napríklad poskytované implementáciami zoznamov, či množín. Medzi najdôležitejšie spomedzi metód deklarovaných v rozhraní <tt>Collection<E></tt> patria nasledujúce:
* Metóda <tt>boolean contains(Object o)</tt> vráti <tt>true</tt> práve vtedy, keď dané zoskupenie objektov obsahuje objekt <tt>o</tt>.
* Metóda <tt>boolean add(E e)</tt> pridá inštanciu <tt>e</tt> typu <tt>E</tt> do zoskupenia objektov a vráti booleovskú hodnotu podľa toho, či po vykonaní tejto operácie bolo dané zoskupenie zmenené (napríklad u zoznamov by to tak malo byť vždy; naopak množina sa nezmení v prípade, že je do nej pridaný prvok, ktorý už obsahuje). Pri jednotlivých implementáciách rozhrania <tt>Collection<E></tt> môže byť správanie tejto metódy bližšie určené: napríklad u zoznamov sa typicky pridávajú prvky na koniec. Táto metóda je označená ako nepovinná, čo znamená, že niektoré implementácie rozhrania <tt>Collection<E></tt> ju môžu implementovať iba ako vyhodenie výnimky typu <tt>UnsupportedOperationException</tt>. 
* Metóda <tt>boolean remove(Object o)</tt> odoberie zo zoskupenia jeden výskyt argumentu <tt>o</tt>. Opäť ide o nepovinnú metódu, ktorej správanie môže byť v jednotlivých implementáciách rozhrania bližšie špecifikované. (Napríklad pri zoznamoch väčšinou býva užitočnejšia iná verzia metódy <tt>remove</tt>, ktorá odoberie prvok na danom indexe; táto sa ale v rozhraní pre všeobecné zoskupenia objektov nedeklaruje.)
* Metóda <tt>int size()</tt> vráti veľkosť daného zoskupenia objektov.
* Metóda <tt>boolean isEmpty()</tt> zistí, či je dané zoskupenie objektov prázdne. 
* Metóda <tt>Iterator<E> iterator()</tt> vráti tzv. ''iterátor'', ktorý možno použiť na postupné prechádzanie cez všetky prvky daného zoskupenia. Ide tu o dôležitý koncept, pri ktorom sa ešte bližšie pristavíme nižšie.

=== Použitie metódy <tt>equals</tt> ===

Je ešte potrebné ujasniť si, čo napríklad pri metóde <tt>contains</tt> znamená, že zoskupenie ''obsahuje'' objekt <tt>o</tt>, prípadne kedy sa pri metóde <tt>remove</tt> nejaký objekt považuje za ''výskyt'' jej argumentu. V obdivoch prípadoch sa na porovnávanie objektov používa metóda <tt>equals</tt>, ktorá porovná dva objekty na rovnosť. S touto metódou sme sa už stretli napríklad pri reťazcoch alebo pri &bdquo;baliacich&rdquo; triedach. Ide však o metódu, ktorá je podobne ako <tt>toString</tt> definovaná už v triede <tt>Object</tt> &ndash; jej východzou implementáciou je porovnávanie referencií pomocou operátora <tt>==</tt> &ndash; a v iných triedach môže byť prekrytá prirodzenejšou implementáciou. Viacero štandardných tried (napr. <tt>String</tt> a <tt>Integer</tt>) túto metódu vhodným spôsobom prekrýva.
* Programátor prekrytej metódy <tt>equals</tt> by mal vždy zabezpečiť, aby išlo o ''reláciu ekvivalencie'' (reflexívnu, symetrickú a súčasne tranzitívnu reláciu).
* Súčasne by sa výstupy metódy <tt>equals</tt> pre danú dvojicu objektov v ideálnom prípade ''nemali meniť v čase''. To v praxi znamená, že prekrývanie metódy <tt>equals</tt> má význam hlavne pri triedach, ktorých inštancie reprezentujú nemodifikovateľné dáta. Napríklad <tt>String</tt> metódu <tt>equals</tt> zdedenú od triedy <tt>Object</tt> vhodným spôsobom prekrýva, ale <tt>StringBuilder</tt> nie. Hoci prekrytie metódy <tt>equals</tt> spôsobom porušujúcim túto podmienku nie je striktne zakázané (príkladom môže byť napríklad jej implementácia práve pre väčšinu zoskupení Java Collections), môže použitie takýchto objektov ako prvkov zoskupení často viesť k neočakávaným výsledkom. V takom prípade je teda často potrebné zabezpečiť, aby sa modifikovateľné prvky zoskupení nemodifikovali. 
* Dátové štruktúry, ktoré sú súčasťou Java Collections, sa na tieto vlastnosti metódy <tt>equals</tt> spoliehajú &ndash; iba za ich splnenia je teda garantované, že sa budú správať očakávaným spôsobom. 

''Príklad'': nasledujúca trieda reprezentuje bod v rovine, pričom dva body sa považujú za rovné kedykoľvek sa rovnajú obidve ich súradnice.
<syntaxhighlight lang="java">
public class Point {
    private double x, y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }

    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        return o.getClass() == this.getClass() && ((Point) o).x == x && ((Point) o).y == y;
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Trieda {

    public static void main(String[] args) {
        Point p1 = new Point(1, 2);
        Point p2 = new Point(1, 2);
        System.out.println(p1 == p2);       // false
        System.out.println(p1.equals(p2));  // true
    }
}
</syntaxhighlight>

=== Zoznamy ===

Triedy pre zoznamy sú implementáciami rozhrania [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/List.html <tt>List<E></tt>].
* Prvok na koniec zoznamu pridáva metóda <tt>add</tt>, prvok na danej pozícii dostaneme metódou <tt>get</tt>, metóda <tt>set</tt> mení prvok na danej pozícii na určenú hodnotu a dĺžku zoznamu vracia metóda <tt>size</tt>.
Dvoma najdôležitejšími triedami implementujúcimi rozhranie <tt>List<E></tt> sú:
* Trieda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/ArrayList.html <tt>ArrayList<E></tt>] reprezentujúca zoznamy implementované pomocou ''dynamických'' polí, ktoré dokážu automaticky meniť objem alokovanej pamäte. 
:''Príklad'':
:<syntaxhighlight lang="Java">
import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        ArrayList<Integer> a = new ArrayList<>();
        for (int i = 0; i <= 9; i++) {
            a.add(i);
        }
        for (int i = 0; i <= a.size() - 1; i++) {
            a.set(i, i + 1);
        }
        for (int i = 0; i <= a.size() - 1; i++) {
            System.out.print(a.get(i) + " ");
        }
    }
}
</syntaxhighlight>
* Trieda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/LinkedList.html <tt>LinkedList<E></tt>] reprezentujúca obojsmerne spájaný zoznam.

Každá z týchto dvoch implementácií zoznamov je zameraná na iné operácie, ktoré sú v nej efektívnejšie &ndash; z minulého semestra napríklad vieme, že prístup k prvku na konkrétnej pozícii zoznamu je omnoho efektívnejší u polí, zato pri spájaných zoznamoch sa rýchlejšie pridávajú a odoberajú nové prvky (napríklad) na začiatku alebo konci.

* Kopírovanie zoznamov možno realizovať napríklad pomocou konštruktorov, ktoré ako argument berú iné zoskupenie: 
:<syntaxhighlight lang="java">
ArrayList<Integer> a1 = new ArrayList<>();

// ... 

ArrayList<Integer> a2 = new ArrayList<>(a1);
LinkedList<Integer> list = new LinkedList<>(a1);
</syntaxhighlight>

=== Rad a objostranný rad ===

* Trieda <tt>LinkedList<E></tt> okrem rozhrania <tt>List<E></tt> implementuje aj rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Queue.html <tt>Queue<E></tt>] reprezentujúce rady (fronty). Na koniec radu pridávame metódou <tt>add</tt> rovnako ako u zoznamov; metóda <tt>remove</tt> (bez parametrov) vyberie a vráti na výstupe prvok zo začiatku radu; metóda <tt>peek</tt> vráti prvok na začiatku radu bez toho, aby ho z radu vybrala.
* Okrem toho trieda <tt>LinkedList<E></tt> implementuje aj rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Deque.html <tt>Deque<E></tt>] (z angl. ''double-ended queue'') pre obojstranné rady, v ktorých možno prvky pridávať a vyberať z obidvoch strán. Toto rozhranie okrem iného deklaruje metódy <tt>push</tt> a <tt>pop</tt> umožňujúce pracovať s ním ako so zásobníkom.
* Javovské spájané zoznamy typu <tt>LinkedList<E></tt> teda možno použiť aj ako rad, aj ako zásobník.

=== Množiny a použitie metódy <tt>hashCode</tt> ===

Triedy pre množiny sú implementáciami rozhrania [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Set.html <tt>Set<E></tt>] a pri práci s nimi sú podstatné predovšetkým metódy <tt>add</tt>, <tt>contains</tt> a <tt>remove</tt>. Najdôležitejšou implementáciou množín je trieda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/HashSet.html <tt>HashSet<E></tt>]:
* Ide o implementáciu množín pomocou hešovania.
* Pri hešovaní sa využíva metóda <tt>hashCode</tt> vracajúca pre daný objekt nejakú celočíselnú hodnotu, na základe ktorej sa pre tento objekt počíta index do hešovacej tabuľky. Táto metóda je podobne ako metóda <tt>equals</tt> definovaná už v triede <tt>Object</tt> a viaceré štandardné triedy ju prekrývajú. Napríklad <tt>String</tt> vráti ako výstup tejto metódy číslo, ktoré vznikne sčítaním hodnôt jednotlivých znakov prenásobených rôznymi mocninami čísla 31.
* Opäť by malo ísť o metódu, ktorá pre ľubovoľný objekt zakaždým vráti rovnakú hodnotu, takže jej prekrývanie má obyčajne zmysel hlavne pri triedach, ktorých inštancie reprezentujú nemodifikovateľné dáta.
* Ďalšou požiadavkou je, aby pre ľubovoľnú dvojicu objektov, pre ktoré vráti metóda <tt>equals</tt> hodnotu <tt>true</tt>, vrátila metóda <tt>hashCode</tt> rovnaké výstupy. ''To znamená, že metódu <tt>hashCode</tt> je žiadúce prekryť kedykoľvek je prekrytá metóda <tt>equals</tt>.''
* Pre dvojice objektov, pre ktoré <tt>equals</tt> vráti hodnotu <tt>false</tt>, metóda <tt>hashCode</tt> nemusí vrátiť rôzne hodnoty &ndash; implementácia by sa ale mala snažiť o čo najmenšiu pravdepodobnosť takejto situácie, aby boli prvky v hešovacej tabuľke rozdelené čo najrovnomernejšie.

''Príklad'':
<syntaxhighlight lang="java">
public class Name {
    private String givenName;
    private String lastName;

    public Name(String givenName, String lastName) {
        this.givenName = givenName;
        this.lastName = lastName;
    }

    public String getGivenName() {
        return givenName;
    }

    public String getLastName() {
        return lastName;
    }

    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        return o.getClass() == this.getClass() && ((Name) o).givenName.equals(givenName)
                && ((Name) o).lastName.equals(lastName);
    }

    @Override
    public int hashCode() {
        return givenName.hashCode() + 31 * lastName.hashCode();
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Set<Name> set = new HashSet<>();
        while (scanner.hasNext()) {
            String command = scanner.next();
            String givenName = scanner.next();
            String lastName = scanner.next();
            switch (command) {
                case "ADD":
                    set.add(new Name(givenName, lastName));
                    break;
                case "CONTAINS":
                    System.out.println(set.contains(new Name(givenName, lastName)));
                    break;
                case "REMOVE":
                    set.remove(new Name(givenName, lastName));
                    break;
            }
        }
    }
}
</syntaxhighlight>

''Cvičenie'': zakomentujte v kóde triedy <tt>Name</tt> prekrytú metódu <tt>hashCode</tt> a nájdite príklad vstupu, pre ktorý sa v metóde <tt>main</tt> na konzolu vypíšu neočakávané výsledky.

=== Iterátory ===

Všetky triedy implementujúce rozhranie <tt>Collection<E></tt> implementujú aj rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/Iterable.html <tt>Iterable<E></tt>]. Rozhranie <tt>Iterable<T></tt> pritom deklaruje jedinú povinnú metódu <tt>Iterator<T> iterator()</tt>, ktorej výstupom je iterátor &ndash; objekt umožňujúci postupne prechádzať cez nejakú sadu prvkov typu <tt>T</tt>. Pri triedach implementujúcich <tt>Collection<E></tt> je výstupom metódy <tt>iterator()</tt> iterátor, pomocou ktorého možno postupne prechádzať cez všetky prvky daného zoskupenia objektov.
* Zoznamy iterátor prechádza od začiatku po koniec.
* Napríklad pri množinách typu <tt>HashSet</tt> ale nie je určené žiadne špeciálne poradie, v ktorom iterátor prechádza cez ich prvky.

Samotným iterátorom cez prvky typu <tt>E</tt> je pritom inštancia ľubovoľnej triedy implementujúcej rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Iterator.html <tt>Iterator<E></tt>]. To deklaruje predovšetkým nasledujúce tri metódy:
* Metóda <tt>E next()</tt> vráti nasledujúci spomedzi prvkov, cez ktoré iterátor prechádza. Ak už žiaden ďalší prvok neexistuje, vyhodí výnimku typu <tt>NoSuchElementException</tt>.
* Metóda <tt>boolean hasNext()</tt> vráti <tt>true</tt>, ak ešte existuje nejaký ďalší prvok &ndash; čiže v prípade, že nasledujúce volanie metódy <tt>next</tt> nevyhodí výnimku.
* Nepovinná metóda <tt>default void remove()</tt> z prechádzaného zoskupenia odoberie prvok, ktorý bol dosiaľ posledným výstupom metódy <tt>next</tt>. Túto metódu nemusia implementovať všetky triedy implementujúce rozhranie <tt>Iterator<E></tt> &ndash; v takom prípade sa pri pokuse o jej volanie použije východzia implementácia spočívajúca vo vyhodení výnimky typu <tt>UnsupportedOperationException</tt>.

Iterátor si teda možno predstaviť tak, že v každom momente svojej existencie ukazuje na medzeru medzi nejakými dvoma prechádzanými prvkami (resp. na pozíciu pred prvým alebo za posledným prvkom). Po zavolaní metódy <tt>next</tt> iterátor preskočí ďalší prvok a tento prvok vráti na výstupe.

::[[Súbor:Iterator.png]]

Iterátory sú užitočné napríklad v situáciách, keď je potrebné prejsť všetky prvky nejakého zoskupenia, avšak ''samotné toto zoskupenie'' nepotrebujeme výraznejšie meniť (inak ako metódou <tt>remove</tt> iterátora). Počas iterovania samozrejme ''môžeme'' meniť dáta uložené v prechádzaných objektoch; obmedzenie sa týka iba modifikácie referencií na objekty v zoskupení uložených.

''Príklad'': Vypísanie všetkých prvkov spájaného zoznamu celých čísel <tt>list</tt> môžeme pomocou iterátora realizovať napríklad nasledovne:
<syntaxhighlight lang="java">
LinkedList<Integer> list = new LinkedList<>();

// ...

for (Iterator<Integer> it = list.iterator(); it.hasNext(); ) {
    System.out.print(it.next() + " ");
}
</syntaxhighlight>
Takýto cyklus je pre spájané zoznamy omnoho efektívnejší ako cyklus
<syntaxhighlight lang="java">
for (int i = 0; i <= list.size() - 1; i++) {
    System.out.print(list.get(i) + " ");
}
</syntaxhighlight>
v ktorom je potrebné pre všetky <tt>i</tt> vykonať pomalú operáciu <tt>get(i)</tt>. Pre <tt>ArrayList</tt> je naopak efektívnosť oboch cyklov porovnateľná. 

Rozhranie <tt>List<E></tt> okrem metódy <tt>iterator</tt> deklaruje aj metódu <tt>listIterator</tt>, ktorá vráti &bdquo;vylepšený&rdquo; iterátor implementujúci rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/ListIterator.html <tt>ListIterator<E></tt>]. Takýto iterátor umožňuje pohybovať sa po zozname obidvoma smermi.

=== Cyklus <tt>for each</tt> a iterátory ===

Cez prvky inštancií <tt>iterable</tt> tried implementujúcich rozhranie <tt>Iterable<T></tt> možno, podobne ako pri poliach, prechádzať pomocou cyklu <tt>for each</tt>:
<syntaxhighlight lang="java">
for (T x : iterable) {
    // ...
}
</syntaxhighlight>
V takom prípade je (na rozdiel od polí) tento cyklus ekvivalentný cyklu
<syntaxhighlight lang="java">
for (Iterator<T> it = iterable.iterator(); it.hasNext(); ) {
    T x = it.next();
    // ...
}
</syntaxhighlight>
(za predpokladu, že <tt>it</tt> je identifikátor rôzny od všetkých identifikátorov použitých v pôvodnom programe).

=== Definovanie vlastných iterátorov ===

''Príklad'': nasledujúca generická trieda <tt>MyArrayList<E></tt> sa od bežného <tt>ArrayList</tt>-u líši iba implementáciou metódy <tt>iterator</tt>. Tá vráti iterátor novodefinovaného typu <tt>NullSkippingArrayListIterator</tt>, ktorý pri prechádzaní prvkov <tt>ArrayList</tt>-u vynecháva všetky výskyty referencie <tt>null</tt>. Takéto prekrytie metódy <tt>iterator</tt> v podtriede <tt>ArrayList</tt>-u nie je dobrá prax, keďže sa ním poruší špecifikácia metódy <tt>iterator</tt> v rozhraní <tt>List<E></tt>; krajšie by bolo napríklad pridať novú metódu <tt>nullSkippingIterator</tt> za súčasného ponechania pôvodnej metódy <tt>iterator</tt>. V nasledujúcom ale ide aj o ukážku toho, že prekrytie metódy <tt>iterator</tt> má vplyv na správanie cyklu <tt>for each</tt>.

<syntaxhighlight lang="java">
import java.util.*;

public class NullSkippingArrayListIterator<E> implements Iterator<E> {
    private ArrayList<E> a;
    private int nextIndex;

    public NullSkippingArrayListIterator(ArrayList<E> a) {
        this.a = a;
        skipNullValues();
    }

    private void skipNullValues() {
        while (nextIndex <= a.size() - 1 && a.get(nextIndex) == null) {
            nextIndex++;
        }
    }

    @Override
    public boolean hasNext() {
        return nextIndex <= a.size() - 1;
    }

    @Override
    public E next() {
        E result = null;
        if (hasNext()) {
            result = a.get(nextIndex++);
        } else {
            throw new NoSuchElementException();
        }
        skipNullValues();
        return result;
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
import java.util.*;

public class MyArrayList<E> extends ArrayList<E> {

    @Override
    public Iterator<E> iterator() {
        return new NullSkippingArrayListIterator<>(this);
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Trieda {

    public static void main(String[] args) {
        MyArrayList<Integer> a = new MyArrayList<>();
        a.add(1);
        a.add(null);
        a.add(2);
        a.add(null);
        a.add(null);
        a.add(3);
        a.add(null);
        for (Integer x : a) {
            System.out.print(x + " ");
        }
        System.out.println(); 
        System.out.println(a); // Zmena sa prejavi aj tu, pretoze toString pre ArrayList vyuziva iterator.
    }
}
</syntaxhighlight>

=== Zobrazenia ===

Rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Map.html <tt>Map<K, V></tt>] reprezentuje zobrazenia, ktoré priraďujú nejakej množine ''kľúčov'' (angl. ''keys'') typu <tt>K</tt> ich ''obrazy'' (resp. ''hodnoty'', angl. ''values'') typu <tt>V</tt>. Najdôležitejšou implementáciou tohto rozhrania je trieda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/HashMap.html <tt>HashMap</tt>] založená na hešovaní. Kľúčom aj jeho obrazom tu môže byť aj <tt>null</tt>. Podobne ako <tt>HashSet</tt> využíva táto trieda metódy <tt>hashCode</tt> a <tt>equals</tt> pre jednotlivé kľúče. Niektoré poskytované metódy:
* Metóda <tt>public V get(Object key)</tt> vráti obraz kľúča <tt>key</tt> pri danom zobrazení, ak je definovaný; v opačnom prípade vráti <tt>null</tt>.
* Metóda <tt>public V put(K key, V value)</tt> nastaví obraz kľúča <tt>key</tt> na hodnotu <tt>value</tt>.
* Metóda <tt>public boolean containsKey(Object key)</tt> zistí, či je <tt>key</tt> kľúčom, t. j. či je preň definovaný obraz v danom zobrazení.
* Metóda <tt>public Set<K> keySet()</tt> vráti množinu všetkých kľúčov.
* Metóda <tt>public int size()</tt> vráti počet všetkých dvojíc kľúč/obraz v danom zobrazení.
* ...

''Príklad'': nasledujúci program spočíta počty výskytov slov v nejakom vstupnom texte (a na konci ich vypíše v nejakom ľubovoľnom poradí).
<syntaxhighlight lang="java">
import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String word = scanner.next();
            if (map.containsKey(word)) {
                map.put(word, map.get(word) + 1);
            } else {
                map.put(word, 1);
            }
        }
        System.out.println("Pocet roznych slov: " + map.size() + ".");
        for (String word : map.keySet()) {  
            System.out.println("Pocet vyskytov slova \"" + word + "\": " + map.get(word) + ".");
        }
    }
}
</syntaxhighlight>

=== Usporiadané množiny a zobrazenia na nich ===

Java Collections obsahuje aj rozhrania [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/SortedSet.html <tt>SortedSet<E></tt>] resp. [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/SortedMap.html <tt>SortedMap<K, V></tt>] rozširujúce rozhrania <tt>Set<E></tt> resp. <tt>Map<K, V></tt>. Ide o reprezentácie úplne usporiadaných množín resp. zobrazení s úplným usporiadaním množiny kľúčov. Najdôležitejšími implementáciami týchto rozhraní sú triedy [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/TreeSet.html <tt>TreeSet<E></tt>] resp. [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/TreeMap.html <tt>TreeMap<K, V></tt>].
* V základnom variante &ndash; to jest pri použití konštruktora triedy <tt>TreeSet</tt> alebo <tt>TreeMap</tt> bez parametrov &ndash; sa predpokladá, že všetky dvojice prvkov, ktoré budú pridávané do množiny resp. budú zohrávať úlohu kľúčov pri zobrazení, sú navzájom porovnateľné pomocou metódy <tt>compareTo</tt> (použije sa teda tzv. ''prirodzené usporiadanie'' prvkov). Typicky sa teda <tt>TreeSet<E></tt> a <tt>TreeMap<K, V></tt> používajú v prípade, keď typ <tt>E</tt> resp. <tt>K</tt> implementuje rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/Comparable.html <tt>Comparable<E></tt>] resp. <tt>Comparable<K></tt>. Nie je to ale striktne vyžadované: pomocou konštruktora bez parametrov technicky môžeme vytvoriť napríklad aj inštanciu typu <tt>TreeSet<Object></tt>. Akonáhle však do takejto množiny pridáme dvojicu neporovnateľných objektov, dôjde k vyhodeniu výnimky typu [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/ClassCastException.html <tt>ClassCastException</tt>].
* Od prirodzeného usporiadania sa tu vyžaduje, aby bolo konzistentné s metódou <tt>equals</tt>. Pre všetky dvojice objektov <tt>e1, e2</tt> daného typu by teda mal mať logický výraz <tt>e1.compareTo(e2) == 0</tt> vždy tú istú booleovskú hodnotu ako <tt>e1.equals(e2)</tt>. Štandardné triedy implementujúce rozhranie <tt>Comparable</tt>, ako napríklad <tt>Integer</tt> alebo <tt>String</tt>, túto požiadavku spĺňajú.
* Pri iterovaní cez usporiadanú množinu, ako aj cez množinu kľúčov zobrazenia typu <tt>SortedMap</tt>, sa prvky prechádzajú vo vzostupnom poradí (čo môže byť užitočné napríklad aj v našom príklade s počítaním výskytov slov).

=== Komparátory ===

Alternatívne možno pri triedach <tt>TreeSet<E></tt> a <tt>TreeMap<K, V></tt> namiesto prirodzeného usporiadania prvkov použiť aj novodefinované usporiadanie (bez ohľadu na to, či na prvkoch daného typu existuje alebo neexistuje prirodzené usporiadanie). V takom prípade vytvoríme inštanciu <tt>TreeSet<E></tt> resp. <tt>TreeMap<K, V></tt> pomocou konštruktora, ktorý ako argument berie tzv. ''komparátor'' prvkov typu <tt>E</tt> resp. <tt>K</tt> (alebo ich nadtried). 

Pod komparátorom prvkov typu <tt>T</tt> rozumieme ľubovoľnú inštanciu triedy implementujúcej rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Comparator.html <tt>Comparator<T></tt>]. 
* Toto rozhranie vyžaduje povinnú implementáciu jedinej metódy &ndash; a to metódy <tt>int compare(T o1, T o2)</tt> na porovnanie dvojice prvkov typu <tt>T</tt>.
* Výstupom tejto metódy má byť záporné číslo, nula, resp. kladné číslo podľa toho, či je prvý argument menší, rovnako veľký, alebo väčší ako druhý argument.
* Od programátora sa vyžaduje splnenie zvyčajných vlastností úplného usporiadania alebo aspoň úplného predusporiadania (detaily možno nájsť v dokumentácii). Pri použití v <tt>TreeSet</tt> a <tt>TreeMap</tt> sa rovnako ako pri prirodzenom usporiadaní vyžaduje konzistencia s metódou <tt>equals</tt>.

''Príklad'':
<syntaxhighlight lang="java">
import java.util.*;

public class DualComparator implements Comparator<Integer> {

    @Override
    public int compare(Integer o1, Integer o2) {
        return o2.compareTo(o1);
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<>(new DualComparator());
        set.add(0);
        set.add(1);
        set.add(2);
        set.add(3);
        for (Integer x : set) {
            System.out.print(x + " ");  // Vypise 3 2 1 0
        }
    }
}
</syntaxhighlight>

=== Trieda <tt>Collections</tt> ===

Trieda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Collections.html <tt>Collections</tt>] obsahuje viacero užitočných statických metód na prácu s Java Collections (ide o akúsi obdobu triedy <tt>Arrays</tt> pre polia). Sú v nej definované napríklad:
* Metódy <tt>sort</tt> na utriedenie zoznamu (v dvoch verziách: s použitím prirodzeného usporiadania v prípade, že typ <tt>E</tt> prvkov zoznamu implementuje <tt>Comparable<E></tt>, ako aj s použitím komparátora).
:<syntaxhighlight lang="java">import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        List<Integer> a = new ArrayList<>();
        a.add(6);
        a.add(1);
        a.add(3);
        a.add(2);
        a.add(3);
        Collections.sort(a);
        System.out.println(a);
        Collections.sort(a, new DualComparator());
        System.out.println(a);
    }
}
</syntaxhighlight>
* Metódy <tt>shuffle</tt> na náhodné premiešanie zoznamu.
* Metódu <tt>reverse</tt> na otočenie zoznamu.
* ...

== Vnorené, lokálne a anonymné triedy ==

Triedy pre iterátory a komparátory &ndash; napríklad tie, ktoré sme tvorili vyššie &ndash; sú dosť často triedami &bdquo;na jedno použitie&rdquo;. Takéto triedy, ktoré sú viac-menej limitované na použitie v jednej inej triede alebo metóde, môžu pomerne značne zneprehľadňovať štruktúru celého projektu. V podobných situáciách je preto lepšie využiť črtu jazyka Java, s ktorou sme sa doposiaľ nestretli: možnosť tvoriť triedy, ktoré sú súčasťou iných tried alebo dokonca metód. Obmedzíme sa tu len na nutné základy tejto problematiky &ndash; viac sa možno dočítať [https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html tu]. 
 
=== Statické vnorené triedy ===

Trieda definovaná vo vnútri inej triedy sa v Jave nazýva ''vnorenou triedou'' (angl. ''nested class''). Takáto trieda môže alebo nemusí byť statická. V prípade, že statická je, správa sa táto trieda veľmi podobne ako ľubovoľná iná trieda &ndash; k statickej vnorenej triede <tt>StatickaVnorenaTrieda</tt> definovanej v triede <tt>VonkajsiaTrieda</tt> ale mimo triedy <tt>VonkajsiaTrieda</tt> pristupujeme cez <tt>VonkajsiaTrieda.StatickaVnorenaTrieda</tt>. Užitočnou novinkou je možnosť nastaviť vnoreným triedam prístupový modifikátor <tt>private</tt>, čím sa trieda stane viditeľnou iba z vonkajšej triedy, v ktorej je definovaná.

<syntaxhighlight lang="java">
public class VonkajsiaTrieda {

    private static class StatickaVnorenaTrieda1 {
        // ...
    }

    public static class StatickaVnorenaTrieda2 {
        // ...
    }

    public void metoda() {
        StatickaVnorenaTrieda1 o1 = new StatickaVnorenaTrieda1();
        StatickaVnorenaTrieda2 o2 = new StatickaVnorenaTrieda2();
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        VonkajsiaTrieda.StatickaVnorenaTrieda2 x = new VonkajsiaTrieda.StatickaVnorenaTrieda2();
    }
}
</syntaxhighlight>

Statickosť vnorených tried znamená predovšetkým to, že k premenným a metódam inštancií triedy, v ktorej sú definované, pristupujú v podstate ako ktorákoľvek iná trieda (t. j. iba prostredníctvom tvorby inštancií vonkajšej triedy).

=== Vnútorné triedy ===

Nestatické vnorené triedy sa v Jave nazývajú aj ''vnútornými triedami'' (angl. ''inner classes''). Tieto triedy patria jednotlivým inštanciám vonkajšej triedy a majú tak prístup k ich premenným a metódam.

''Ukážka'':
<syntaxhighlight lang="java">
public class VonkajsiaTrieda {
    private int x, y;

    private class VnutornaTrieda1 {
        private int y;

        public void f() {
            y = x + VonkajsiaTrieda.this.y; // Premenna y vnutornej triedy skryva metodu vonkajsej triedy.
        }

        public int getY() {
            return y;
        }
    }

    public class VnutornaTrieda2 {

        public void vypis() {
            System.out.println("Som vnutorna trieda.");
        }
    }

    public void metoda() {
        VnutornaTrieda1 o1 = new VnutornaTrieda1();
        x = 2;
        y = 3;
        o1.f();
        System.out.println(o1.getY());
        VnutornaTrieda2 o2 = new VnutornaTrieda2();
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Trieda {

    public static void main(String[] args) {
        VonkajsiaTrieda o = new VonkajsiaTrieda();
        o.metoda();
        VonkajsiaTrieda.VnutornaTrieda2 o2 = o.new VnutornaTrieda2();
        o2.vypis();
    }
}
</syntaxhighlight>

=== Lokálne triedy ===

Dôležitejšie, než vnútorné triedy pre nás budú tzv. ''lokálne triedy'' (angl. ''local classes''). Tie sú podobným konceptom ako vnútorné triedy, avšak definujú sa ''vo vnútri metódy'' (resp. bloku) a pod svojím názvom sú prístupné iba tam.
* Lokálne triedy sa definujú vo vnútri bloku medzi ostatnými príkazmi, ale inak je ich definícia veľmi podobná definícii ktorejkoľvek inej triedy. Keďže sú tieto triedy viditeľné iba v rámci daného bloku, nepíše sa pred kľúčové slovo <tt>class</tt> žiaden modifikátor prístupu.
* Inštancie týchto tried sú použiteľné aj mimo bloku, v ktorom je lokálna trieda definovaná (za ich typ tam možno považovať napríklad nejakú nelokálnu nadtriedu lokálnej triedy alebo implementované rozhranie).
* Z lokálnych tried možno pristupovať aj k lokálnym premenným metódy, v ktorej je táto trieda definovaná. Avšak to iba za predpokladu, že sú tieto premenné ''finálne'' alebo &bdquo;''v podstate finálne''&rdquo; (angl. ''effectively final''), to jest po inicializácii sa už ďalej nemení ich hodnota. Pokiaľ je touto premennou objekt, znamená táto požiadavka nemenenie referencie; dáta, na ktoré referencia ukazuje, sa meniť môžu. Lokálne premenné, ku ktorým sa z lokálnej triedy pristupuje, samozrejme musia byť definované ešte pred definíciou danej lokálnej triedy.
* Lokálne triedy sú tak vcelku užitočným nástrojom na tvorbu &bdquo;jednorazových&rdquo; tried pre iterátory alebo komparátory.

''Príklad'': Triedu <tt>NullSkippingArrayListIterator<E></tt>, ktorú sme vracali ako iterátor v triede <tt>MyArrayList<E></tt>, môžeme napísať ako lokálnu triedu v metóde <tt>iterator</tt> triedy <tt>MyArrayList<E></tt>.
<syntaxhighlight lang="java">
import java.util.*;

public class MyArrayList<E> extends ArrayList<E> {

    @Override
    public Iterator<E> iterator() {
        class NullSkippingArrayListIterator<E> implements Iterator<E> {
            private int nextIndex;

            public NullSkippingArrayListIterator() {
                skipNullValues();
            }

            private void skipNullValues() {
                while (nextIndex <= MyArrayList.this.size() - 1 && MyArrayList.this.get(nextIndex) == null) {
                    nextIndex++;
                }
            }

            @Override
            public boolean hasNext() {
                return nextIndex <= MyArrayList.this.size() - 1;
            }

            @Override
            public E next() {
                E result = null;
                if (hasNext()) {
                    result = (E) MyArrayList.this.get(nextIndex++);
                } else {
                    throw new NoSuchElementException();
                }
                skipNullValues();
                return result;
            }
        }

        return new NullSkippingArrayListIterator<>();
    }
}
</syntaxhighlight>

''Príklad'': Komparátor <tt>DualComparator</tt> ako lokálna trieda.
<syntaxhighlight lang="java">
import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        class DualComparator implements Comparator<Integer> {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        }
        List<Integer> a = new ArrayList<>();
        a.add(6);
        a.add(1);
        a.add(3);
        a.add(2);
        a.add(3);
        Collections.sort(a, new DualComparator());
        System.out.println(a);
    }
}
</syntaxhighlight>

=== Anonymné triedy ===

Ak sa aj v rámci metódy inštancia lokálnej triedy vytvára iba raz, je často užitočné spojiť definíciu lokálnej triedy a vytvorenie jej inštancie do jedného príkazu. To umožňuje mechanizmus tzv. ''anonymných tried'' (angl. ''anonymous classes''). Takáto lokálna trieda ani nemá svoj názov, vytvorí sa iba jej inštancia. Syntax vytvorenia inštancie anonymnej triedy je nasledujúca:
* Za kľúčovým slovom <tt>new</tt> nasleduje volanie konštruktora nadtriedy, prípadne (častejšie) názov implementovaného rozhrania nasledovaný prázdnymi zátvorkami (akoby &bdquo;konštruktor bez parametrov&rdquo;, akurát v tomto prípade ide o rozhranie).
* Následne sa uvedie samotná definícia triedy.
* Za uzatváracou zloženou zátvorkou <tt>}</tt> definície triedy sa uvedie bodkočiarka, ktorou sa ukončí príkaz na vytvorenie nového objektu (prípadne príkaz obsahujúci <tt>new</tt> pokračuje iným spôsobom).

Anonymné triedy sú oproti lokálnym triedam obmedzené v tom, že pre ne nemožno písať konštruktory. Možno ale inicializovať ich premenné na dané hodnoty.

''Príklad'': Iterátor pre <tt>MyArrayList</tt> ako anonymná trieda.
<syntaxhighlight lang="java">
import java.util.*;

public class MyArrayList<E> extends ArrayList<E> {

    @Override
    public Iterator<E> iterator() {
        return new Iterator<>() {
            private int nextIndex;

            private void skipNullValues() {
                while (nextIndex <= MyArrayList.this.size() - 1 && MyArrayList.this.get(nextIndex) == null) {
                    nextIndex++;
                }
            }

            @Override
            public boolean hasNext() {
                skipNullValues();
                return nextIndex <= MyArrayList.this.size() - 1;
            }

            @Override
            public E next() {
                skipNullValues();
                E result = null;
                if (hasNext()) {
                    result = (E) MyArrayList.this.get(nextIndex++);
                } else {
                    throw new NoSuchElementException();
                }
                skipNullValues();
                return result;
            }
        }; 
    }
}
</syntaxhighlight>
Alternatívne by sme mohli metódu <tt>skipNullValues</tt> prepísať tak, aby vracala <tt>int</tt> a jej výstup použiť na inicializáciu premennej <tt>nextIndex</tt>; v takom prípade by už volania metódy <tt>skipNullValues</tt> na začiatku metód <tt>next</tt> a <tt>hasNext</tt> neboli nutné.

''Príklad'': Komparátor ako anonymná trieda.
<syntaxhighlight lang="java">
import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        List<Integer> a = new ArrayList<>();
        a.add(6);
        a.add(1);
        a.add(3);
        a.add(2);
        a.add(3);
        Collections.sort(a, new Comparator<>(){
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println(a);
    }
}
</syntaxhighlight>
V tomto prípade dokonca existuje ešte podstatne kratší zápis pomocou tzv. ''lambda výrazov'' &ndash; nimi sa budeme zaoberať neskôr v priebehu tohto semestra.
=Letný semester, prednáška č. 6=
== Oznamy ==

* Počas najbližších cvičení, čiže ''v stredu 24. marca od 11:30 do 13:00'' bude prebiehať druhý test. Bude pozostávať z troch úloh zameraných na látku ''z prvých piatich týždňov'', s dôrazom na látku zo štvrtého a piateho týždňa. Po dobu riešenia testu je potrebná účasť na stretnutí &bdquo;Cvičenia&rdquo; v MS Teams.
* Druhú bonusovú úlohu je potrebné odovzdať ''do stredy 24. marca, 11:30'' (čiže do začiatku stredajších cvičení).
* Druhú domácu úlohu je potrebné odovzdať ''do pondelka 29. marca, 9:00'' (čiže do začiatku siedmej prednášky).

== Tvorba dokumentácie: Javadoc ==

Systém Javadoc umožňuje automatické generovanie dokumentácie k balíku, triede a pod. v štandardnom formáte, aký používa aj [https://docs.oracle.com/en/java/javase/15/docs/api/index.html dokumentácia k Java API]. Program <tt>javadoc</tt> je štandardnou súčasťou Javy a možno ho nájsť v rovnakom priečinku ako kompilátor <tt>javac</tt> a interpreter <tt>java</tt>. Javadoc dokumentáciu generuje na základe komentárov pri jednotlivých triedach, metódach, premenných, atď. Tieto komentáre musia byť v nasledujúcom špeciálnom formáte:
* Komentár musí byť ohraničený značkami <tt>/**</tt> a <tt>*/</tt> (na začiatku sú teda dve hviezdičky namiesto bežnej jednej) a každý riadok komentára sa tiež musí začínať hviezdičkou.
* Musí byť umiestnený bezprostredne pred triedou, metódou a pod., ku ktorej sa vzťahuje.
* Časť textu komentára končiaca prvou bodkou je stručné zhrnutie, ktoré sa uvádza aj v prehľadoch metód, tried, atď.; v samotnej dokumentácii danej triedy resp. metódy sa potom uvádza kompletný text.
* Ako súčasť Javadoc komentára možno (nepovinne) použiť niekoľko špecializovaných značiek &ndash; napríklad <tt>@param</tt> pre opis parametra metódy, <tt>@return</tt> pre opis výstupu metódy, <tt>@throws</tt> pre opis vyhadzovaných výnimiek, atď.

''Príklad'':
<syntaxhighlight lang="java">
/**
 * Trieda obsahujuca velmi dolezite a zmysluplne metody na pracu s celymi cislami. Napriklad druhu mocninu a v buducich
 * verziach mozno aj scitanie.
 */
public class Trieda {

    /**
     * Metoda pocitacuja druhu mocninu celociselneho vstupneho parametra. Vypocet je implementovany prenasobenim
     * vstupneho cisla so sebou samym.
     *
     * @param n Celociselny vstup.
     * @return  Druha mocnina cisla n.
     */
    public int sqr(int n) {
        return n * n;
    }

    /**
     * Metoda na scitanie dvojice celociselnych vstupov. Je implementovana ako vyhodenie vynimky typu Exception.
     *
     * @param n Prvy vstupny parameter.
     * @param m Druhy vstupny parameter.
     * @return  Nepodstatne...
     * @throws Exception V pripade nespravneho pouzitia vyhodi vynimku typu Exception.
     */
    public int add(int n, int m) throws Exception {
        throw new Exception();
    }

}
</syntaxhighlight>
Pre triedu alebo balík tried s komentármi vo formáte Javadoc možno pomocou programu <tt>javadoc</tt> vygenerovať samotnú dokumentáciu vo formáte HTML. 
* Z príkazového riadku sa tak dá urobiť volaním programu <tt>javadoc</tt> s vhodnými parametrami (treba sa nastaviť do adresára obsahujúceho priečinok s daným balíkom resp. danú triedu):
:<syntaxhighlight lang="dosbatch">
javadoc balik
javadoc Trieda.java
</syntaxhighlight> 
: Toto volanie programu <tt>javadoc</tt> často vygeneruje pomerne veľké množstvo súborov. Je preto užitočné nastaviť priečinok, do ktorého sa má dokumentácia vygenerovať, pomocou možnosti <tt>-d</tt>. 
:<syntaxhighlight lang="dosbatch">
javadoc -d doc balik
javadoc -d doc Trieda.java
</syntaxhighlight>
* Z IntelliJ cez <tt>Tools --> Generate JavaDoc...</tt>

Pri východzích nastaveniach sa dokumentácia vytvára iba pre položky s modifikátorom prístupu <tt>public</tt> alebo <tt>protected</tt>, pretože predovšetkým tieto tvoria API pre ostatné triedy. V prípade potreby možno toto správanie zmeniť:
* Z príkazového riadku použitím jedného z prepínačov <tt>-private</tt>, <tt>-package</tt>, <tt>-protected</tt> (ekvivalentné nepoužitiu žiadneho prepínača), alebo <tt>-public</tt>. V takom prípade sa dokumentácia vygeneruje ku všetkým položkám s príslušným alebo &bdquo;verejnejším&rdquo; modifikátorom prístupu.
* V IntelliJ možno tieto nastavenia meniť v dialógovom okne, ktoré sa zobrazí pred vygenerovaním dokumentácie.

== Testovanie programov ==
Pod ''testovaním'' sa rozumie systematický spôsob hľadania chýb v programe spočívajúci vo vytvorení niekoľkých testov pozostávajúcich zo vstupov a očakávaných výstupov na týchto vstupoch; program je následne (podobne ako na testovači) spustený na každom zo vstupov a jeho výstupy sú konfrontované s očakávanými.
* Cieľom testovania je teda preukázať, že program ''nepracuje'' podľa špecifikácie (aby sme potom vedeli chybu nájsť a opraviť).
* Ak program prejde všetkými testmi, ''nejde'' v žiadnom prípade o dôkaz toho, že program pracuje správne. Dokázať správnosť programu možno iba pomocou metód ''formálnej verifikácie'', ktoré značne presahujú rámec tohto predmetu (a pre ich výpočtovú náročnosť sa v súčasnosti uplatňujú zvyčajne iba pri tvorbe kritických aplikácií).
* Už aj dobre navrhnutými testmi ale možno početnosť chýb podstatne znížiť.

Typický proces testovania programu alebo jeho časti možno zhrnúť nasledovne:
* Vytvorí sa niekoľko testov pozostávajúcich zo vstupu, očakávaného správneho výstupu a obyčajne aj opisu daného testu (aby bolo jasné, čo sa chce daným testom preveriť).
* Program (resp. napríklad testovaná metóda) sa pre každý z testov spustí na príslušnom vstupe a takto získaný výstup sa porovná s očakávanou odpoveďou.
* ''Tradičný prístup'': najprv sa napíše kód, potom sa vytvárajú testy.
* ''Test-driven development'': najprv sa napíšu testy a až následne sa programuje kód, ktorý ich dokáže splniť.

=== &bdquo;White-box&rdquo; testovanie ===

Pod ''&bdquo;white-box&rdquo; testovaním'' sa rozumie prístup, pri ktorom sa testy vytvárajú na základe kódu; cieľom je pritom preveriť všetky významné vetvy výpočtu.
* Pri cykloch napríklad možno preveriť prípady, keď sa vykoná 0 iterácií, 1 iterácia, 2 iterácie, nejaký väčší pevný počet iterácií a prípadne maximálny počet iterácií (ak niečo také dáva zmysel).
* Pri podmienkach sa preverí ako prípad, keď je táto podmienka splnená, tak aj prípad, keď je nesplnená.
* ...

Nevýhodou tohto prístupu je, že sústredením sa na kód môžeme pozabudnúť na prípady, na ktoré sa v kóde nemyslelo.
Napríklad nasledujúca metóda úplne nespĺňa svoju špecifikáciu:
<syntaxhighlight lang="java">
    /**
     * Metoda pocitajuca pocet retazcov vo vstupnom zozname retazcov, ktore obsahuju dany podretazec. Hladany
     * podretazec musi byt rozny od null. Vstupny zoznam ostane po vykonani metody nezmeneny.
     *
     * @param list      Vstupny zoznam retazcov, ktorym moze byt lubovolna instancia typu List&lt;String&gt;.
     * @param substring Podretazec, ktoreho vyskyty v retazcoch sa pocitaju.
     * @return          Pocet retazcov zo zoznamu list, ktore obsahuju podretazec substring.
     * @throws IllegalArgumentException V pripade, ze je niektory z argumentov rovny null, vznikne vynimka typu
     * IllegalArgumentException.
     */
    public static int numberOfSubstringContainingStrings(List<String> list, String substring) {
        if (list == null || substring == null) {
            throw new IllegalArgumentException();
        }
        int count = 0;
        for (String s : list) {
            if (s.contains(substring)) {
                count++;
            }
        }
        return count;
    }
</syntaxhighlight>

=== &bdquo;Black-box&rdquo; testovanie ===

Pod ''&bdquo;black-box&rdquo; testovaním'' sa naopak rozumie prístup, pri ktorom sa sada testov vytvorí len na základe špecifikácie programu. V testoch sa pritom snažíme zachytiť okrajové aj typické prípady.

Uvažujme napríklad neformálnu špecifikáciu metódy <tt>remove</tt> rovnakú ako vyššie:
<syntaxhighlight lang="java">
    /**
     * Metoda pocitajuca pocet retazcov vo vstupnom zozname retazcov, ktore obsahuju dany podretazec. Hladany
     * podretazec musi byt rozny od null. Vstupny zoznam ostane po vykonani metody nezmeneny.
     * 
     * @param list      Vstupny zoznam retazcov, ktorym moze byt lubovolna instancia typu List&lt;String&gt;.
     * @param substring Podretazec, ktoreho vyskyty v retazcoch sa pocitaju.
     * @return          Pocet retazcov zo zoznamu list, ktore obsahuju podretazec substring.
     * @throws IllegalArgumentException V pripade, ze je niektory z argumentov rovny null, vznikne vynimka typu
     * IllegalArgumentException.
     */
    public static int numberOfSubstringContainingStrings(List<String> list, String substring) {
        // ...
    }
</syntaxhighlight>

K nej môžeme zhotoviť napríklad nasledujúcu sadu testovacích vstupov:
# Prázdny zoznam <tt>list</tt>, ľubovoľný reťazec <tt>substring</tt>.
# Jednoprvkový zoznam <tt>list</tt> obsahujúci iba reťazec rovný reťazcu <tt>substring</tt>.
# Jednoprvkový zoznam <tt>list</tt>, ktorého jediný reťazec neobsahuje podreťazec <tt>substring</tt>.
# Dlhší zoznam obsahujúci niekoľko reťazcov s výskytmi podreťazca <tt>substring</tt> a niekoľko reťazcov bez výskytu tohto podreťazca. Medzi reťazcami zoznamu obsahujúcimi podreťazec <tt>substring</tt> by mali byť také, ktoré tento podreťazec obsahujú na začiatku, v strede, na konci a viackrát.
# Reťazec <tt>substring</tt> prázdny, zoznam <tt>list</tt> ľubovoľný.
# Reťazec <tt>substring</tt> rovný <tt>null</tt>, zoznam <tt>list</tt> ľubovoľný.
# Zoznam <tt>list</tt> rovný <tt>null</tt>, reťazec <tt>substring</tt> ľubovoľný.
# Zoznam obsahujúci prázdne reťazce, reťazec <tt>substring</tt> ľubovoľný.
# Zoznam obsahujúci výskyty <tt>null</tt>, reťazec <tt>substring</tt> ľubovoľný.
# Veľmi dlhý zoznam náhodne vygenerovaných reťazcov, reťazec <tt>substring</tt> ľubovoľný.
# Zoznam veľmi dlhých náhodne vygenerovaných reťazcov, dlhý náhodne vygenerovaný reťazec <tt>substring</tt>.
# ...

Popri tom je žiadúce v rôznych testoch použiť zoznamy rôznych typov, napr. aspoň <tt>ArrayList</tt> a <tt>LinkedList</tt>.

===JUnit===

Systém JUnit umožňuje vytvárať špeciálne triedy obsahujúce testy iných tried.
* Sadu testov možno ľahko automaticky spustiť a vyhodnotiť ich výsledky.
* Podporované väčšinou IDE pre Javu.

JUnit nie je priamo súčasťou Javy, ale jeho verziu JUnit 4 možno nájsť napríklad aj v typickej inštalácii IntelliJ. Prostredie IntelliJ má dobrú podporu aj pre najnovšiu verziu JUnit 5, tú je ale potrebné stiahnuť pomocou nástroja Maven. V nasledujúcom používame (stále hojne rozšírenú) verziu JUnit 4. O použití JUnit z príkazového riadku sa možno dočítať napríklad [http://junit.sourceforge.net/doc/cookbook/cookbook.htm tu].
* [https://junit.org/junit4/javadoc/latest/index.html Dokumentácia k JUnit.]

V prostredí IntelliJ je pred prácou s JUnit potrebné vykonať nasledujúce úkony:
* Cez <tt>File --> Project Structure... -> Libraries -> + -> Java</tt> pridať do projektu ako knižnice balíky <tt>hamcrest-core-1.3.jar</tt> a <tt>junit-4.12.jar</tt>, ktoré by mali byť umiestnené v podpriečinku <tt>lib</tt> koreňového priečinka inštalácie IntelliJ (čísla verzií sa v závislosti od verzie IntelliJ môžu trochu líšiť, ale podstatné je, aby verzia JUnit začínala číslom 4).
* Vytvoriť nový priečinok (napríklad <tt>tests</tt>) na rovnakej úrovni ako <tt>src</tt>. Tento adresár je následne potrebné označiť ako koreňový pre testy pomocou možnosti <tt>Mark Directory as --> Test Sources Root</tt> z kontextovej ponuky, ktorá sa zjaví po kliknutí na adresár pravou myšou.

Samotný test pre triedu <tt>Trieda</tt> potom vytvoríme takto:
* V zdrojovom kóde klikneme na názov triedy <tt>Trieda</tt> a použijeme klávesovú skratku <tt>Alt+Enter</tt>.
* Zvolíme možnosť <tt>Create Test</tt>.
* V dialógovom okne vyberieme verziu <tt>JUnit 4</tt> a ako názov triedy zvolíme napríklad <tt>TriedaTest</tt>.
* Po potvrdení vznikne nová trieda <tt>TriedaTest.java</tt>, ktorá bude namiesto pod priečinkom <tt>src</tt> umiestnená pod priečinkom <tt>tests</tt>.
* (Alternatívne možno namiesto predchádzajúcich štyroch krokov jednoducho vytvoriť novú triedu pod priečinkom <tt>tests</tt>.)
* Vo vytvorenej triede môžeme napísať niekoľko testov podobných ako v ukážke nižšie. 
* Po spustení triedy <tt>TriedaTest</tt> sa spustia všetky testy a v okne <tt>Run</tt> sa zobrazia ich výsledky.

Príklad niekoľkých testov pre metódu <tt>numberOfSubstringContainingStrings</tt> opísanú vyššie (statický import statických ''metód'' z triedy &ndash; pri použití <tt>*</tt> ide o všetky takéto metódy &ndash; znamená, že sa tieto metódy budú dať volať iba ich názvom, bez potreby uvedenia názvu triedy):
<syntaxhighlight lang="java">
import org.junit.*;
import static org.junit.Assert.*;
import java.util.*;

public class TriedaTest {

    @Test
    public void testEmpty() {
        List<String> list = new ArrayList<>();
        String substring = "retazec";

        int expectedResult = 0;
        List<String> expectedList = new ArrayList<>();

        int result = Trieda.numberOfSubstringContainingStrings(list, substring);

        assertEquals(result, expectedResult);
        assertTrue(expectedList.equals(list));  // To iste sa da napisat aj cez assertEquals.
    }

    @Test
    public void testSubstringOnly() {
        List<String> list = new LinkedList<>();
        list.add("retazec");
        String substring = "retazec";

        int expectedResult = 1;
        List<String> expectedList = new LinkedList<>(list);

        int result = Trieda.numberOfSubstringContainingStrings(list, substring);

        assertEquals(result, expectedResult);
        assertTrue(list.equals(expectedList));
    }

    @Test(expected = IllegalArgumentException.class)
    public void testSubstringNull() {
        List<String> list = new ArrayList<>();
        list.add("retazec1");
        list.add("retazec2");
        String substring = null;

        List<String> expectedList = new ArrayList<>(list);

        Trieda.numberOfSubstringContainingStrings(list, substring);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testListNull() {
        List<String> list = null;
        String substring = "retazec";

        Trieda.numberOfSubstringContainingStrings(list, substring);
    }

    @Test
    public void testListContainsNull() {
        List<String> list = new LinkedList<>();
        list.add("retazec1");
        list.add(null);
        list.add("retazec2");
        String substring = "retazec";

        int expectedResult = 2;
        List<String> expectedList = new LinkedList<>(list);

        int result = Trieda.numberOfSubstringContainingStrings(list, substring);

        assertEquals(result, expectedResult);
        assertTrue(list.equals(expectedList));
    }

}
</syntaxhighlight>
Tento príklad je možné rôzne vylepšovať:
* Opakujúce sa časti kódu môžeme dať do pomocných metód.
* Môžeme v triede <tt>ProgTest</tt> definovať premenné, konštruktor, ako aj špeciálne metódy, ktoré sa vykonajú pred každým testom, prípadne po každom teste.
* ...

== Grafy: úvod ==

Počas nasledujúcich niekoľkých týždňov sa budeme venovať práci s grafmi a implementácii jednoduchých grafových algoritmov. 
* Na tomto predmete nebudeme grafy definovať matematicky &ndash; to je náplň predmetu &bdquo;Úvod do kombinatoriky a teórie grafov&rdquo;. Namiesto toho si vystačíme s intuitívnym chápaním vysvetleným nižšie.
* Viac sa o grafových algoritmoch možno dočítať napríklad v nasledujúcej literatúre, ktorá svojím záberom prudko presahuje rámec tohto predmetu:
** R. Sedgewick, K. Wayne: ''Algorithms, 4th ed''. Upper Saddle River : Addison-Wesley, 2011. (Grafmi sa zaoberá štvrtá kapitola, používa sa Java.)
** J. Demel: ''Grafy a jejich aplikace''. Praha : Academia, 2002. (Algoritmy opisované pomocou prirodzeného/matematického jazyka.)
** T. H. Cormen et al. ''Introduction to Algorithms, 3rd ed''. Cambridge, Massachusetts : MIT Press, 2009. (Algoritmy opisované pomocou pseudokódu.)
* Ďalšie predmety, na ktorých sa robí s grafmi:
** &bdquo;[https://sluzby.fmph.uniba.sk/infolist/sk/1-INF-310.html Tvorba efektívnych algoritmov]&rdquo; (pokročilejšie grafové algoritmy).  
** &bdquo;[https://sluzby.fmph.uniba.sk/infolist/sk/2-INF-174.html Teória grafov]&rdquo; (teoretické aspekty grafov, niektoré grafové algoritmy).
** &bdquo;[http://www.dcs.fmph.uniba.sk/~kostolanyi/nestruktury/ Neštruktúrované rozpravy o štruktúrach: kapitoly z matematiky pre informatikov (1)]&rdquo; (prevažne súvis grafov s maticami).

=== Orientované a neorientované grafy ===

* Pod ''orientovaným grafom'' (angl. ''directed graph'') budeme rozumieť konečnú množinu vrcholov (zvyčajne ''{0,1,...,n-1}'' pre nejaké kladné prirodzené číslo ''n''), kde medzi každou dvojicou vrcholov môže viesť najviac jedna orientovaná hrana. Vrcholy (angl. ''vertices'') znázorňujeme bodmi resp. krúžkami, orientované hrany (angl. ''edges'') šípkami. Nezaujímajú nás pritom geometrické vlastnosti diagramu grafu, ale iba to, či dané vrcholy sú alebo nie sú spojené hranou. Špeciálnym prípadom hrany je tzv. ''slučka'' &ndash; hrana s rovnakým počiatočným a koncovým vrcholom. Príklad diagramu orientovaného grafu je na obrázku nižšie.

:::::::[[Súbor:Graf1.png]]

* V ''neorientovanom grafe'' (angl. ''undirected graph'') nerozlišujeme orientáciu hrán; hrany tak namiesto šípok kreslíme &bdquo;obyčajnými čiarami&rdquo;. Medzi každou (neusporiadanou) dvojicou vrcholov pritom môže viesť najviac jedna hrana a v každom vrchole môže graf obsahovať najviac jednu slučku. Neorientovaný graf budeme stotožňovať s orientovaným grafom, v ktorom existencia hrany z vrcholu ''u'' do vrcholu ''v'' (rôzneho od ''u'') implikuje existenciu hrany z ''v'' do ''u''. Príklad diagramu neorientovaného grafu je na obrázku nižšie.

:::::::::[[Súbor:Graf2.png]]

Pod ''grafom'' (bez ďalšieho prívlastku) budeme mať &ndash; na rozdiel od väčšiny odborníkov na teóriu grafov &ndash; vždy na mysli orientovaný graf.

''Dôležité pojmy'':
* ''Následník'' vrcholu ''u'' v grafe ''G'' je ľubovoľný vrchol ''v'' taký, že v ''G'' vedie hrana z vrcholu ''u'' do vrcholu ''v''.
* ''Predchodca'' vrcholu ''u'' v grafe ''G'' je ľubovoľný vrchol ''v'' taký, že ''u'' je v grafe ''G'' následníkom ''v''.
* ''Sused'' vrcholu ''u'' je ľubovoľný vrchol ''v'', ktorý je následníkom alebo predchodcom vrcholu ''u''.
* V neorientovaných grafoch sú množiny následníkov, predchodcov a susedov každého vrcholu totožné.

=== Vybrané aplikácie grafov ===

* Grafy cestnej (resp. železničnej, leteckej, elektrickej, potrubnej, počítačovej...) siete.
* Modely zložitých sietí (napr. internet, interakcie proteínov, ľudský mozog...).
* Grafy molekúl (vrcholmi sú atómy a hranami väzby medzi nimi).
* Časové závislosti medzi činnosťami (ak činnosť ''u'' treba vykonať pred činnosťou ''v'', vedie z ''u'' do ''v'' orientovaná hrana).
* Preferencie (napríklad pri tvorbe rozvrhov môžu byť hranami pospájané predmety s časmi, v ktorých sa musia vyučovať).
* Všeobecnejšie možno grafom zadať akúkoľvek konečnú binárnu reláciu. 
* Niektoré modely výpočtov (booleovské obvody, konečné automaty...).
* Každý strom je súčasne aj grafom...
* ...

=== Reprezentácia grafov ===

Na dnešnej prednáške sa budeme zaoberať orientovanými a neorientovanými grafmi na množine vrcholov ''{0,1,...,n-1}'' pre kladné prirodzené ''n''. Najužitočnejšími spôsobmi reprezentácie grafu v pamäti počítača sú nasledujúce dva:

==== Matica susednosti (angl. ''adjacency matrix'') ====

* Hrany grafu reprezentujeme pomocou štvorcovej booleovskej matice <tt>A</tt> typu ''n'' &times; ''n''</tt>. Pritom <tt>A[i][j] == true</tt> práve vtedy, keď v grafe vedie hrana z vrcholu <tt>i</tt> do vrcholu <tt>j</tt>.
* Napríklad pre graf s vrcholmi ''V = {0,1,2,3,4}'' a hranami ''E = {(0,1),(1,2),(1,3),(2,3),(3,0),(3,3)}'' dostávame nasledujúcu štvorcovú maticu rádu 5 (kde <tt>T</tt> je skratkou <tt>true</tt> a <tt>F</tt> pre <tt>false</tt>):
:<syntaxhighlight lang="java">
  0 1 2 3 4
0 F T F F F
1 F F T T F
2 F F F T F
3 T F F T F
4 F F F F F
</syntaxhighlight>
* Matica susednosti ''neorientovaného'' grafu je vždy symetrická.

==== Zoznamy následníkov (angl. ''successor lists'') ====

* Pre každý vrchol ''u'' si pamätáme zoznam (<tt>ArrayList</tt>, <tt>LinkedList</tt>, prípadne aj obyčajné pole) ''následníkov'' &ndash; čiže vrcholov, ''do'' ktorých vedie z vrcholu ''u'' hrana. Tieto vrcholy si môžeme pamätať v ľubovoľnom poradí, napríklad od najmenšieho po najväčší.
* Napríklad pre graf s vrcholmi ''V = {0,1,2,3,4}'' a hranami ''E = {(0,1),(1,2),(1,3),(2,3),(3,0),(3,3)}'':
:<syntaxhighlight lang="java">
0: 1
1: 2, 3
2: 3
3: 0, 3
4: 
</syntaxhighlight> 
* Pre neorientované grafy obsahuje každý zo zoznamov práve všetkých susedov daného vrcholu. Ide tak o tzv. ''zoznamy susedov'' (angl. ''adjacency lists'').

=== Graf ako abstraktný dátový typ: rozhranie <tt>Graph</tt> ===
* Skôr, než si ukážeme konkrétne implementácie grafov pomocou matíc susednosti aj zoznamov následníkov, potrebujeme vedieť, aké operácie by mal graf poskytovať. 
* Napíšeme preto jednoduché rozhranie pre (orientovaný alebo neorientovaný) graf deklarujúce metódy, ktoré by mala poskytovať každá implementácia grafov.
* Budeme prevažne pracovať s ''nemodifikovateľnými'' grafmi &ndash; nasledujúce rozhranie preto ''nebude'' deklarovať metódy meniace počet vrcholov alebo množinu hrán.
<syntaxhighlight lang="java">
package graphs;

/**
 *  Rozhranie pre reprezentacie grafov o vrcholoch 0, 1, ..., n-1 pre nejake
 *  prirodzene cislo n.
 */
public interface Graph {
    /**
     * Metoda, ktora vrati pocet vrcholov reprezentovaneho grafu.
     *
     * @return Pocet vrcholov grafu.
     */
    int getNumberOfVertices();

    /**
     * Metoda, ktora vrati pocet hran reprezentovaneho grafu.
     *
     * @return Pocet hran grafu.
     */
    int getNumberOfEdges();

    /**
     * Metoda, ktora zisti, ci v grafe existuje hrana medzi danou dvojicou vrcholov.
     *
     * @param from Pociatocny vrchol.
     * @param to   Koncovy vrchol.
     * @return     Vrati true prave vtedy, ked v grafe existuje hrana z vrcholu from do vrcholu to.
     */
    boolean existsEdge(int from, int to);

    /**
     * Metoda, ktora vrati vsetkych naslednikov daneho vrcholu -- cize vsetky vrcholy, do ktorych vedie z daneho vrcholu
     * orientovana hrana. Pre neorientovane grafy tak tato metoda vzdy vrati vsetkych susedov daneho vrcholu.
     * 
     * @param vertex Lubovolny vrchol grafu.
     * @return       Naslednici vrcholu vertex ako instancia typu Iterable&lt;Integer&gt;.
     */
    Iterable<Integer> outgoingEdgesDestinations(int vertex);
}
</syntaxhighlight>
Výstupom metódy <tt>outgoingEdgesDestinations</tt> je inštancia triedy implementujúcej rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/Iterable.html <tt>Iterable<Integer></tt>]. Pripomeňme si, že je v tomto rozhraní predpísaná jediná metóda <tt>iterator()</tt>, ktorá vráti iterátor (v našom prípade cez prvky typu <tt>Integer</tt>) a že inštancie <tt>inst</tt> tried implementujúcich <tt>Iterable<Integer></tt> sa dajú použiť v cykle <tt>for each</tt>. ''Napríklad'':
<syntaxhighlight lang="java">
package graphs;

import java.io.*;

public class Trieda {
    /**
     * Metoda vypise do daneho vystupneho prudu pocet vrcholov a hran grafu, ako aj vsetky dvojice vrcholov tvoriace
     * hrany grafu. 
     * 
     * @param g   Graf, pre ktory sa vypis realizuje.
     * @param out Vystupny prud, do ktoreho sa vypis realizuje.
     */
    public static void printGraph(Graph g, PrintStream out) {
        int n = g.getNumberOfVertices();
        out.println(n + " " + g.getNumberOfEdges());
        for (int u = 0; u <= n - 1; u++) {
            for (int v : g.outgoingEdgesDestinations(u)) {
                out.println(u + " " + v);
            }
        }
    }
}
</syntaxhighlight>

=== Orientované grafy pomocou zoznamov následníkov: trieda <tt>SuccessorListsGraph</tt> ===

* Pre každý vrchol ''u'' si budeme udržiavať <tt>ArrayList</tt> jeho následníkov.
* V metóde <tt>outgoingEdgesDestinations</tt> jednoducho pre daný vrchol vrátime tento zoznam. Obalíme ho ale tak, aby sa nedal meniť (alternatívne by sme namiesto zoznamu samotného mohli vracať jeho kópiu, čo by ale bolo pri častom volaní tejto metódy o niečo menej efektívne).
* Konštruktor dostane počet vrcholov grafu a všetky jeho hrany v nejakom zoskupení typu <tt>Collection<Edge></tt>, kde <tt>Edge</tt> je pomocná trieda reprezentujúca hranu a slúžiaca hlavne na tento účel.

<syntaxhighlight lang="java">
package graphs;

public class Edge {
    private int from, to;

    public Edge(int from, int to) {
        this.from = from;
        this.to = to;
    }

    public int getFrom() {
        return from;
    }

    public int getTo() {
        return to;
    }

    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        return this.getClass() == o.getClass() && from == ((Edge) o).from && to == ((Edge) o).to;
    }

    @Override
    public int hashCode() {
        return Integer.valueOf(from).hashCode() + 31 * Integer.valueOf(to).hashCode();
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda reprezentujuca orientovany graf pomocou zoznamov naslednikov jednotlivych jeho vrcholov.
 */
public class SuccessorListsGraph implements Graph {
    /**
     * Pre kazdy vrchol zoznam jeho naslednikov.
     */
    private ArrayList<ArrayList<Integer>> successorLists;

    /**
     * Pocet hran v grafe (velkost grafu).
     */
    private int edgeCount;

    /**
     * Konstruktor, ktory dostane ako argumenty pocet vrcholov grafu (t. j. jeho rad), ako aj vsetky hrany grafu.
     *
     * @param vertexCount Rad grafu, cize pocet jeho vrcholov.
     * @param edges       Zoskupenie pozostavajuce zo vsetkych hran grafu.
     */
    public SuccessorListsGraph(int vertexCount, Collection<Edge> edges) {
        successorLists = new ArrayList<>();
        for (int i = 0; i <= vertexCount - 1; i++) {
            successorLists.add(new ArrayList<>());
        }
        edgeCount = 0;
        for (Edge e : edges) {
            if (!existsEdge(e.getFrom(), e.getTo())) {
                successorLists.get(e.getFrom()).add(e.getTo());
                edgeCount++;
            }
        }
    }

    @Override
    public int getNumberOfVertices() {
        return successorLists.size();
    }

    @Override
    public int getNumberOfEdges() {
        return edgeCount;
    }

    @Override
    public boolean existsEdge(int from, int to) {
        return successorLists.get(from).contains(to);
    }

    @Override
    public Iterable<Integer> outgoingEdgesDestinations(int from) {
        return Collections.unmodifiableList(successorLists.get(from));  // Vratime nemodifikovatelny pohlad na zoznam successorLists.get(from).
    }
}
</syntaxhighlight>

=== Orientované grafy pomocou matice susednosti: trieda <tt>AdjacencyMatrixGraph</tt> ===

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda reprezentujuca orientovany graf pomocou matice susednosti.
 */
public class AdjacencyMatrixGraph implements Graph {
    /**
     * Matica susednosti.
     */
    private boolean adjacencyMatrix[][];

    /**
     * Pocet hran v grafe (velkost grafu).
     */
    private int edgeCount;

    /**
     * Konstruktor, ktory dostane ako argumenty pocet vrcholov grafu (t. j. jeho rad), ako aj vsetky hrany grafu.
     *
     * @param vertexCount Rad grafu, cize pocet jeho vrcholov.
     * @param edges       Zoskupenie pozostavajuce zo vsetkych hran grafu.
     */
    public AdjacencyMatrixGraph(int vertexCount, Collection<Edge> edges) {
        adjacencyMatrix = new boolean[vertexCount][vertexCount];
        edgeCount = 0;
        for (Edge e : edges) {
            if (!existsEdge(e.getFrom(), e.getTo())) {
                adjacencyMatrix[e.getFrom()][e.getTo()] = true;
                edgeCount++;
            }
        }
    }

    @Override
    public int getNumberOfVertices() {
        return adjacencyMatrix.length;
    }

    @Override
    public int getNumberOfEdges() {
        return edgeCount;
    }

    @Override
    public boolean existsEdge(int from, int to) {
        return adjacencyMatrix[from][to];
    }

    @Override
    public Iterable<Integer> outgoingEdgesDestinations(int vertex) {
        List<Integer> a = new ArrayList<>();
        for (int i = 0; i <= getNumberOfVertices() - 1; i++) {
            if (adjacencyMatrix[vertex][i]) {
                a.add(i);
            }
        }
        return Collections.unmodifiableList(a);
    }
}
</syntaxhighlight>

=== Neorientované grafy: triedy <tt>AdjacencyListsUndirectedGraph</tt> a <tt>AdjacencyMatrixUndirectedGraph</tt> ===

Pri implementácii neorientovaných grafov môžeme využiť dedenie od prislušných tried pre orientované grafy. Narážame tu len na dva rozdiely:
* Konštruktor by mal pre každú požadovanú neorientovanú hranu pridať dvojicu protichodných orientovaných hrán (s výnimkou slučiek, kde sa pridáva jediná orientovaná hrana).
* Metóda <tt>getNumberOfEdges</tt> by nemala vracať počet orientovaných hrán, ale počet neorientovaných hrán.

<syntaxhighlight lang="java">
package graphs;

public interface UndirectedGraph extends Graph {

}
</syntaxhighlight>

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Pomocne metody na pracu so zoskupeniami hran.
 */
public class Edges {

    public static Collection<Edge> symmetricClosure(Collection<Edge> edges) {
        List<Edge> result = new ArrayList<>();
        for (Edge e : edges) {
            result.add(e);
            if (e.getFrom() != e.getTo()) {
                result.add(new Edge(e.getTo(), e.getFrom()));
            }
        }
        return result;
    }

    public static int distinctUndirectedEdges(Collection<Edge> edges) {
        HashSet<Edge> set = new HashSet<>();
        for (Edge e : edges) {
            if (!set.contains(e) && !set.contains(new Edge(e.getTo(), e.getFrom()))) {
                set.add(e);
            }
        }
        return set.size();
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda reprezentujuca neorientovany graf pomocou zoznamov susedov jednotlivych jeho vrcholov.
 */
public class AdjacencyListsUndirectedGraph extends SuccessorListsGraph implements UndirectedGraph {
    private int undirectedEdgeCount;

    public AdjacencyListsUndirectedGraph(int vertexCount, Collection<Edge> edges) {
        super(vertexCount, Edges.symmetricClosure(edges));
        undirectedEdgeCount = Edges.distinctUndirectedEdges(edges);
    }

    @Override
    public int getNumberOfEdges() {
        return undirectedEdgeCount;
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda reprezentujuca neorientovany graf pomocou matice susednosti.
 */
public class AdjacencyMatrixUndirectedGraph extends AdjacencyMatrixGraph implements UndirectedGraph {
    private int undirectedEdgeCount;

    public AdjacencyMatrixUndirectedGraph(int vertexCount, Collection<Edge> edges) {
        super(vertexCount, Edges.symmetricClosure(edges));
        undirectedEdgeCount = Edges.distinctUndirectedEdges(edges);
    }

    @Override
    public int getNumberOfEdges() {
        return undirectedEdgeCount;
    }
}
</syntaxhighlight>

=== Vytvorenie grafu ===

Metóda <tt>readGraph</tt> triedy <tt>Trieda</tt> uvedenej nižšie prečíta pomocou danej inštancie triedy <tt>Scanner</tt> reprezentáciu grafu a vytvorí z nej graf typu určeného nasledujúcim parametrom. Argument pre typ grafu je pritom ''vymenovaného typu'' <tt>GraphType</tt> (o vymenovaných typoch sa možno dočítať viac [https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html tu]).

<syntaxhighlight lang="java">
package graphs;

public enum GraphType {
    DIRECTED_SUCCESSOR_LISTS, DIRECTED_ADJACENCY_MATRIX, UNDIRECTED_ADJACENCY_LISTS, UNDIRECTED_ADJACENCY_MATRIX
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

public class Trieda {
    /**
     * Metoda, ktora precita textovu reprezentaciu grafu pozostavajucu z poctu vrcholov n, poctu hran m a z m dvojic
     * vrcholov udavajucich jednotlive hrany a vytvori z nej graf urceneho typu.
     *
     * @param scanner   Scanner, z ktoreho sa reprezentacia grafu cita.
     * @param graphType Typ vytvaraneho grafu.
     * @return          Vytvoreny graf.  
     */
    public static Graph readGraph(Scanner scanner, GraphType graphType) {
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        List<Edge> edges = new ArrayList<>();
        for (int i = 1; i <= m; i++) {
            edges.add(new Edge(scanner.nextInt(), scanner.nextInt()));
        }
        Graph g = null;
        switch (graphType) {
            case DIRECTED_SUCCESSOR_LISTS:
                g = new SuccessorListsGraph(n, edges);
                break;
            case DIRECTED_ADJACENCY_MATRIX:
                g = new AdjacencyMatrixGraph(n, edges);
                break;
            case UNDIRECTED_ADJACENCY_LISTS:
                g = new AdjacencyListsUndirectedGraph(n, edges);
                break;
            case UNDIRECTED_ADJACENCY_MATRIX:
                g = new AdjacencyMatrixUndirectedGraph(n, edges);
                break;
        }
        return g;
    }
}
</syntaxhighlight>

Volanie metódy <tt>readGraph</tt> potom môže vyzerať napríklad nasledovne:
<syntaxhighlight lang="java">
Graph g = readGraph(scanner, GraphType.DIRECTED_SUCCESSOR_LISTS);
</syntaxhighlight>

=== Porovnanie reprezentácií grafov ===
Majme orientovaný graf s ''n'' vrcholmi a ''m'' hranami &ndash; počet hrán ''m'' teda môže byť od 0 po ''n<sup>2</sup>''. V závislosti od použitej reprezentácie grafu sa líši ako časová zložitosť jednotlivých operácií na grafoch, tak aj pamäťová zložitosť samotnej tejto reprezentácie. Napríklad:
* Pamäť potrebná na uloženie matice susednosti grafu je vždy rádovo veľkosti ''n<sup>2</sup>''. Pri reprezentácii pomocou zoznamov následníkov resp. susedov je veľkosť reprezentácie grafu rádovo ''n+m''. Hlavne pre riedke grafy (s menším počtom hrán) je teda reprezentácia pomocou zoznamov pamäťovo efektívnejšia.
* Operácia <tt>existsEdge</tt> sa pre grafy reprezentované maticou susednosti vykoná v konštantnom čase. Pre grafy reprezentované zoznamami následníkov resp. susedov môže byť zložitosť tejto operácie až lineárna v závislosti od počtu vrcholov grafu (je potrebné prejsť celý zoznam susedov jedného vrchola, ktorý môže obsahovať až ''n'' rôznych vrcholov).
* Naopak vytvorenie zoznamu následníkov resp. susedov grafu v metóde <tt>outgoingEdgesDestinations</tt> je efektívnejšie pri reprezentácii pomocou zoznamov.

=== Ďalšie varianty grafov ===

Grafy na tejto prednáške chápeme v relatívne obmedzenom slova zmysle. V praxi sa často zídu aj rôzne rozšírenia definície grafu:
* ''Grafy s násobnými hranami'' (niekde tiež ''multigrafy'') umožňujú viesť medzi danou dvojicou vrcholov viacero paralelných hrán. To možno v pamäti počítača realizovať napríklad nahradením booleovskej matice maticou prirodzených čísel udávajúcich násobnosti jendotlivých hrán, prípadne pridaním informácie o multiplicite do zoznamov následníkov resp. susedov.
* ''Ohodnotené grafy'' obsahujú na hranách nejakú ďalšiu prídavnú informáciu (napríklad pri cestnej sieti si môžeme pamätať dĺžku jednotlivých úsekov, prípadne ich možno využiť aj na reprezentáciu multigrafov). Možno ich reprezentovať nahradením booleovskej matice maticou ohodnotení, prípadne zakomponovaním informácie o ohodnotení hrán do zoznamov následníkov resp. susedov. S ohodnotenými grafmi sa okrajovo stretneme aj tento semester.
* ''Dynamické grafy'' podporujú aj pridávanie a mazanie vrcholov a/alebo hrán.
=Riešenia testu č. 2=
== Úloha č. 1 ==

<syntaxhighlight lang="java">
import java.util.*;

public class Multiset<E> {
    private HashMap<E, Integer> map;

    public Multiset() {
        map = new HashMap<>();
    }

    public void add(E e) {
        if (map.containsKey(e)) {
            map.put(e, map.get(e) + 1);
        } else {
            map.put(e, 1);
        }
    }

    public void remove(E e) {
        if (map.containsKey(e) && map.get(e) >= 2) {
            map.put(e, map.get(e) - 1);
        } else {
            map.remove(e);
        }
    }

    public boolean contains(E e) {
        return map.containsKey(e);
    }

    public int getMultiplicity(E e) {
        if (map.containsKey(e)) {
            return map.get(e);
        } else {
            return 0;
        }
    }
}
</syntaxhighlight>

== Úloha č. 2 ==

<syntaxhighlight lang="java">
// ...

Collections.sort(polynomials, new Comparator<Polynomial>() {
    @Override
    public int compare(Polynomial p1, Polynomial p2) {
        if (p1.getDegree() < p2.getDegree()) {
            return -1;
        }
        if (p1.getDegree() > p2.getDegree()) {
            return 1;
        }
        for (int n = p1.getDegree(); n >= 0; n--) {
            if (p1.getCoefficient(n) < p2.getCoefficient(n)) {
                return -1;
            }
            if (p1.getCoefficient(n) > p2.getCoefficient(n)) {
                return 1;
            }
        }
        return 0;
    }
});

// ...
</syntaxhighlight>

== Úloha č. 3 ==

<syntaxhighlight lang="java">
import java.util.*;

public class PalilalicIterator<E> implements Iterator<E> {
    private Iterator<E> it;
    private E next;
    private boolean newValueFollows = true;

    public PalilalicIterator(Iterable<E> iterable) {
        this.it = iterable.iterator();
        findNext();
    }

    private void findNext() {
        if (newValueFollows) {
            if (it.hasNext()) {
                next = it.next();
            } else {
                next = null;
            }
        }
        newValueFollows = !newValueFollows;
    }

    @Override
    public boolean hasNext() {
        return next != null;
    }

    @Override
    public E next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        E result = next;
        findNext();
        return result;
    }
}
</syntaxhighlight>
=Letný semester, prednáška č. 7=
== Oznamy ==

* Dnes po prednáške bude zverejnené zadanie tretej domácej úlohy, ktorú bude potrebné odovzdať ''do pondelka 12. apríla, 9:00'' (čiže do začiatku budúcej prednášky).
* V stredu na cvičeniach bude zverejnených niekoľko nebodovaných úloh zameraných na grafy a grafové algoritmy.
* Počas cvičení ''v stredu 7. apríla'' bude prebiehať tretí test zameraný na látku z prvých siedmich prednášok (časť úloh bude zameraná na grafy, časť ešte na skoršiu látku).

== Triedy pre grafy z minulej prednášky ==

<syntaxhighlight lang="java">
package graphs;

/**
 *  Rozhranie pre reprezentacie grafov o vrcholoch 0, 1, ..., n-1 pre nejake
 *  prirodzene cislo n.
 */
public interface Graph {
    /**
     * Metoda, ktora vrati pocet vrcholov reprezentovaneho grafu.
     *
     * @return Pocet vrcholov grafu.
     */
    int getNumberOfVertices();

    /**
     * Metoda, ktora vrati pocet hran reprezentovaneho grafu.
     *
     * @return Pocet hran grafu.
     */
    int getNumberOfEdges();

    /**
     * Metoda, ktora zisti, ci v grafe existuje hrana medzi danou dvojicou vrcholov.
     *
     * @param from Pociatocny vrchol.
     * @param to   Koncovy vrchol.
     * @return     Vrati true prave vtedy, ked v grafe existuje hrana z vrcholu from do vrcholu to.
     */
    boolean existsEdge(int from, int to);

    /**
     * Metoda, ktora vrati vsetkych naslednikov daneho vrcholu -- cize vsetky vrcholy, do ktorych vedie z daneho vrcholu
     * orientovana hrana. Pre neorientovane grafy tak tato metoda vzdy vrati vsetkych susedov daneho vrcholu.
     * 
     * @param vertex Lubovolny vrchol grafu.
     * @return       Naslednici vrcholu vertex ako instancia typu Iterable&lt;Integer&gt;.
     */
    Iterable<Integer> outgoingEdgesDestinations(int vertex);
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package graphs;

public class Edge {
    private int from, to;

    public Edge(int from, int to) {
        this.from = from;
        this.to = to;
    }

    public int getFrom() {
        return from;
    }

    public int getTo() {
        return to;
    }

    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        return this.getClass() == o.getClass() && from == ((Edge) o).from && to == ((Edge) o).to;
    }

    @Override
    public int hashCode() {
        return Integer.valueOf(from).hashCode() + 31 * Integer.valueOf(to).hashCode();
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda reprezentujuca orientovany graf pomocou zoznamov naslednikov jednotlivych jeho vrcholov.
 */
public class SuccessorListsGraph implements Graph {
    /**
     * Pre kazdy vrchol zoznam jeho naslednikov.
     */
    private ArrayList<ArrayList<Integer>> successorLists;

    /**
     * Pocet hran v grafe (velkost grafu).
     */
    private int edgeCount;

    /**
     * Konstruktor, ktory dostane ako argumenty pocet vrcholov grafu (t. j. jeho rad), ako aj vsetky hrany grafu.
     *
     * @param vertexCount Rad grafu, cize pocet jeho vrcholov.
     * @param edges       Zoskupenie pozostavajuce zo vsetkych hran grafu.
     */
    public SuccessorListsGraph(int vertexCount, Collection<Edge> edges) {
        successorLists = new ArrayList<>();
        for (int i = 0; i <= vertexCount - 1; i++) {
            successorLists.add(new ArrayList<>());
        }
        edgeCount = 0;
        for (Edge e : edges) {
            if (!existsEdge(e.getFrom(), e.getTo())) {
                successorLists.get(e.getFrom()).add(e.getTo());
                edgeCount++;
            }
        }
    }

    @Override
    public int getNumberOfVertices() {
        return successorLists.size();
    }

    @Override
    public int getNumberOfEdges() {
        return edgeCount;
    }

    @Override
    public boolean existsEdge(int from, int to) {
        return successorLists.get(from).contains(to);
    }

    @Override
    public Iterable<Integer> outgoingEdgesDestinations(int from) {
        return Collections.unmodifiableList(successorLists.get(from));  // Vratime nemodifikovatelny pohlad na zoznam successorLists.get(from).
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda reprezentujuca orientovany graf pomocou matice susednosti.
 */
public class AdjacencyMatrixGraph implements Graph {
    /**
     * Matica susednosti.
     */
    private boolean adjacencyMatrix[][];

    /**
     * Pocet hran v grafe (velkost grafu).
     */
    private int edgeCount;

    /**
     * Konstruktor, ktory dostane ako argumenty pocet vrcholov grafu (t. j. jeho rad), ako aj vsetky hrany grafu.
     *
     * @param vertexCount Rad grafu, cize pocet jeho vrcholov.
     * @param edges       Zoskupenie pozostavajuce zo vsetkych hran grafu.
     */
    public AdjacencyMatrixGraph(int vertexCount, Collection<Edge> edges) {
        adjacencyMatrix = new boolean[vertexCount][vertexCount];
        edgeCount = 0;
        for (Edge e : edges) {
            if (!existsEdge(e.getFrom(), e.getTo())) {
                adjacencyMatrix[e.getFrom()][e.getTo()] = true;
                edgeCount++;
            }
        }
    }

    @Override
    public int getNumberOfVertices() {
        return adjacencyMatrix.length;
    }

    @Override
    public int getNumberOfEdges() {
        return edgeCount;
    }

    @Override
    public boolean existsEdge(int from, int to) {
        return adjacencyMatrix[from][to];
    }

    @Override
    public Iterable<Integer> outgoingEdgesDestinations(int vertex) {
        List<Integer> a = new ArrayList<>();
        for (int i = 0; i <= getNumberOfVertices() - 1; i++) {
            if (adjacencyMatrix[vertex][i]) {
                a.add(i);
            }
        }
        return Collections.unmodifiableList(a);
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package graphs;

public interface UndirectedGraph extends Graph {

}
</syntaxhighlight>

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Pomocne metody na pracu so zoskupeniami hran.
 */
public class Edges {

    public static Collection<Edge> symmetricClosure(Collection<Edge> edges) {
        List<Edge> result = new ArrayList<>();
        for (Edge e : edges) {
            result.add(e);
            if (e.getFrom() != e.getTo()) {
                result.add(new Edge(e.getTo(), e.getFrom()));
            }
        }
        return result;
    }

    public static int distinctUndirectedEdges(Collection<Edge> edges) {
        HashSet<Edge> set = new HashSet<>();
        for (Edge e : edges) {
            if (!set.contains(e) && !set.contains(new Edge(e.getTo(), e.getFrom()))) {
                set.add(e);
            }
        }
        return set.size();
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda reprezentujuca neorientovany graf pomocou zoznamov susedov jednotlivych jeho vrcholov.
 */
public class AdjacencyListsUndirectedGraph extends SuccessorListsGraph implements UndirectedGraph {
    private int undirectedEdgeCount;

    public AdjacencyListsUndirectedGraph(int vertexCount, Collection<Edge> edges) {
        super(vertexCount, Edges.symmetricClosure(edges));
        undirectedEdgeCount = Edges.distinctUndirectedEdges(edges);
    }

    @Override
    public int getNumberOfEdges() {
        return undirectedEdgeCount;
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda reprezentujuca neorientovany graf pomocou matice susednosti.
 */
public class AdjacencyMatrixUndirectedGraph extends AdjacencyMatrixGraph implements UndirectedGraph {
    private int undirectedEdgeCount;

    public AdjacencyMatrixUndirectedGraph(int vertexCount, Collection<Edge> edges) {
        super(vertexCount, Edges.symmetricClosure(edges));
        undirectedEdgeCount = Edges.distinctUndirectedEdges(edges);
    }

    @Override
    public int getNumberOfEdges() {
        return undirectedEdgeCount;
    }
}
</syntaxhighlight>

== Pokračovanie úvodu do grafov ==

=== Vytvorenie grafu ===

Metóda <tt>readGraph</tt> triedy <tt>Trieda</tt> uvedenej nižšie prečíta pomocou danej inštancie triedy <tt>Scanner</tt> reprezentáciu grafu a vytvorí z nej graf typu určeného jej druhým parametrom. Argument pre typ grafu je pritom ''vymenovaného typu'' <tt>GraphType</tt> (o vymenovaných typoch sa možno dočítať viac [https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html tu]).

<syntaxhighlight lang="java">
package graphs;

public enum GraphType {
    DIRECTED_SUCCESSOR_LISTS, DIRECTED_ADJACENCY_MATRIX, UNDIRECTED_ADJACENCY_LISTS, UNDIRECTED_ADJACENCY_MATRIX
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

public class Trieda {
    /**
     * Metoda, ktora precita textovu reprezentaciu grafu pozostavajucu z poctu vrcholov n, poctu hran m a z m dvojic
     * vrcholov udavajucich jednotlive hrany a vytvori z nej graf urceneho typu.
     *
     * @param scanner   Scanner, z ktoreho sa reprezentacia grafu cita.
     * @param graphType Typ vytvaraneho grafu.
     * @return          Vytvoreny graf.  
     */
    public static Graph readGraph(Scanner scanner, GraphType graphType) {
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        List<Edge> edges = new ArrayList<>();
        for (int i = 1; i <= m; i++) {
            edges.add(new Edge(scanner.nextInt(), scanner.nextInt()));
        }
        Graph g = null;
        switch (graphType) {
            case DIRECTED_SUCCESSOR_LISTS:
                g = new SuccessorListsGraph(n, edges);
                break;
            case DIRECTED_ADJACENCY_MATRIX:
                g = new AdjacencyMatrixGraph(n, edges);
                break;
            case UNDIRECTED_ADJACENCY_LISTS:
                g = new AdjacencyListsUndirectedGraph(n, edges);
                break;
            case UNDIRECTED_ADJACENCY_MATRIX:
                g = new AdjacencyMatrixUndirectedGraph(n, edges);
                break;
        }
        return g;
    }
}
</syntaxhighlight>

Volanie metódy <tt>readGraph</tt> potom môže vyzerať napríklad nasledovne:
<syntaxhighlight lang="java">
Graph g = readGraph(scanner, GraphType.DIRECTED_SUCCESSOR_LISTS);
</syntaxhighlight>

=== Porovnanie reprezentácií grafov ===
Majme orientovaný graf s ''n'' vrcholmi a ''m'' hranami &ndash; počet hrán ''m'' teda môže byť od 0 po ''n<sup>2</sup>''. V závislosti od použitej reprezentácie grafu sa líši ako časová zložitosť jednotlivých operácií na grafoch, tak aj pamäťová zložitosť samotnej tejto reprezentácie. Napríklad:
* Pamäť potrebná na uloženie matice susednosti grafu je vždy rádovo veľkosti ''n<sup>2</sup>''. Pri reprezentácii pomocou zoznamov následníkov resp. susedov je veľkosť reprezentácie grafu rádovo ''n+m''. Hlavne pre riedke grafy (s menším počtom hrán) je teda reprezentácia pomocou zoznamov pamäťovo efektívnejšia.
* Operácia <tt>existsEdge</tt> sa pre grafy reprezentované maticou susednosti vykoná v konštantnom čase. Pre grafy reprezentované zoznamami následníkov resp. susedov môže byť zložitosť tejto operácie až lineárna v závislosti od počtu vrcholov grafu (je potrebné prejsť celý zoznam susedov jedného vrchola, ktorý môže obsahovať až ''n'' rôznych vrcholov).
* Naopak vrátenie zoznamu následníkov resp. susedov grafu v metóde <tt>outgoingEdgesDestinations</tt> je efektívnejšie pri reprezentácii pomocou zoznamov.

=== Ďalšie varianty grafov ===

Grafy na tejto prednáške chápeme v relatívne obmedzenom slova zmysle. V praxi sa často zídu aj rôzne rozšírenia definície grafu:
* ''Grafy s násobnými hranami'' (niekde tiež ''multigrafy'') umožňujú viesť medzi danou dvojicou vrcholov viacero paralelných hrán. To možno v pamäti počítača realizovať napríklad nahradením booleovskej matice maticou prirodzených čísel udávajúcich násobnosti jendotlivých hrán, prípadne pridaním informácie o multiplicite do zoznamov následníkov resp. susedov.
* ''Ohodnotené grafy'' obsahujú na hranách nejakú ďalšiu prídavnú informáciu (napríklad pri cestnej sieti si môžeme pamätať dĺžku jednotlivých úsekov, prípadne ich možno využiť aj na reprezentáciu multigrafov). Možno ich reprezentovať nahradením booleovskej matice maticou ohodnotení, prípadne zakomponovaním informácie o ohodnotení hrán do zoznamov následníkov resp. susedov. S ohodnotenými grafmi sa okrajovo stretneme aj tento semester.
* ''Dynamické grafy'' podporujú aj pridávanie a mazanie vrcholov a/alebo hrán.

== Prehľadávanie (orientovaného alebo neorientovaného) grafu do hĺbky ==

=== Existencia cesty medzi dvojicou vrcholov ===

Riešme teraz nasledujúci problém: pre danú dvojicu vrcholov ''u'' a ''v'' nejakého (orientovaného alebo neorientovaného) grafu potrebujeme zistiť, či sú spojené ''sledom'' &ndash; t. j. či sa dá medzi nimi prejsť pomocou postupne na seba nadväzujúcich hrán (počet týchto hrán môže byť aj nulový, takže z každého vrcholu triviálne vedie sled do seba samého). Existencia sledu medzi dvoma vrcholmi je očividne ekvivalentná existencii ''cesty'' (t. j. sledu, v ktorom sa žiaden vrchol nezopakuje). 
[[Súbor:Sled_cesta.png|center]]
V nasledujúcom preto budeme hovoriť o existencii ciest.

''Pojmy sledu a cesty o niečo presnejšie:''
* ''Sledom'' v grafe rozumieme postupnosť vrcholov ''v<sub>0</sub>, v<sub>1</sub>, ..., v<sub>n</sub>'' takú, že pre ''i = 1,...,n'' existuje v danom grafe hrana z ''v<sub>i-1</sub>'' do ''v<sub>i</sub>''.
* ''Cestou'' rozumieme sled ''v<sub>0</sub>, v<sub>1</sub>, ..., v<sub>n</sub>'' taký, že vrcholy ''v<sub>0</sub>, v<sub>1</sub>, ..., v<sub>n</sub>'' sú po dvoch rôzne.
* ''Dĺžkou sledu'' (alebo cesty) ''v<sub>0</sub>, v<sub>1</sub>, ..., v<sub>n</sub>'' nazveme číslo ''n'', čiže počet hrán tento sled tvoriacich.  

Pre ''neorientované'' grafy možno problém existencie cesty medzi dvoma vrcholmi chápať aj ako úlohu zistiť, či sú tieto dva vrcholy v rovnakom ''komponente súvislosti'' grafu. Komponent súvislosti neorientovaného grafu je každý jeho (vzhľadom na inklúziu) maximálny podgraf, ktorý je súvislý &ndash; komponent súvislosti grafu teda pozostáva z nejakej podmnožiny jeho vrcholov a všetkých hrán pôvodného grafu spájajúcich vrcholy z tejto podmnožiny, pričom ľubovoľné dva vrcholy komponentu sú spojené cestou a pridaním ľubovoľného ďalšieho vrcholu grafu sa táto vlastnosť poruší. (Pri tejto &bdquo;definícii&rdquo; využívame fakt, že existencia cesty v ''neorientovanom'' grafe je zjavne reláciou ekvivalencie na množine jeho vrcholov.) Napríklad neorientovaný graf na nasledujúcom obrázku pozostáva z troch komponentov súvislosti.

[[Súbor:Graf3.png|center]]

Na riešenie problému existencie cesty použijeme ''prehľadávanie do hĺbky'' (angl. ''depth-first search'') &ndash; podobné, ako sme už používali minulý semester pri vyfarbovaní súvislých oblastí v obdĺžnikovej mriežke. Procedúra na grafoch však bude všeobecnejšia:
* Mriežku môžeme reprezentovať neorientovaným grafom, v ktorom vrcholy zodpovedajú políčkam mriežky. Dvojica vrcholov je navyše spojená hranou práve vtedy, keď zodpovedajúce políčka spolu susedia a súčasne majú rovnakú farbu.
* Ostrovy rovnakej farby v mriežke potom zodpovedajú komponentom súvislosti výsledného neorientovaného grafu.

Na riešenie uvedeného problému napíšeme rekurzívnu metódu <tt>search</tt>, ktorá bude prehľadávať všetkých ešte nenavštívených následníkov daného vrcholu. Informáciu o navštívení jednotlivých vrcholov si budeme uchovávať v zozname <tt>visited</tt>. Metóda <tt>existsPath</tt> bude metódu <tt>search</tt> využívať na riešenie horeuvedeného problému. 

<syntaxhighlight lang="java">
/**
* Pomocna metoda pre metodu existsPath, ktora rekurzivne prehlada vsetky doposial nenavstivene vrcholy
* dosiahnutelne z daneho vrcholu.
* @param g       Orientovany alebo neorientovany graf, v ktorom sa prehladavanie realizuje.
* @param vertex  Vrchol grafu g, v ktorom sa prehladavanie zacina.
* @param visited Zoznam obsahujuci informacie o navstiveni jednotlivych vrcholov grafu. Pri volani metody by malo
*                platit visited.get(vertex) == false.
*/
private static void search(Graph g, int vertex, List<Boolean> visited) {
    visited.set(vertex, true);
    for (int successor : g.outgoingEdgesDestinations(vertex)) {
        if (!visited.get(successor)) {
            search(g, successor, visited);
        }
    }
}

/**
 * Metoda, ktora zisti, ci je dvojica vrcholov grafu spojena cestou.
 * @param g    Graf, v ktorom sa uloha realizuje.
 * @param from Pociatocny vrchol.
 * @param to   Koncovy vrchol.
 * @return     Vystup je true prave vtedy, ked v grafe g existuje cesta z vrcholu from do vrcholu to.
 */
public static boolean existsPath(Graph g, int from, int to) {
    ArrayList<Boolean> visited = new ArrayList<>();
    for (int i = 0; i <= g.getNumberOfVertices() - 1; i++) {
        visited.add(false);
    }
    search(g, from, visited);
    return visited.get(to);
}
</syntaxhighlight>

''Cvičenie.'' Vytvorte abstraktnú triedu <tt>AbstractGraph</tt> implementujúcu rozhranie <tt>Graph</tt> a upravte triedy <tt>SuccessorListsGraph</tt> a <tt>AdjacencyMatrixGraph</tt> tak, aby dedili od triedy <tt>AbstractGraph</tt>. Prepíšte metódy <tt>existsPath</tt> a <tt>search</tt> uvedené vyššie ako metódy inštancie triedy <tt>AbstractGraph</tt>. Aký bude mať táto zmena vplyv na argumenty týchto metód?

=== Hľadanie komponentov súvislosti neorientovaného grafu ===

V prípade, že pracujeme s ''neorientovaným'' grafom a existenciu cesty medzi dvojicami vrcholov by sme chceli testovať veľakrát, oplatí sa nájsť všetky komponenty súvislosti v danom grafe. Komponenty môžeme očíslovať od nuly až po nejaké ''k - 1'', pričom pre každý vrchol si môžeme pamätať číslo jeho komponentu. Túto úlohu realizuje nasledujúca trieda:
<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda reprezentujuca rozdelenie neorientovaneho grafu na komponenty suvislosti.
 */
public class Components {
    /**
     * Neorientovany graf, ktoreho komponenty suvislosti su instanciou tejto triedy reprezentovane.
     */
    private UndirectedGraph g;

    /**
     * Zoznam, v ktorom si pre kazdy vrchol grafu g budeme pamatat cislo jeho komponentu.
     */
    private ArrayList<Integer> componentId;

    /**
     * Celkovy pocet komponentov suvislosti grafu g.
     */
    private int componentCount;

    /**
     * Konstruktor, ktory dostane ako argument neorientovany graf, najde komponenty suvislosti tohto grafu a informacie
     * o nich ulozi do premennych instancie.
     * @param g Neorientovany graf, ktoreho komponenty su reprezentovane instanciou tejto triedy.
     */
    public Components(UndirectedGraph g) {
        this.g = g;
        componentCount = 0;
        int n = g.getNumberOfVertices();

        componentId = new ArrayList<>();
        for (int i = 0; i <= n - 1; i++) {
            componentId.add(-1);
        }

        for (int i = 0; i <= n - 1; i++) {
            if (componentId.get(i) == -1) {
                search(i, componentCount);
                componentCount++;
            }
        }
    }

    /**
     * Pomocna metoda pre konstruktor, ktora oznaci vrcholy jedneho komponentom suvislosti identifikatorom tohto
     * komponentu. Pracuje na baze prehladavania do hlbky.
     * @param vertex Vrchol, z ktoreho sa zacina prehladavanie vrcholov komponentu.
     * @param id     Identifikator komponentu suvislosti.
     */
    private void search(int vertex, int id) {
        componentId.set(vertex, id);
        for (int neighbour : g.outgoingEdgesDestinations(vertex)) {
            if (componentId.get(neighbour) == -1) {
                search(neighbour, id);
            }
        }
    }

    /**
     * Metoda, ktora zisti, ci v grafe, ktoreho komponenty reprezentuje instancia tejto triedy, existuje cesta spajajuca
     * danu dvojicu vrcholov.
     * @param from Pociatocny vrchol.
     * @param to   Koncovy vrchol.
     * @return     Metoda vrati true prave vtedy, ked v grafe existuje cesta z vrcholu from do vrcholu to.
     */
    public boolean existsPath(int from, int to) {
        return componentId.get(from).equals(componentId.get(to));
    }

    /**
     * Metoda, ktora vrati celkovy pocet komponentov grafu.
     * @return Pocet komponentov.
     */
    public int getComponentCount() {
        return componentCount;
    }
}
</syntaxhighlight>

Nasledujúci kód načíta neorientovaný graf a dvojicu jeho vrcholov. Na konzolu následne vypíše, či sú tieto dva vrcholy v danom grafe spojené cestou.

<syntaxhighlight lang="java">
public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("Zadaj neorientovany graf:");
    UndirectedGraph g = (UndirectedGraph) readGraph(scanner, GraphType.UNDIRECTED_ADJACENCY_LISTS);
    System.out.println("Zadaj dvojicu vrcholov grafu:");
    int from = scanner.nextInt();
    int to = scanner.nextInt();

    Components components = new Components(g);
    if (components.existsPath(from, to)) {
        System.out.println("Vrcholy su spojene cestou.");
    } else {
        System.out.println("Vrcholy nie su spojene cestou.");
    }
}
</syntaxhighlight>

== Prehľadávanie (orientovaného alebo neorientovaného) grafu do šírky ==

Podobne ako prehľadávanie do hĺbky možno vo všeobecnejšom kontexte grafov aplikovať aj ''prehľadávanie do šírky'' (angl. ''breadth-first search''), ktorého variant pre obdĺžnikovú mriežku poznáme z minulého semestra. Prehľadávanie grafu do šírky bude možné použiť na hľadanie ''najkratších ciest'' medzi dvojicami vrcholov orientovaného (a teda aj neorientovaného) grafu, kde dĺžka cesty je meraná počtom hrán. 

=== Hľadanie najkratšej cesty ===

Hľadanie najkratších ciest v grafe &ndash; či už orientovanom alebo neorientovanom &ndash; možno realizovať napríklad nasledujúcou triedou <tt>ShortestPathsFromVertex</tt>:
* Jej konštruktor dostane ako parameter graf <tt>g</tt> a nejaký jeho význačný &bdquo;štartovací&rdquo; vrchol <tt>start</tt>. Následne spustí na grafe <tt>g</tt> prehľadávanie do šírky z vrcholu <tt>start</tt>.
* Takto sa postupne prehľadajú vrcholy vo vzdialenosti 1 od <tt>start</tt>, potom vrcholy vo vzdialenosti 2 od <tt>start</tt>, atď. Na zabezpečenie takéhoto poradia sa použije rad, podobne ako pri algoritme na mriežke minulý semester. V každom momente vykonávania algoritmu môže tento rad obsahovať vrcholy najviac dvoch rôznych vzdialeností od <tt>start</tt>.
* Pre každý vrchol <tt>v</tt> sa počas prehľadávania do zoznamu <tt>dist</tt> uloží jeho vzdialenosť od vrcholu <tt>start</tt> a do zoznamu <tt>predecessors</tt> sa uloží vrchol <tt>u</tt>, z ktorého bol vrchol <tt>v</tt> objavený &ndash; musí pritom vždy ísť o predposledný vrchol na jednej z najkratších ciest zo <tt>start</tt> do <tt>v</tt>.
* Metóda <tt>distanceFromStart</tt> bude pre daný vrchol <tt>vertex</tt> vracať jeho vzdialenosť od vrcholu <tt>start</tt>. Tu sa jednoducho využije hodnota uložená v zozname <tt>dist</tt>.
* Metóda <tt>shortestPathFromStart</tt> bude pre daný vrchol <tt>vertex</tt> vracať najkratšiu cestu z vrcholu <tt>start</tt> do vrcholu <tt>vertex</tt> reprezentovanú zoznamom vrcholov. Tú bude konštruovať od konca: začne vo vrchole <tt>vertex</tt> a postupne bude hľadať predchodcov pomocou hodnôt uložených v zozname <tt>predecessors</tt>.

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda reprezentujuca najkratsie cesty z pevne daneho pociatocneho vrcholu do vsetkych ostatnych vrcholov grafu.
 */
public class ShortestPathsFromVertex {
    /**
     * Graf, v ktorom sa hladanie najkratsich ciest realizuje.
     */
    private Graph g;

    /**
     * "Startovaci" vrchol. Instancia triedy bude reprezentovat najkratsie cesty z tohto vrcholu do vsetkych ostatnych
     * vrcholov grafu g.
     */
    private int start;

    /**
     * Zoznam obsahujuci pre kazdy vrchol grafu jeho vzdialenost zo startovacieho vrcholu start. Ak zo start do nejakeho
     * vrcholu nevedie ziadna cesta, bude namiesto jeho vzdialenosti v zozname ulozena hodnota -1.
     */
    private List<Integer> distances;

    /**
     * Zoznam obsahujuci pre kazdy vrchol v grafu g jeho predchodcu na najkratsej ceste z vrcholu start do vrcholu v.
     * Pre vrchol start samotny a vrcholy, do ktorych zo start nevedie ziadna cesta, bude v zozname ulozena hodnota -1.
     */
    private List<Integer> predecessors;

    /**
     * Konstruktor, ktory pre dany graf a "startovaci" vrchol rovno aj najde najkratsie cesty zo startovacieho vrcholu
     * do vsetkych ostatnych vrcholov grafu.
     * @param g     Graf, v ktorom sa hladanie ciest realizuje.
     * @param start "Startovaci" vrchol.
     */
    public ShortestPathsFromVertex(Graph g, int start) {
        this.g = g;
        this.start = start;

        /* Inicializacia zoznamov dist a predecessors: */
        distances = new ArrayList<>();
        predecessors = new ArrayList<>();
        for (int i = 0; i <= g.getNumberOfVertices() - 1; i++) {
            distances.add(-1);
            predecessors.add(-1);
        }

        /* Samotne prehladavanie do sirky: */
        Queue<Integer> queue = new LinkedList<>();
        distances.set(start, 0);
        queue.add(start);
        while (!queue.isEmpty()) {
            // Vyberieme vrchol z radu, prejdeme vsetkych jeho naslednikov, nenavstivenych spracujeme a vlozime do radu:
            int vertex = queue.remove();
            for (int successor : g.outgoingEdgesDestinations(vertex)) {
                if (distances.get(successor) == -1) {
                    distances.set(successor, distances.get(vertex) + 1);
                    predecessors.set(successor, vertex);
                    queue.add(successor);
                }
            }
        }
    }

    /**
     * Metoda, ktora vrati dlzku najkratsej cesty z vrcholu start do daneho vrcholu.
     * @param vertex Vrchol, vzdialenost ktoreho z vrcholu start sa pocita.
     * @return       Dlzka najkratsej cesty z vrcholu start do vrcholu vertex. Ak ziadna neexistuje, vrati sa -1.
     */
    public int distanceFromStart(int vertex) {
        return distances.get(vertex);
    }

    /**
     * Metoda, ktora vrati najkratsiu cestu z vrcholu start do daneho vrcholu, reprezentovanu ako zoznam vrcholov.
     * @param vertex Vrchol, najkratsia cesta do ktoreho z vrcholu start sa pocita.
     * @return       Nemodifikovatelny zoznam obsahujuci postupne vsetky vrcholy najkratsej cesty zo start do vertex.
     *               Ak ziadna cesta zo start do vertex neexistuje, vrati metoda referenciu null.
     */
    public List<Integer> shortestPathFromStart(int vertex) {
        if (distances.get(vertex) == -1) {
            return null;
        }
        LinkedList<Integer> path = new LinkedList<>();
        int v = vertex;
        while (v != -1) {
            path.addFirst(v);
            v = predecessors.get(v);
        }
        return path;
    }
}
</syntaxhighlight>

Nasledujúci kód načíta graf a dvojicu jeho vrcholov; vypíše najkratšiu cestu medzi danými vrcholmi.
<syntaxhighlight lang="java">
public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("Zadaj graf:");
    Graph g = readGraph(scanner, GraphType.DIRECTED_SUCCESSOR_LISTS);
    System.out.println("Zadaj pociatocny a koncovy vrchol:");
    int from = scanner.nextInt();
    int to = scanner.nextInt();

    ShortestPathsFromVertex shortestPathsFromVertex = new ShortestPathsFromVertex(g, from);
    System.out.println("Najkratsia cesta ma dlzku " + shortestPathsFromVertex.distanceFromStart(to) + ".");
    List<Integer> shortestPath = shortestPathsFromVertex.shortestPathFromStart(to);
    if (shortestPath != null) {
        System.out.println(shortestPath);
    }
}
</syntaxhighlight>

== Stromy prehľadávania do hĺbky a do šírky ==

Označme pri prehľadávaní do hĺbky aj do šírky tie hrany, ktoré boli použité pri objavovaní nových vrcholov &ndash; to znamená: pri prehľadávaní do hĺbky hrany ''(u,v)'' také, že vo volaní metódy <tt>search</tt> pre vrchol ''u'' sa táto metóda zavolala rekurzívne aj pre vrchol ''v'' a pri prehľadávaní do šírky hrany ''(u,v)'' také, že sa v rámci prehľadávania následníkov vrcholu ''u'' do radu pridal vrchol ''v''.

* V oboch prípadoch potom takéto hrany tvoria strom zakorenený vo vrchole, v ktorom prehľadávanie začalo (pri orientovaných grafoch sú všetky hrany orientované smerom od koreňa k listom). 
* Hovoríme teda o ''stromoch prehľadávania do hĺbky'' resp. ''do šírky'' (angl. ''DFS Tree'' resp. ''BFS Tree'').
* V prípade, že je graf neorientovaný a súvislý, ide v obidvoch prípadoch o jeho ''kostru'' (t. j. strom zložený zo ''všetkých'' vrcholov grafu a jeho vybraných hrán).
* U stromov prehľadávania ''do šírky'' reprezentujú cesty od koreňa k listom vždy niektorú z najkratších ciest medzi príslušnými vrcholmi grafu.

''Príklad.'' Nižšie je znázornený diagram orientovaného grafu a jeho stromy prehľadávania do hĺbky a do šírky v prípade, že prehľadávanie začne vo vrchole 0 a pri spracúvaní následníkov sa postupuje vzostupne podľa čísel vrcholov (čo nemusí byť vždy tak).

''Strom prehľadávania do hĺbky:''
<center>
[[Súbor:Graf4.png]] &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[[Súbor:Graf4DFS.png]] &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; [[Súbor:DFSTree.png]]
</center>

''Strom prehľadávania do šírky:''
<center>
[[Súbor:Graf4.png]] &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[[Súbor:Graf4BFS.png]] &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; [[Súbor:BFSTree.png]]
</center>

== Prehľadávanie s návratom na grafoch ==

Pre veľa úloh na grafoch nie sú známe &ndash; a v prípade platnosti niektorých hypotéz z teoretickej informatiky často ani neexistujú &ndash; žiadne efektívne algoritmy. Prehľadávaním s návratom však vieme spočítať odpoveď aspoň pre malé vstupy.

=== Hľadanie ciest dĺžky ''k'' ===

Nasledujúca trieda <tt>FixedLengthPaths</tt> pre daný graf <tt>g</tt>, danú dvojicu vrcholov <tt>from, to</tt> a dané prirodzené číslo <tt>length</tt> nájde všetky cesty dĺžky ''presne'' <tt>length</tt> vedúce v <tt>g</tt> z vrcholu <tt>from</tt> do vrcholu <tt>to</tt>. Prehľadávanie s návratom sa spustí hneď v konštruktore a nájdené cesty sa uložia do zoznamu <tt>paths</tt>.

Pri prehľadávaní sa v spájanom zozname <tt>path</tt> budú postupne generovať všetky cesty hľadaného typu. Pre každý vrchol budeme mať navyše v <tt>ArrayList</tt>-e <tt>visited</tt> poznačené, či sme ho už v generovanej ceste použili. Akonáhle nájdeme cestu požadovanej dĺžky končiacu vo vrchole <tt>to</tt>, uložíme ju do zoznamu <tt>paths</tt>.

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda realizujuca najdenie vsetkych ciest danej fixnej dlzky medzi danou dvojicou vrcholov daneho grafu.
 */
public class FixedLengthPaths {
    /**
     * Graf, v ktorom sa hladanie ciest realizuje.
     */
    private Graph g;

    /**
     * Pociatocny vrchol hladanych ciest.
     */
    private int from;

    /**
     * Koncovy vrchol hladanych ciest.
     */
    private int to;

    /**
     * Pozadovana dlzka hladanych ciest.
     */
    private int length;

    /**
     * Pomocny zoznam, v ktorom sa budu pomocou prehladavania s navratom postupne generovat jednotlive cesty.
     */
    private LinkedList<Integer> path;

    /**
     * Pomocny zoznam, v ktorom si budeme pocas generovania ciest pre kazdy vrchol pamatat, ci sa nachadza alebo
     * nenachadza v doposial vygenerovanej casti cesty.
     */
    private ArrayList<Boolean> visited;

    /**
     * Zoznam, v ktorom budu ulozene vsetky vygenerovane cesty.
     */
    private List<List<Integer>> paths;

    /**
     * Konstruktor, ktory rovno aj spusti prehladavanie s navratom a do zoznamu paths postupne ulozi vsetky cesty danej
     * dlzky medzi danou dvojicou vrcholov daneho grafu.
     * @param g      Graf, v ktorom sa hladanie ciest realizuje.
     * @param from   Pociatocny vrchol hladanych ciest.
     * @param to     Koncovy vrchol hladanych ciest.
     * @param length Pozadovana dlzka hladanych ciest.
     */
    public FixedLengthPaths(Graph g, int from, int to, int length) {
        this.g = g;
        this.from = from;
        this.to = to;
        this.length = length;
        paths = new LinkedList<>();

        visited = new ArrayList<>();
        for (int i = 0; i <= g.getNumberOfVertices() - 1; i++) {
            visited.add(false);
        }
        path = new LinkedList<>();
        path.add(from);
        visited.set(from, true);
        search();
    }

    /**
     * Metoda realizujuca samotne rekurzivne prehladavanie s navratom. Ak je dosial vygenerovana cast cesty kratsia nez
     * length, postupne sa vyskusaju vsetky moznosti jej predlzenia. V pripade, ze uz ide o cestu dlzky length, overi
     * sa, ci cesta konci vo vrchole to a ak ano, prida sa kopia tejto cesty do zoznamu paths.
     */
    private void search() {
        if (path.size() == length + 1) {   // Dlzka zoznamu je vzdy o jedna vacsia, nez dlzka nim reprezentovanej cesty.
            if (path.getLast() == to) {
                paths.add(Collections.unmodifiableList(new LinkedList<>(path)));
            }
        } else {
            for (int successor : g.outgoingEdgesDestinations(path.getLast())) {
                if (!visited.get(successor)) {
                    visited.set(successor, true);
                    path.add(successor);
                    search();
                    path.removeLast();
                    visited.set(successor, false);
                }
            }
        }
    }

    /**
     * Metoda, ktora vrati nemodifikovatelny pohlad na zoznam vsetkych vygenerovanych ciest.
     * @return Nemodifikovatelny zoznam vsetkych ciest dlzky length veducich v grafe g z vrcholu from do vrcholu to.
     */
    public List<List<Integer>> getPaths() {
        return Collections.unmodifiableList(paths);
    }
}
</syntaxhighlight>

Nasledujúci kód načíta graf, dvojicu vrcholov <tt>from, to</tt> a prirodzené číslo <tt>length</tt> a vypíše všetky cesty dĺžky <tt>length</tt> z vrcholu <tt>from</tt> do vrcholu <tt>to</tt>.
<syntaxhighlight lang="java">
public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("Zadaj graf:");
    Graph g = readGraph(scanner, GraphType.DIRECTED_SUCCESSOR_LISTS);
    System.out.println("Zadaj pociatocny a koncovy vrchol:");
    int from = scanner.nextInt();
    int to = scanner.nextInt();
    System.out.println("Zadaj dlzku generovanych ciest:");
    int length = scanner.nextInt();
  
    FixedLengthPaths fixedLengthPaths = new FixedLengthPaths(g, from, to, length);
    System.out.println("Cesty dlzky " + length + ":");
    for (List<Integer> path : fixedLengthPaths.getPaths()) {
        System.out.println(path);
    }
}
</syntaxhighlight>

[[Image:Graf5.png|thumb|130px|right]]
''Príklad''. Pre orientovaný graf s vrcholmi ''{0,...,4}'' a hranami ''{(0,1),(0,2),(0,3),(1,2),(2,3),(2,4),(4,3)}'', počiatočný vrchol ''0'' a koncový vrchol ''3'' dostávame nasledujúce výstupy
<pre>
Cesty dlzky 1:
[0, 3]
Cesty dlzky 2:
[0, 2, 3]
Cesty dlzky 3:
[0, 1, 2, 3]
[0, 2, 4, 3]
Cesty dlzky 4:
[0, 1, 2, 4, 3]
</pre>

''Cvičenia'':
* Upravte triedu <tt>FixedLengthPaths</tt> tak, aby namiesto hľadania a ukladania všetkých ciest danej dĺžky iba počítala, koľko ich je.
* Upravte triedu <tt>FixedLengthPaths</tt> tak, aby iba zisťovala, či existuje cesta danej dĺžky (po prvej nájdenej ceste je teda možné prehľadávanie ukončiť).
* Navrhnite spôsoby, ako v niektorých prípadoch zistiť, že aktuálne rozrobenú cestu už nie je možné požadovaným spôsobom rozšíriť.

===Hľadanie najdlhšej cesty===

Uvažujme teraz problém nájdenia nejakej z najdlhších ciest z ''u'' do ''v'' (ak existuje aspoň jedna). Túto úlohu bude realizovať trieda <tt>LongestPath</tt>, ktorá sa oproti triede <tt>FixedLengthPaths</tt> bude líšiť len málo.
* Počas prehľadávania si budeme pamätať najdlhšiu doposiaľ nájdenú cestu.
* Vždy, keď prídeme do cieľového vrcholu, porovnáme dĺžku práve nájdenej cesty s najdlhšou doposiaľ nájdenou cestou.

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda realizujuca najdenie najdlhsej cesty medzi danou dvojicou vrcholov grafu.
 */
public class LongestPath {
    /**
     * Graf, v ktorom sa hladanie ciest realizuje.
     */
    private Graph g;

    /**
     * Pociatocny vrchol hladanych ciest.
     */
    private int from;

    /**
     * Koncovy vrchol hladanych ciest.
     */
    private int to;

    /**
     * Pomocny zoznam, v ktorom sa budu pomocou prehladavania s navratom postupne generovat jednotlive cesty.
     */
    private LinkedList<Integer> path;

    /**
     * Pomocny zoznam, v ktorom si budeme pocas generovania ciest pre kazdy vrchol pamatat, ci sa nachadza alebo
     * nenachadza v doposial vygenerovanej casti cesty.
     */
    private ArrayList<Boolean> visited;

    /**
     * Zoznam, v ktorom bude ulozena najdlhsia cesta medzi danou dvojicou vrcholov (pocas prehladavania pojde
     * o najdlhsiu doposial najdenu cestu).
     */
    private List<Integer> longestPath;

    /**
     * Konstruktor, ktory rovno aj spusti prehladavanie s navratom a do zoznamu longestPath ulozi niektoru spomedzi
     * najdlhsich ciest medzi danou dvojicou vrcholov grafu.
     * @param g      Graf, v ktorom sa hladanie ciest realizuje.
     * @param from   Pociatocny vrchol hladanych ciest.
     * @param to     Koncovy vrchol hladanych ciest.
     */
    public LongestPath(Graph g, int from, int to) {
        this.g = g;
        this.from = from;
        this.to = to;

        visited = new ArrayList<>();
        for (int i = 0; i <= g.getNumberOfVertices() - 1; i++) {
            visited.add(false);
        }
        path = new LinkedList<>();
        path.add(from);
        visited.set(from, true);
        search();
    }

    /**
     * Metoda realizujuca samotne rekurzivne prehladavanie s navratom. V pripade, ze sa vygenerovala cesta konciaca
     * vo vrchole to, porovna sa jej dlzka s dlzkou doposial najdlhsej najdenej cesty a ak je dlhsia, ulozi sa ako nova
     * doposial najdlhsia cesta. V opacnom pripade sa vyskusaju vsetky moznosti predlzenia cesty.
     */
    private void search() {
        if (path.getLast() == to) {
            if (longestPath == null || path.size() > longestPath.size()) {
                longestPath = new LinkedList<>(path);
            }
        } else {
            for (int successor : g.outgoingEdgesDestinations(path.getLast())) {
                if (!visited.get(successor)) {
                    visited.set(successor, true);
                    path.add(successor);
                    search();
                    path.removeLast();
                    visited.set(successor, false);
                }
            }
        }
    }

    /**
     * Metoda, ktora vrati najdenu najdlhsiu cestu medzi danou dvojicou vrcholov.
     * @return Nemodifikovatelny pohlad na zoznam vrcholov na najdlhsej ceste z vrcholu from do vrcholu to.
     */
    public List<Integer> getLongestPath() {
        if (longestPath != null) {
            return Collections.unmodifiableList(longestPath);
        } else {
            return null;
        }
    }
}
</syntaxhighlight>

Použitie triedy:
<syntaxhighlight lang="java">
LongestPath longestPath = new LongestPath(g, from, to);
List<Integer> longest = longestPath.getLongestPath();
if (longest != null) {
    System.out.println("Najdlhsia cesta: " + longest);
}
</syntaxhighlight>

Príklad výstupu na rovnakom grafe ako vyššie pre počiatočný vrchol ''0'' a koncový vrchol ''3'':
<pre>
Najdlhsia cesta: [0, 1, 2, 4, 3]
</pre>
=Riešenia testu č. 3=
== Úloha č. 1 ==

<syntaxhighlight lang="java">
import java.util.*;

public class IncreasingIterator<E extends Comparable<E>> implements Iterator<E> {
    private Iterator<E> it;
    private E next;

    public IncreasingIterator(Iterable<E> iterable) {
        it = iterable.iterator();
        if (it.hasNext()) {
            next = it.next();
        }
    }

    @Override
    public boolean hasNext() {
        return next != null;
    }

    private void findNext() {
        E newNext = null;
        while (newNext == null && it.hasNext()) {
            E e = it.next();
            if (e.compareTo(next) > 0) {
                newNext = e;
            }
        }
        next = newNext;
    }

    @Override
    public E next() {
        E result = null;
        if (hasNext()) {
            result = next;
        } else {
            throw new NoSuchElementException();
        }
        findNext();
        return result;
    }

}
</syntaxhighlight>

== Úloha č. 2 ==

<syntaxhighlight lang="java">
private static void search(Graph g, int vertex, List<Boolean> visited) {
    visited.set(vertex, true);
    for (int successor : g.outgoingEdgesDestinations(vertex)) {
        if (!visited.get(successor)) {
            search(g, successor, visited);
        }
    }
}

private static boolean existsPath(Graph g, int from, int to) {
    ArrayList<Boolean> visited = new ArrayList<>();
    for (int i = 0; i <= g.getNumberOfVertices() - 1; i++) {
        visited.add(false);
    }
    search(g, from, visited);
    return visited.get(to);
}

public static boolean areMutuallyReachable(Graph g, int u, int v) {
    return existsPath(g, u, v) && existsPath(g, v, u);
}
</syntaxhighlight>

== Úloha č. 3 ==

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

public class Eccentricities {
    private int n;
    private List<Integer> eccentricities;
    private int radius = Integer.MAX_VALUE;

    public Eccentricities(UndirectedGraph g) {
        n = g.getNumberOfVertices();
        eccentricities = new ArrayList<>();

        for (int v = 0; v <= n - 1; v++) {
            int eccentricity = 0;
            List<Integer> distances = new ArrayList<>();
            for (int u = 0; u <= n - 1; u++) {
                distances.add(-1);
            }

            Queue<Integer> queue = new LinkedList<>();
            distances.set(v, 0);
            queue.add(v);
            while (!queue.isEmpty()) {
                int vertex = queue.remove();
                if (distances.get(vertex) > eccentricity) {
                    eccentricity = distances.get(vertex);
                }
                for (int successor : g.outgoingEdgesDestinations(vertex)) {
                    if (distances.get(successor) == -1) {
                        distances.set(successor, distances.get(vertex) + 1);
                        queue.add(successor);
                    }
                }
            }

            if (distances.contains(-1)) {
                eccentricity = Integer.MAX_VALUE;
            }

            eccentricities.add(eccentricity);
            if (eccentricity < radius) {
                radius = eccentricity;
            }
        }
    }

    public int eccentricity(int vertex) {
        return eccentricities.get(vertex);
    }

    public int radius() {
        return radius;
    }

    public boolean isCentral(int vertex) {
        return eccentricities.get(vertex) == radius;
    }
}
</syntaxhighlight>
=Letný semester, prednáška č. 9=
== Oznamy ==

* Dnes po prednáške bude zverejnené zadanie štvrtej domácej úlohy, ktorú bude potrebné odovzdať ''do pondelka 26. apríla, 9:00'' (čiže do začiatku jedenástej prednášky).
* Počas stredajších cvičení bude prebiehať štvrtý test zameraný predovšetkým na grafy a grafové algoritmy.
* V rámci stredajších cvičení tiež bude zverejnené zadanie tretej bonusovej úlohy s termínom odovzdania ''do stredy 28. apríla, 11:30''.
* Cvičenia v stredu 21. apríla ''budú'' aj napriek dekanskému voľnu (účasť je samozrejme dobrovoľná, rovnako ako aj na ostatných cvičeniach, na ktorých sa nepíše test).
* Boli vypísané ''predbežné'' termíny skúšok:
** Predtermín ''v piatok 14. mája, 11:30'' (ústne skúšky po 15:30). Maximálne 12 prihlásených študentov.
** Ďalšie termíny ''vo štvrtky 20. mája, 3. júna, 17. júna a 24. júna, vždy o 9:00'' (ústne skúšky po 14:00). Maximálne 18 prihlásených študentov na každý z termínov.
** Každý z termínov možno využiť ako riadny aj ako opravný; žiadne ďalšie termíny ale nebudú.
** Prípadné námietky voči týmto termínom dajte vedieť najneskôr na prednáške 26. apríla. Po tejto prednáške bude otvorené prihlasovanie na skúšky v AIS.
** Na každý z termínov bude potrebné prihlásiť sa cez AIS najneskôr 24 hodín vopred.

== Prehľadávanie s návratom na grafoch: pokračovanie ==

===Hľadanie najdlhšej cesty===

Uvažujme problém nájdenia niektorej z ''najdlhších ciest'' z vrcholu ''u'' do vrcholu ''v'' daného orientovaného grafu (ak existuje aspoň jedna). Je dokázané, že za predpokladu platnosti určitých hypotéz z teoretickej informatiky pre túto úlohu neexistuje žiaden efektívny algoritmus. Použijeme teda prehľadávanie s návratom. To bude realizovať trieda <tt>LongestPath</tt>, ktorú získame drobnou úpravou triedy <tt>FixedLengthPaths</tt> z minulej prednášky.
* Počas prehľadávania si budeme pamätať najdlhšiu doposiaľ nájdenú cestu.
* Vždy, keď prídeme do cieľového vrcholu, porovnáme dĺžku práve nájdenej cesty s najdlhšou doposiaľ nájdenou cestou.

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda realizujuca najdenie najdlhsej cesty medzi danou dvojicou vrcholov grafu.
 */
public class LongestPath {
    /**
     * Graf, v ktorom sa hladanie ciest realizuje.
     */
    private Graph g;

    /**
     * Pociatocny vrchol hladanych ciest.
     */
    private int from;

    /**
     * Koncovy vrchol hladanych ciest.
     */
    private int to;

    /**
     * Pomocny zoznam, v ktorom sa budu pomocou prehladavania s navratom postupne generovat jednotlive cesty.
     */
    private LinkedList<Integer> path;

    /**
     * Pomocny zoznam, v ktorom si budeme pocas generovania ciest pre kazdy vrchol pamatat, ci sa nachadza alebo
     * nenachadza v doposial vygenerovanej casti cesty.
     */
    private ArrayList<Boolean> visited;

    /**
     * Zoznam, v ktorom bude ulozena najdlhsia cesta medzi danou dvojicou vrcholov (pocas prehladavania pojde
     * o najdlhsiu doposial najdenu cestu).
     */
    private List<Integer> longestPath;

    /**
     * Konstruktor, ktory rovno aj spusti prehladavanie s navratom a do zoznamu longestPath ulozi niektoru spomedzi
     * najdlhsich ciest medzi danou dvojicou vrcholov grafu.
     * @param g      Graf, v ktorom sa hladanie ciest realizuje.
     * @param from   Pociatocny vrchol hladanych ciest.
     * @param to     Koncovy vrchol hladanych ciest.
     */
    public LongestPath(Graph g, int from, int to) {
        this.g = g;
        this.from = from;
        this.to = to;

        visited = new ArrayList<>();
        for (int i = 0; i <= g.getNumberOfVertices() - 1; i++) {
            visited.add(false);
        }
        path = new LinkedList<>();
        path.add(from);
        visited.set(from, true);
        search();
    }

    /**
     * Metoda realizujuca samotne rekurzivne prehladavanie s navratom. V pripade, ze sa vygenerovala cesta konciaca
     * vo vrchole to, porovna sa jej dlzka s dlzkou doposial najdlhsej najdenej cesty a ak je dlhsia, ulozi sa ako nova
     * doposial najdlhsia cesta. V opacnom pripade sa vyskusaju vsetky moznosti predlzenia cesty.
     */
    private void search() {
        if (path.getLast() == to) {
            if (longestPath == null || path.size() > longestPath.size()) {
                longestPath = new LinkedList<>(path);
            }
        } else {
            for (int successor : g.outgoingEdgesDestinations(path.getLast())) {
                if (!visited.get(successor)) {
                    visited.set(successor, true);
                    path.add(successor);
                    search();
                    path.removeLast();
                    visited.set(successor, false);
                }
            }
        }
    }

    /**
     * Metoda, ktora vrati najdenu najdlhsiu cestu medzi danou dvojicou vrcholov.
     * @return Nemodifikovatelny pohlad na zoznam vrcholov na najdlhsej ceste z vrcholu from do vrcholu to.
     */
    public List<Integer> getLongestPath() {
        if (longestPath != null) {
            return Collections.unmodifiableList(longestPath);
        } else {
            return null;
        }
    }
}
</syntaxhighlight>

Použitie triedy: 
<syntaxhighlight lang="java">
public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("Zadaj graf:");
    Graph g = readGraph(scanner, GraphType.DIRECTED_SUCCESSOR_LISTS);
    System.out.println("Zadaj pociatocny a koncovy vrchol:");
    int from = scanner.nextInt();
    int to = scanner.nextInt();

    LongestPath longestPath = new LongestPath(g, from, to); 
    List<Integer> longest = longestPath.getLongestPath();
    if (longest != null) {
        System.out.println("Najdlhsia cesta: " + longest);
    } else {
        System.out.println("Ziadna cesta neexistuje.");
    }
}
</syntaxhighlight> 

:::[[Súbor:Graf5.png]]

Príklad výstupu pre graf na obrázku vyššie, počiatočný vrchol ''0'' a koncový vrchol ''3'':
<pre>
Najdlhsia cesta: [0, 1, 2, 4, 3]
</pre>

=== Hľadanie najväčšej kliky v neorientovanom grafe ===

Uvažujme teraz neorientované grafy bez slučiek (slučky síce nebudeme zakazovať, ale v našich nasledujúcich úvahách ich budeme ignorovať; najvhodnejšia predstava teda je, že pracujeme s grafmi, ktoré žiadne slučky neobsahujú).

* ''Klikou'' (angl. ''clique'') v neorientovanom grafe rozumieme jeho ''úplný podgraf'', čiže podmnožinu ''K'' množiny vrcholov grafu takú, že každé dva rôzne vrcholy z ''K'' sú navzájom spojené hranou. ''Veľkosťou kliky'' rozumieme počet vrcholov kliku tvoriacich. Špeciálne každý vrchol sám o sebe tvorí kliku veľkosti jedna a ľubovoľné dva vrcholy spojené hranou tvoria kliku veľkosti dva.
* V grafoch na nasledujúcom obrázku sú vyznačené kliky veľkosti tri a štyri.

:::[[Súbor:Kliky.png]]

Budeme sa teraz zaoberať problémom nájdenia ''najväčšej kliky'' (angl. ''maximum clique'') v neorientovanom grafe.
* Ide o nájdenie kliky s najväčšou veľkosťou spomedzi všetkých klík daného grafu.
* Pozor na terminológiu: ''maximálna klika'' (angl. ''maximal clique'') je ľubovoľná klika, ktorú nemožno pridaním ďalšieho vrcholu rozšíriť na väčšiu kliku. ''Nie každá maximálna klika ale musí byť aj najväčšia''. My sa budeme zaoberať prakticky užitočnejším problémom hľadania najväčších klík.
* Aj pre problém najväčšej kliky je dokázané, že v prípade platnosti určitých hypotéz z teoretickej informatiky preň neexistuje žiaden efektívny algoritmus. Použijeme teda prehľadávanie s návratom &ndash; nebudeme ním však teraz konštruovať cesty, ale množiny vrcholov grafu.
* Postupne budeme generovať všetky množiny vrcholov daného grafu ako utriedené spájané zoznamy. Zakaždým sa pokúsime daný vrchol do množiny pridať a rekurzívne pokračovať na ďalší vrchol, následne sa ho pokúsime vynechať a tiež rekurzívne pokračovať na ďalší vrchol. Po vygenerovaní kompletnej množiny zistíme, či ide o kliku; ak áno, porovnáme jej veľkosť s najväčšou doposiaľ nájdenou klikou, ktorú v prípade potreby aktualizujeme.

Trieda <tt>MaximumClique</tt> realizujúca nájdenie najväčšej kliky v neorientovanom grafe:
<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda realizujuca najdenie niektorej spomedzi najvacsich klik v danom neorientovanom grafe.
 */
public class MaximumClique {
    /**
     * Neorientovany graf, v ktorom sa hladanie najvacsej kliky realizuje.
     */
    private UndirectedGraph g;

    /**
     * Zoznam vrcholov najvacsej kliky neorientovaneho grafu g, resp. pocas prehladavania s navratom doposial najvacsej
     * najdenej kliky.
     */
    private LinkedList<Integer> maximumClique;

    /**
     * Zoznam, v ktorom sa pocas prehladavania s navratom budu postupne generovat vsetky (utriedene) mnoziny vrcholov
     * grafu g.
     */
    private LinkedList<Integer> currentVertices;

    /**
     * Konstruktor, ktory pomocou prehladavania s navratom najde najvacsiu kliku v danom neorientovanom grafe.
     * @param g Neorientovany graf, v ktorom sa hladanie najvacsej kliky realizuje.
     */
    public MaximumClique(UndirectedGraph g) {
        this.g = g;
        maximumClique = new LinkedList<>();
        currentVertices = new LinkedList<>();
        search(0);
    }

    /**
     * Rekurzivna metoda realizujuca samotne prehladavnie s navratom a v zozname currentVertices postupne generujuca
     * vsetky (utriedene) mnoziny vrcholov grafu g. Predpoklada sa, ze pred volanim metody reprezentuje zoznam
     * currentVertices nejaku utriedenu podmnozinu mnoziny vrcholov &lbrace;0,...,vertex-1&rbrace;. Metoda search
     * sa najprv pokusi pridat do zoznamu vrchol vertex a vygenerovat vsetky mnoziny obsahujuce vrcholy z tohto zoznamu;
     * nasledne sa pokusi vrchol vertex do zoznamu nepridat a taktiez vygeneruje vsetky taketo mnoziny.
     * Volanie metody pre vertex == 0 teda postupne vygeneruje vsetky utriedene mnoziny vrcholov grafu g. V pripade, ze
     * vertex == g.getNumberOfVertices(), povazuje sa mnozina vrcholov za vygenerovanu a zisti sa, ci ide o najvacsiu
     * doposial najdenu kliku v grafe g.
     * @param vertex Vrchol neorientovaneho grafu g alebo hodnota g.getNumberOfVertices().
     */
    private void search(int vertex) {
        if (vertex == g.getNumberOfVertices()) {
            if (isClique(currentVertices) && currentVertices.size() > maximumClique.size()) {
                maximumClique = new LinkedList<>(currentVertices);
            }
        } else {
            currentVertices.addLast(vertex);
            search(vertex + 1);
            currentVertices.removeLast();
            search(vertex + 1);
        }
    }

    /**
     * Pomocna metoda, ktora zisti, ci dane zoskupenie vrcholov zodpoveda klike v neorientovanom grafe g.
     * @param vertices Zoskupenie vrcholov grafu g.
     * @return         Metoda vrati true prave vtedy, ked vrcholy zoskupenia vertices tvoria kliku v grafe g.
     */
    private boolean isClique(Collection<Integer> vertices) {
        for (int u : vertices) {
            for (int v : vertices) {
                if (u != v && !g.existsEdge(u, v)) {
                    return false;
                }
            }
        }
        return true;
    }

    /**
     * Metoda, ktora vrati najdenu najvacsiu kliku v neorientovanom grafe g ako utriedeny zoznam jej vrcholov.
     * @return Nemodifikovatelny zoznam obsahujuci vo vzostupnom poradi vsetky vrcholy najdenej najvacsej kliky.
     */
    public List<Integer> getMaximumClique() {
        return Collections.unmodifiableList(maximumClique);
    }
}
</syntaxhighlight>

Použitie triedy <tt>MaximumClique</tt>:

<syntaxhighlight lang="java">
public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("Zadaj graf:");
    UndirectedGraph g = (UndirectedGraph) readGraph(scanner, GraphType.UNDIRECTED_ADJACENCY_LISTS);
  
    MaximumClique maximumClique = new MaximumClique(g);
    System.out.println("Najvacsia klika v zadanom grafe: " + maximumClique.getMaximumClique());
}
</syntaxhighlight>

Uvažujme napríklad graf na nasledujúcom obrázku.

:::[[Súbor:Graf6.png]]

Vyššie uvedený program preň vypíše nasledujúci výstup:
<pre>
Najvacsia klika v zadanom grafe: [0, 1, 2, 4]
</pre>

=== Mierne zrýchlenie hľadania najväčšej kliky ===

Pri hľadaní najväčšej kliky v neorientovanom grafe sme zakaždým prešli cez všetkých ''2<sup>n</sup>'' podmnožín ''n''-prvkovej množiny vrcholov grafu. Často je ale možné už behom prehľadávania rozoznať, že rozpracovanú množinu vrcholov nebude možné rozšíriť na najväčšiu kliku. Zapracujeme teda do prehľadávania s návratom v triede <tt>MaximumClique</tt> dve vylepšenia, ktoré síce nijak nezmenia časovú zložitosť algoritmu v najhoršom prípade, ale pre veľké množstvo grafov jeho vykonávanie podstatne urýchlia:
* Vrchol budeme pridávať do rozpracovanej množiny iba v prípade, že je spojený hranou so všetkými vrcholmi v tejto množine &ndash; v opačnom prípade už totiž z tejto množiny, ani po prípadnom pridaní ďalších vrcholov, kliku nikdy nevytvoríme. V takom prípade bude po vygenerovaní kompletnej množiny garantované, že ide o kliku a kontrolu metódou <tt>isClique</tt> môžeme vypustiť.
* Vrchol tiež budeme pridávať iba v prípade, že je počet jeho susedov &ndash; ktorý pre neorientované grafy bez slučiek možno nazvať aj ''stupňom'' vrcholu &ndash; väčší alebo rovný počtu vrcholov v doposiaľ najväčšej objavenej klike. Ak má totiž najväčšia doposiaľ objavená klika veľkosť ''k'', má pridanie vrcholu do rozpracovanej množiny zmysel iba v prípade, že bude môcť byť súčasťou kliky veľkosti aspoň ''k+1''; každý vrchol, ktorý je súčasťou takejto kliky, má evidentne aspoň ''k'' susedov.

Upravená trieda <tt>MaximumClique</tt>:
<syntaxhighlight lang="java">
package graphs;

import java.util.*;

public class MaximumClique {
    private UndirectedGraph g;
    private LinkedList<Integer> maximumClique;
    private LinkedList<Integer> currentVertices;

    public MaximumClique(UndirectedGraph g) {
        this.g = g;
        maximumClique = new LinkedList<>();
        currentVertices = new LinkedList<>();
        search(0);
    }

    private void search(int vertex) {
        if (vertex == g.getNumberOfVertices()) {
            if (currentVertices.size() > maximumClique.size()) {
                maximumClique = new LinkedList<>(currentVertices);
            }
        } else {
            if (hasEdgeToEach(vertex, currentVertices) && neighbourCount(vertex) >= maximumClique.size()) {
                currentVertices.addLast(vertex);
                search(vertex + 1);
                currentVertices.removeLast();
            }
            search(vertex + 1);
        }
    }

    private boolean hasEdgeToEach(int vertex, Collection<Integer> vertices) {
        for (int v : vertices) {
            if (!g.existsEdge(vertex, v)) {
                return false;
            }
        }
        return true;
    }

    private int neighbourCount(int vertex) {
        int result = 0;
        for (int v : g.outgoingEdgesDestinations(vertex)) {
            result++;
        }
        return result;
    }

    public List<Integer> getMaximumClique() {
        return Collections.unmodifiableList(maximumClique);
    }
}
</syntaxhighlight>

''Cvičenia'':
* Opíšte beh uvedeného programu na grafe obsahujúcom niekoľko vrcholov a žiadnu hranu.
* Urýchlite uvedený algoritmus vhodnou implementáciou metódy <tt>neighbourCount</tt> už v triedach pre grafy (keďže bude potrebná implementácia aj pre orientované grafy, bude asi vhodnejšie premenovať metódu na <tt>successorCount</tt> a implementovať ju tak, aby pre každý vrchol vrátila počet jeho následníkov v orientovanom grafe).

== Orientované acyklické grafy a topologické usporiadanie ==

Budeme teraz pracovať s ''orientovanými acyklickými grafmi'' &ndash; čiže orientovanými grafmi neobsahujúcimi žiaden cyklus. Takéto grafy sa zídu pri rôznych praktických úlohách, kde môžu reprezentovať napríklad časové závislosti &ndash; alebo ''prerekvizity'' &ndash; medzi vykonávanými činnosťami (celý proces je očividne vykonateľný práve vtedy, keď je tento orientovaný graf acyklický).

''Príklad orientovaného acyklického grafu:''

:::[[Súbor:Graf7.png]]

Pod ''topologickým usporiadaním'' orientovaného acyklického grafu o vrcholoch ''0,1,...,n-1'' budeme rozumieť permutáciu ''&pi;'': {''0,1,...,n-1''} &#8594; {''0,1,...,n-1''} takú, že pre všetky hrany ''(u,v)'' grafu platí ''&pi;''(''u'') &le; ''&pi;''(''v''). V princípe teda ide o úplné usporiadanie na množine vrcholov grafu (vrchol ''v'' vždy ide ako ''&pi;''(''v'')-ty v poradí) také, že všetky hrany v grafe idú &bdquo;v smere tohto usporiadania&rdquo;. Topologické usporiadanie teda napríklad môže určovať poradie, v ktorom možno vykonať jednotlivé činnosti tak, aby boli splnené všetky ich prerekvizity.
Väčšinou budeme pod topologickým usporiadaním chápať priamo postupnosť vrcholov v poradí určenom príslušnou permutáciou, t. j. ''&pi;<sup>-1</sup>''(''0''), ''&pi;<sup>-1</sup>''(''1''), ..., ''&pi;<sup>-1</sup>''(''n - 1''). Pod ''topologickým triedením'' budeme rozumieť proces hľadania topologického usporiadania.

Jeden orientovaný acyklický graf môže mať aj viacero topologických usporiadaní. Napríklad graf na obrázku vyššie má presne štyri topologické usporiadania:
<pre>
[5, 6, 4, 3, 1, 2, 0]
[6, 5, 4, 3, 1, 2, 0]
[5, 6, 4, 3, 2, 1, 0]
[6, 5, 4, 3, 2, 1, 0]
</pre>

''Poznámka'': matematicky o niečo výstižnejšia ekvivalentná definícia topologického usporiadania využíva fakt, že orientované acyklické grafy sú práve tie orientované grafy bez slučiek, ktorých reflexívno-tranzitívny uzáver možno chápať ako čiastočné usporiadanie na množine vrcholov (neexistencia cyklu zodpovedá antisymetrii). V tomto zmysle teda každý orientovaný acyklický graf jednoznačne určuje čiastočné usporiadanie &#10927; na množine vrcholov grafu. Topologické usporiadanie je potom ľubovoľné úplné usporiadanie &le; na tej istej množine vrcholov také, že &#10927; &#8838; &le;.

''Veta'': Každý orientovaný acyklický graf má aspoň jedno topologické usporiadanie.

''Dôkaz''. Indukciou vzhľadom na počet vrcholov. Graf o jednom vrchole ''v'' má evidentne topologické usporiadanie ''v''. Predpokladajme teraz, že tvrdenie platí pre všetky grafy veľkosti ''n'' a uvažujme orientovaný acyklický graf veľkosti ''n+1''. Ten musí obsahovať najmenej jeden vrchol, z ktorého nevychádza žiadna hrana &ndash; v opačnom prípade by totiž každý sled bolo možné predĺžiť na dlhší, pričom sled dĺžky ''n+1'' nutne musí obsahovať cyklus. Nech má túto vlastnosť vrchol ''u''. Podľa indukčného predpokladu potom existuje topologické usporiadanie grafu, ktorý z uvažovaného grafu získame odstránením vrcholu ''u'' a všetkých do neho vedúcich hrán (ten má totiž ''n'' vrcholov). Ak je týmto usporiadaním ''v<sub>1</sub>'',...,''v<sub>n</sub>'', je ''v<sub>1</sub>'',...,''v<sub>n</sub>'',''u'' topologickým usporiadaním uvažovaného grafu. &#9633;

Naopak je zrejmé, že orientovaný graf obsahujúci cyklus iný ako slučku nemôže mať žiadne topologické usporiadanie (napríklad žiaden vrchol cyklu nemôže byť spomedzi týchto vrcholov v usporiadaní prvý).

=== Topologické triedenie grafu ===

Napíšeme teraz statickú metódu <tt>topologicalSort</tt>, ktorá realizuje topologické triedenie daného orientovaného acyklického grafu.
* Vstupom metódy je orientovaný graf.
* V prípade, že je tento graf acyklický, vráti metóda na výstupe zoznam vrcholov zodpovedajúci nejakému jeho topologickému usporiadaniu.
* V opačnom prípade metóda vráti na výstupe referenciu <tt>null</tt>.

Samotný algoritmus si bude v zozname <tt>edgesFromUnprocessedVertices</tt> pre každý vrchol pamätať počet vrcholov, z ktorých do daného vrcholu vedie hrana a ktoré ešte neboli pridané do topologického usporiadania. Ak je tento počet pre nejaký vrchol nulový, možno ho pridať ako ďalší vrchol do topologického usporiadania. Vrcholy s touto vlastnosťou sa budú udržiavať v rade <tt>ready</tt> (rovnako dobre ako rad by sme mohli použiť aj inú dátovú štruktúru).

<syntaxhighlight lang="java">
public static List<Integer> topologicalSort(Graph g) {
    /* Inicializacia: */
    int n = g.getNumberOfVertices();
    List<Integer> edgesFromUnprocessedVertices = new ArrayList<>();
    for (int v = 0; v <= n - 1; v++) {
        edgesFromUnprocessedVertices.add(0);
    }
    for (int v = 0; v <= n - 1; v++) {
        for (int successor : g.outgoingEdgesDestinations(v)) {
            edgesFromUnprocessedVertices.set(successor, edgesFromUnprocessedVertices.get(successor) + 1);
        }
    }
    Queue<Integer> ready = new LinkedList<>();
    for (int v = 0; v <= n - 1; v++) {
        if (edgesFromUnprocessedVertices.get(v) == 0) {
            ready.add(v);
        }
    }
    List<Integer> result = new LinkedList<>();
 
    /* Samotne topologicke triedenie: */
    while (!ready.isEmpty()) {
        int vertex = ready.remove();
        result.add(vertex);
        for (int successor : g.outgoingEdgesDestinations(vertex)) {
            edgesFromUnprocessedVertices.set(successor, edgesFromUnprocessedVertices.get(successor) - 1);
            if (edgesFromUnprocessedVertices.get(successor) == 0) {
                ready.add(successor);
            }
        }
    }

    if (result.size() == n) {
        return result;
    } else {
        return null;
    }
}
</syntaxhighlight>

=== Topologické triedenie na báze prehľadávania do hĺbky ===

Ukážme si ešte alternatívnu metódu topologického triedenia grafu, založenú na nasledujúcej úprave prehľadávania do hĺbky:
* Okrem zoznamu <tt>visited</tt> si budeme udržiavať aj zoznam <tt>finished</tt>, v ktorom si pre každý vrchol grafu budeme pamätať, či prehľadávanie v ňom započaté už skončilo.
* Pri objavení vrcholu teda nastavíme na <tt>true</tt> príslušnú položku zoznamu <tt>visited</tt> a po vykonaní všetkých rekurzívnych volaní metódy <tt>search</tt> pre susedov daného vrcholu nastavíme na <tt>true</tt> aj príslušnú položku zoznamu <tt>finished</tt>.

V každom momente vykonávania takto upraveného prehľadávania do hĺbky teda existujú tri množiny vrcholov:
* Už spracované vrcholy, pre ktoré sú rovné <tt>true</tt> príslušné položky v zozname <tt>visited</tt> aj v zozname <tt>finished</tt>.
* &bdquo;Rozrobené&rdquo; vrcholy, pre ktoré je príslušná položka v zozname <tt>visited</tt> rovná <tt>true</tt>, ale príslušná položka v zozname <tt>finished</tt> je rovná <tt>false</tt>.
* Ešte nenavštívené vrcholy, pre ktoré sú príslušné položky v zozname <tt>visited</tt> aj v zozname <tt>finished</tt> rovné <tt>false</tt>.

Ľahko pritom vidieť, že graf obsahuje cyklus práve vtedy, keď počas prehľadávania grafu do hĺbky z niektorého vrcholu objavíme &bdquo;rozrobený&rdquo; vrchol. 

Pre účely topologického triedenia je kľúčová nasledujúca vlastnosť:
* Kedykoľvek v orientovanom acyklickom grafe skončí prehľadávanie do hĺbky z niektorého vrcholu <tt>v</tt> skôr, než prehľadávanie do hĺbky z vrcholu <tt>u</tt>, nemôže v tomto grafe viesť žiadna cesta z vrcholu <tt>v</tt> do vrcholu <tt>u</tt>. Ak totiž takáto cesta existuje, sú iba nasledujúce možnosti:
** Vrchol <tt>u</tt> je na začiatku prehľadávania z vrcholu <tt>v</tt> nenavštívený. V takom prípade ho musíme, ako ešte nenavštívený vrchol dosiahnuteľný z <tt>v</tt>, navštíviť v rámci prehľadávania z <tt>v</tt>. Potom však prehľadávanie z vrcholu <tt>u</tt> skončí skôr, než prehľadávanie z vrcholu <tt>v</tt>: spor s predpokladom.
** Vrchol <tt>u</tt> je na začiatku prehľadávania z vrcholu <tt>v</tt> &bdquo;rozrobený&rdquo;. To znamená, že sme vrchol <tt>v</tt> objavili v rámci prehľadávania spusteného vo vrchole <tt>u</tt> a z <tt>u</tt> do <tt>v</tt> teda vedie orientovaná cesta. Spojením tejto cesty s orientovanou cestou z <tt>v</tt> do <tt>u</tt> potom dostávame uzavretý sled: spor s predpokladom acyklickosti.
** Vrchol <tt>u</tt> je na začiatku prehľadávania z vrcholu <tt>v</tt> už spracovaný: spor s predpokladom, že prehľadávanie z <tt>v</tt> skončí skôr, než prehľadávanie z <tt>u</tt>.
* To znamená, že kedykoľvek prehľadávanie z nejakého vrcholu ukončíme, môžeme ho pridať na začiatok topologicky usporiadanej postupnosti vrcholov grafu.

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda realizujuca topologicke triedenie pomocou prehladavania do hlbky.
 */
public class TopologicalSort {
    /**
     * Graf, v ktorom sa topologicke triedenie realizuje.
     */
    private Graph g;

    /**
     * Vysledne topologicke usporiadanie alebo jeho cast.
     */
    private LinkedList<Integer> topologicalOrder;

    /**
     * Pole, v ktorom si pre kazdy vrchol pamatame, ci bol prehladavanim do hlbky navstiveny.
     */
    private ArrayList<Boolean> visited;

    /**
     * Pole, v ktorom si pre kazdy vrchol pamatame, ci bolo prehladavanie z neho ukoncene.
     */
    private ArrayList<Boolean> finished;

    /**
     * Po vykonani konstruktora bude true prave vtedy, ked je graf g acyklicky.
     */
    private boolean acyclic = true;

    /**
     * Konstruktor, ktory pomocou prehladavania do hlbky najde niektore z topologickych usporiadani daneho grafu, resp.
     * v pripade grafov obsahujuci cyklus nastavi premennu acyclic na false.
     * @param g Graf, v ktorom sa topologicke triedenie realizuje.
     */
    public TopologicalSort(Graph g) {
        this.g = g;
        int n = g.getNumberOfVertices();
        topologicalOrder = new LinkedList<>();
        visited = new ArrayList<>();
        finished = new ArrayList<>();

        for (int v = 0; v <= n - 1; v++) {
            visited.add(false);
            finished.add(false);
        }

        for (int v = 0; v <= n - 1; v++) {
            if (!visited.get(v)) {
                search(v);
            }
        }
    }

    /**
     * Metoda realizujuca samotne prehladavanie do hlbky z vrcholu vertex.
     * @param vertex Vrchol, z ktoreho sa prehladavanie do hlbky spusta.
     */
    private void search(int vertex) {
        visited.set(vertex, true);
        for (int successor : g.outgoingEdgesDestinations(vertex)) {
            if (visited.get(successor) && !finished.get(successor)) {
                acyclic = false;
            }
            if (!visited.get(successor)) {
                search(successor);
            }
        }
        finished.set(vertex, true);
        topologicalOrder.addFirst(vertex);
    }

    /**
     * Metoda, ktora vrati najdene topologicke usporiadanie grafu.
     * @return Topologicke usporiadanie grafu ako nemodifikovatelny zoznam vrcholov. V pripade, ze graf nie je
     *         acyklicky, vrati sa na vystupe referencia null.
     */
    public List<Integer> getTopologicalOrder() {
        if (acyclic) {
            return Collections.unmodifiableList(topologicalOrder);
        } else {
            return null;
        }
    }

    /**
     * Metoda, ktora vrati informaciu o tom, ci je graf g acyklicky.
     * @return Vrati booleovsku hodnotu true prave vtedy, ked je graf g acyklicky.
     */
    public boolean isAcyclic() {
        return acyclic;
    }
}
</syntaxhighlight>

== Úlohy na ohodnotených grafoch ==

Po zvyšok tejto prednášky sa budeme zaoberať ''ohodnotenými grafmi'' nad množinou reálnych čísel. Ide o rozšírenie grafov, pri ktorom má každá hrana priradené nejaké reálne ohodnotenie. Pre ohodnotené grafy napíšeme rozhranie <tt>WeightedGraph</tt> a triedu <tt>WeightedSuccessorListsGraph</tt> reprezentujúcu ''orientované'' ohodnotené grafy pomocou zoznamov následníkov (podobným spôsobom ako na minulých prednáškach by sme však mohli napísať aj triedy ako <tt>WeightedAdjacencyMatrixGraph</tt>, <tt>WeightedAdjacencyListsUndirectedGraph</tt> a podobne).

=== Rozhranie pre ohodnotené grafy (<tt>WeightedGraph</tt>) ===

<syntaxhighlight lang="java">
package graphs;

/**
 * Trieda reprezentujuca ohodnotenu hranu.
 */
public class WeightedEdge extends Edge {
    private double weight;

    public WeightedEdge(int from, int to, double weight) {
        super(from, to);
        this.weight = weight;
    }

    public double getWeight() {
        return weight;
    }

    @Override
    public boolean equals(Object o) {
        return super.equals(o) && ((WeightedEdge) o).weight == weight;
    }

    @Override
    public int hashCode() {
        return Double.valueOf(weight).hashCode() + 31 * super.hashCode();
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

public class WeightedEdges {

    public static Collection<Edge> unweightedEdgeCollection(Collection<WeightedEdge> weightedEdges) {
        ArrayList<Edge> result = new ArrayList<>();
        for (WeightedEdge we : weightedEdges) {
            result.add(new Edge(we.getFrom(), we.getTo()));
        }
        return result;
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package graphs;

/**
 * Rozhranie pre ohodnoteny (vo vseobecnosti orientovany) graf.
 */
public interface WeightedGraph extends Graph {
    /**
     * Metoda, ktora vrati vsetky ohodnotene hrany vychadzajuce z vrcholu vertex reprezentovaneho ohodnoteneho grafu.
     * @param vertex Vrchol ohodnoteneho grafu.
     * @return       Ohodnotene hrany vychadzajuce z vrcholu vertex ako instancia typu Iterable&lt;WeightedEdge&rt;.
     */
    Iterable<WeightedEdge> outgoingWeightedEdges(int vertex);
}
</syntaxhighlight>

=== Orientované ohodnotené grafy pomocou zoznamov následníkov (<tt>WeightedSuccessorListsGraph</tt>) ===

Triedu <tt>WeightedSuccessorListsGraph</tt> reprezentujúcu ohodnotený orientovaný graf pomocou zoznamov následníkov napíšeme jednoduchým rozšírením príslušnej triedy <tt>SuccessorListsGraph</tt> pre neohodnotené grafy. Navyše si len pre každý vrchol budeme pamätať zoznam z neho vychádzajúcich ohodnotených hrán.

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda reprezentujuca ohodnoteny orientovany graf pomocou zoznamov naslednikov.
 */
public class WeightedSuccessorListsGraph extends SuccessorListsGraph implements WeightedGraph {
    /**
     * Zoznamy ohodnotenych hran vychadzajucich z jednotlivych vrcholov.
     */
    private ArrayList<ArrayList<WeightedEdge>> outgoingWeightedEdges;

    /**
     * Konstruktor, ktory vytvori ohodnoteny graf s danym poctom vrcholov a obsahujuci hrany podla daneho zoskupenia.
     * @param vertexCount   Pocet vrcholov vytvaraneho grafu.
     * @param weightedEdges Ohodnotene hrany vytvaraneho grafu. Zoskupenie nesmie obsahovat viacero hran s roznymi
     *                      ohodnoteniami veduce medzi rovnakymi dvojicami vrcholov.
     */
    public WeightedSuccessorListsGraph(int vertexCount, Collection<WeightedEdge> weightedEdges) {
        super(vertexCount, WeightedEdges.unweightedEdgeCollection(weightedEdges));
        outgoingWeightedEdges = new ArrayList<>();
        for (int i = 0; i <= vertexCount - 1; i++) {
            outgoingWeightedEdges.add(new ArrayList<>());
        }
        Set<WeightedEdge> processedWeightedEdges = new HashSet<>();
        Set<Edge> processedUnweightedEdges = new HashSet<>();
        for (WeightedEdge we : weightedEdges) {
            if (!processedUnweightedEdges.contains(new Edge(we.getFrom(), we.getTo()))) {
                outgoingWeightedEdges.get(we.getFrom()).add(we);
                processedWeightedEdges.add(we);
                processedUnweightedEdges.add(new Edge(we.getFrom(), we.getTo()));
            } else if (!processedWeightedEdges.contains(we)) {
                throw new IllegalArgumentException("Multiple edges with different weights connecting the same" +
                        " pair of vertices.");
            }
        }
    }

    @Override
    public Iterable<WeightedEdge> outgoingWeightedEdges(int vertex) {
        return Collections.unmodifiableList(outgoingWeightedEdges.get(vertex));
    }
}
</syntaxhighlight>

=== Hľadanie najdlhšej cesty v ohodnotenom grafe ===

Pod ''dĺžkou cesty'' v ohodnotenom grafe teraz budeme rozumieť súčet ohodnotení jej hrán. Podobne ako pre neohodnotené grafy potom možno najdlhšiu cestu medzi dvoma vrcholmi nájsť pomocou prehľadávania s návratom. 

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

/**
 * Trieda realizujuca najdenie najdlhsej ohodnotenej cesty v ohodnotenom grafe z daneho pociatocneho do daneho koncoveho
 * vrcholu.
 */
public class LongestWeightedPath {
    /**
     * Ohodnoteny graf, v ktorom sa hladanie najdlhsej cesty realizuje.
     */
    private WeightedGraph g;

    /**
     * Pociatocny vrchol hladanej najdlhsej cesty.
     */
    private int from;

    /**
     * Koncovy vrchol hladanej najdlhsej cesty.
     */
    private int to;

    /**
     * Dlzka vygenerovanej casti cesty.
     */
    private double length;

    /**
     * Dlzka doposial najdlhsej najdenej cesty z vrcholu from do vrcholu to.
     */
    private double maxLength;

    /**
     * Zoznam, v ktorom sa postupne budu cesty generovat.
     */
    private LinkedList<Integer> path;

    /**
     * Doposial najdlhsia najdena cesta z vrcholu from do vrcholu to.
     */
    private LinkedList<Integer> longestWeightedPath;

    /**
     * Informacie o navstiveni jednotlivych vrcholov pri prehladavani s navratom.
     */
    private ArrayList<Boolean> visited;

    /**
     * Konstruktor, ktory najde najdlhsiu ohodnotenu cestu medzi danymi dvoma vrcholmi daneho ohodnoteneho grafu.
     * @param g    Graf, v ktorom sa hladanie ciest realizuje.
     * @param from Pociatocny vrchol.
     * @param to   Koncovy vrchol.
     */
    public LongestWeightedPath(WeightedGraph g, int from, int to) {
        this.g = g;
        this.from = from;
        this.to = to;

        visited = new ArrayList<>();
        for (int i = 0; i <= g.getNumberOfVertices() - 1; i++) {
            visited.add(false);
        }

        maxLength = Integer.MIN_VALUE;
        length = 0;
        path = new LinkedList<>();
        path.add(from);
        visited.set(from, true);
        search();
    }

    /**
     * Metoda realizujuca samotne prehladavanie s navratom.
     */
    private void search() {
        if (path.getLast() == to) {
            if (length > maxLength) {
                maxLength = length;
                longestWeightedPath = new LinkedList<>(path);
            }
        } else {
            for (WeightedEdge we : g.outgoingWeightedEdges(path.getLast())) {
                int successor = we.getTo();
                double weight = we.getWeight();
                if (!visited.get(successor)) {
                    visited.set(successor, true);
                    path.addLast(successor);
                    length += weight;
                    search();
                    length -= weight;
                    path.removeLast();
                    visited.set(successor, false);
                }
            }
        }
    }

    /**
     * Metoda, ktora vrati najdenu najdlhsiu ohodnotenu cestu.
     * @return Jedna z najdlhsich ohodnotenych ciest z from do to ako nemodifikovatelny zoznam. V pripade, ze ziadna
     *         cesta medzi vrcholmi from a to neexistuje, vrati sa na vystupe referencia null.
     */
    public List<Integer> getLongestWeightedPath() {
        if (longestWeightedPath != null) {
            return Collections.unmodifiableList(longestWeightedPath);
        } else {
            return null;
        }
    }
}
</syntaxhighlight>

Použitie tejto triedy:
<syntaxhighlight lang="java">
public class Trieda {

    public static WeightedGraph readWeightedGraph(Scanner s) {
        int n = s.nextInt();
        int m = s.nextInt();
        ArrayList<WeightedEdge> weightedEdges = new ArrayList<>();
        for (int i = 1; i <= m; i++) {
            int u = s.nextInt();
            int v = s.nextInt();
            double weight = s.nextDouble();
            weightedEdges.add(new WeightedEdge(u, v, weight));
        }
        return new WeightedSuccessorListsGraph(n, weightedEdges);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Zadaj ohodnoteny graf:");
        WeightedGraph g = readWeightedGraph(scanner);
        System.out.println("Zadaj pociatocny a koncovy vrchol:");
        int from = scanner.nextInt();
        int to = scanner.nextInt();

        LongestWeightedPath longestWeightedPath = new LongestWeightedPath(g, from, to);
        List<Integer> longest = longestWeightedPath.getLongestWeightedPath();
        if (longest != null) {
            System.out.println("Najdlhsia cesta: " + longest);
        } else {
            System.out.println("Ziadna cesta neexistuje.");
        }
    }
}
</syntaxhighlight>

=== Najkratšie cesty v ohodnotených grafoch ===

Poznamenajme, že ''najkratšia'' cesta v ohodnotenom grafe sa vo všeobecnosti ''nedá'' nájsť prehľadávaním do šírky:
* Ak sú ohodnoteniami prirodzené čísla, možno hranu ohodnotenú číslom ''k'' reprezentovať postupnosťou ''k'' nadväzujúcich hrán a aplikovať algoritmus pre neohodnotené grafy. Pokiaľ však nemáme zaručené, že sú ohodnotenia hrán malé, ide o extrémne neefektívny prístup.
* Najkratšiu cestu samozrejme možno hľadať aj prehľadávaním s návratom, podobne ako cestu najdlhšiu. To je však tiež veľmi neefektívne (pri najdlhšej ceste to až tak nevadí, keďže efektívny algoritmus s najväčšou pravdepodobnosťou neexistuje). 
* &bdquo;Rozumné&rdquo; algoritmy na hľadanie najkratšej cesty v ohodnotenom grafe sa preberajú napríklad v rámci predmetu [https://sluzby.fmph.uniba.sk/infolist/sk/1-INF-310.html Tvorba efektívnych algoritmov]. Tieto predpokladajú neexistenciu cyklov zápornej dĺžky (čo je v praxi zmysluplný predpoklad), a teda v skutočnosti hľadajú najkratšie sledy. V prípade možnej existencie cyklov zápornej dĺžky efektívny algoritmus, rovnako ako pri najdlhšej ceste, s najväčšou pravdepodobnosťou neexistuje.

== Zhrnutie prebratých grafových algoritmov ==

Väčšina grafových algoritmov (s výnimkou prvého algoritmu pre topologické triedenie), s ktorými sme sa v rámci posledných niekoľkých prednášok stretli, bola založená na niektorej z nasledujúcich troch techník:
* ''Prehľadávanie do hĺbky'' (angl. ''depth-first search'').
* ''Prehľadávanie do šírky'' (angl. ''breadth-first search'').
* ''Prehľadávanie s návratom'' (angl. ''backtracking'').

Prvé dve z týchto techník sú pomerne efektívne &ndash; je pri nich zaručené, že žiadna hrana nebude pri &bdquo;objavovaní&rdquo; nových vrcholov použitá viac, než raz. To znamená, že časová zložitosť týchto algoritmov je rádovo ''O(n + m)'', kde ''n'' je počet vrcholov a ''m'' je počet hrán grafu.

Prehľadávanie s návratom je naopak extrémne neefektívna technika prehľadávajúca všetky možnosti, ktorých vo všeobecnosti môže byť veľmi veľa. Dá sa teda aplikovať iba na malé vstupy, a to najmä vtedy, keď efektívny algoritmus pre danú úlohu neexistuje alebo nie je známy.
=Riešenia testu č. 4=
== Úloha č. 1 ==

<syntaxhighlight lang="java">
public class LongestCycle {
    
    // ...

    private LinkedList<Integer> walk;
    private ArrayList<Boolean> visited;

    public LongestCycle(Graph g, int vertex) {
        this.g = g;
        this.vertex = vertex;

        walk = new LinkedList<>();
        visited = new ArrayList<>();
        for (int i = 0; i <= g.getNumberOfVertices() - 1; i++) {
            visited.add(false);
        }
        walk.add(vertex);
        search();
    }

    private void search() {
        if (walk.size() > 1 && walk.getLast() == vertex) {
            if (longestCycle == null || walk.size() > longestCycle.size()) {
                longestCycle = new LinkedList<>(walk);
            }
        } else {
            for (int successor : g.outgoingEdgesDestinations(walk.getLast())) {
                if (!visited.get(successor)) {
                    visited.set(successor, true);
                    walk.add(successor);
                    search();
                    walk.removeLast();
                    visited.set(successor, false);
                }
            }
        }
    }

    // ...
}
</syntaxhighlight>

== Úloha č. 2 ==

<syntaxhighlight lang="java">
public class DepthFirstSearch {

    public static Map<Integer, Integer> depthFirstSearch(Graph g, int vertex) {
        Map<Integer, Integer> result = new HashMap<>();
        search(g, vertex, result);
        return result;
    }

    private static void search(Graph g, int vertex, Map<Integer, Integer> orderOfDiscovery) {
        orderOfDiscovery.put(vertex, orderOfDiscovery.size() + 1);
        for (int successor : g.outgoingEdgesDestinations(vertex)) {
            if (!orderOfDiscovery.containsKey(successor)) {
                search(g, successor, orderOfDiscovery);
            }
        }
    }

    // ...
}
</syntaxhighlight>

== Úloha č. 3 ==

<syntaxhighlight lang="java">
// ...

else {
    for (int colour = 0; colour <= colours - 1; colour++) {
        boolean isAdmissible = true;
        for (int neighbour : g.outgoingEdgesDestinations(vertex)) {
            if (neighbour == vertex || (neighbour < vertex && colouring.get(neighbour) == colour)) {
                isAdmissible = false;
            }
        }
        if (isAdmissible) {
            colouring.set(vertex, colour);
            search(vertex + 1);
        }
    }
}
</syntaxhighlight>
=Letný semester, prednáška č. 10=
== Oznamy ==

* Stredajšie cvičenia ''budú'' aj napriek dekanskému voľnu (účasť je samozrejme dobrovoľná, rovnako ako aj na ostatných cvičeniach, na ktorých sa nepíše test). Bude zverejnených niekoľko nebodovaných úloh zameraných na látku z dnešnej prednášky (úlohy na JavaFX sa nebudú odovzdávať na testovač).
* Štvrtú domácu úlohu treba odovzdať ''do pondelka 26. apríla, 9:00'' a tretiu bonusovú úlohu ''do stredy 28. apríla, 11:30''.
* Najneskôr na budúcej prednáške, prosím, dajte vedieť o prípadných námietkach proti vypísaným termínom skúšky.

== Lambda výrazy ==

=== Príklad: komparátor ako lambda výraz ===

Pripomeňme si z [[#Letný semester, prednáška č. 5|piatej prednášky]] ''zostupné'' triedenie zoznamu celých čísel pomocou metódy [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Collections.html#sort(java.util.List,java.util.Comparator) <tt>Collections.sort</tt>], ktorá ako druhý parameter berie ''komparátor'', čiže inštanciu nejakej triedy implementujúcej rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Comparator.html <tt>Comparator<? super Integer></tt>]. Videli sme pritom tri možné spôsoby, ako komparátor definovať:
* Vytvoriť &bdquo;bežnú&rdquo; triedu implementujúcu rozhranie <tt>Comparator<Integer></tt> a metódu <tt>sort</tt> zavolať pre novovytvorenú inštanciu tejto triedy.
* To isté s použitím ''lokálnej triedy'':
:<syntaxhighlight lang="java">
import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        class DualComparator implements Comparator<Integer> {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        }
        List<Integer> a = new ArrayList<>();
        a.add(6);
        a.add(1);
        a.add(3);
        a.add(2);
        a.add(3);
        Collections.sort(a, new DualComparator());
        System.out.println(a);
    }
}
</syntaxhighlight>
* Definíciu triedy a vytvorenie jej inštancie spojiť do jediného príkazu s využitím mechanizmu ''anonymných tried'':
:<syntaxhighlight lang="java">
import java.util.*;

public class Trieda {

    public static void main(String[] args) {
        List<Integer> a = new ArrayList<>();
        a.add(6);
        a.add(1);
        a.add(3);
        a.add(2);
        a.add(3);
        Collections.sort(a, new Comparator<>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println(a);
    }
}
</syntaxhighlight>

Aj posledný z uvedených spôsobov definície komparátora je však stále trochu ťažkopádny &ndash; jediná pre účely triedenia podstatná informácia je tu daná riadkom <tt>return o2.compareTo(o1);</tt>, pričom zvyšok konštrukcie by bol rovnaký aj pri definícii ľubovoľného iného komparátora.

Rozhranie <tt>Comparator<E></tt> je príkladom takzvaného ''funkcionálneho rozhrania'' &ndash; čiže rozhrania, ktoré deklaruje ''jedinú abstraktnú metódu''; v tomto prípade ide o metódu [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/Comparator.html#compare(T,T) <tt>compare</tt>]. Toto rozhranie síce definuje niekoľko ďalších statických metód a metód s modifikátorom <tt>default</tt>; jedinou metódou, ktorú je potrebné implementovať kedykoľvek implementujeme rozhranie <tt>Comparator<E></tt>, je ale metóda <tt>compare</tt>. To okrem iného znamená, že proces vytvárania tried implementujúcich rozhranie <tt>Comparator<E></tt> sa často môže redukovať iba na implementáciu tejto jednej metódy.

Ako skrátený zápis pre definíciu inštancie anonymnej triedy ''implementujúcej funkcionálne rozhranie'', obsahujúcej iba definíciu jedinej abstraktnej metódy deklarovanej v tomto rozhraní, slúžia v Jave takzvané ''lambda výrazy''. Utriedenie poľa tak možno realizovať pomocou príkazu
<syntaxhighlight lang="java">
Collections.sort(a, (o1, o2) -> {return o2.compareTo(o1);});
</syntaxhighlight>
alebo pomocou ešte kratšieho príkazu
<syntaxhighlight lang="java">
Collections.sort(a, (o1, o2) -> o2.compareTo(o1));
</syntaxhighlight>
V zátvorkách pred šípkou sú postupne uvedené identifikátory argumentov metódy <tt>compare</tt> a za šípkou nasleduje blok obsahujúci telo metódy <tt>compare</tt>, prípadne výraz udávajúci výstupnú hodnotu tejto metódy.

=== Syntax lambda výrazov v Jave ===

''Lambda výraz'' je teda skráteným zápisom anonymnej triedy implementujúcej funkcionálne rozhranie, ako aj jej inštancie. Alternatívne ich možno považovať aj za reprezentáciu implementácie abstraktnej metódy v tomto rozhraní deklarovanej; preto sa v súvislosti s lambda výrazmi často hovorí aj o ''anonymných funkciách''.
Pomenovanie &bdquo;lambda výraz&rdquo; odkazuje na ''lambda kalkul'' &ndash; formalizmus, v ktorom sa podobným spôsobom definujú matematické funkcie (napríklad ''&lambda;x.x<sup>2</sup> + 5'' je funkcia ''f'' daná predpisom ''f: x &#8614; x<sup>2</sup> + 5'') a ktorý je okrem iného aj teoretickým základom funkcionálneho programovania.

V prípade, že má jediná abstraktná metóda deklarovaná v implementovanom funkcionálnom rozhraní hlavičku
<syntaxhighlight lang="java">
T f(T1 arg1, T2 arg2, ..., Tn argn);
</syntaxhighlight>
môže byť lambda výraz reprezentujúci inštanciu anonymnej triedy implementujúcej toto rozhranie tvaru
<syntaxhighlight lang="java">
(arg1, arg2, ..., argn) -> { /* Telo implementacie metody f */ }
</syntaxhighlight>
Pred jednotlivé argumenty možno nepovinne uvádzať aj ich typy. V prípade, že je počet argumentov metódy <tt>f</tt> nulový, píšeme
<syntaxhighlight lang="java">
() -> { /* Telo implementacie metody f */ }
</syntaxhighlight>
a v prípade, že ide o metódu s jediným argumentom <tt>arg</tt>, možno vynechať zátvorky okolo argumentov a písať iba
<syntaxhighlight lang="java">
arg -> { /* Telo implementacie metody f */ }
</syntaxhighlight>

V prípade, že návratový typ <tt>T</tt> metódy <tt>f</tt> nie je <tt>void</tt>, možno na pravej strane lambda výrazu namiesto bloku obsahujúceho telo implementovanej metódy uviesť iba výraz, ktorý sa vyhodnotí na typ <tt>T</tt>; v takom prípade bude metóda <tt>f</tt> počítať tento výraz. V prípade, že návratovým typom metódy <tt>f</tt> je <tt>void</tt>, možno namiesto bloku s telom implementovanej metódy uviesť volanie jednej metódy s návratovým typom <tt>void</tt> (ktoré možno z určitého pohľadu chápať ako &bdquo;výraz typu <tt>void</tt>&rdquo;), prípadne volanie jednej metódy s iným návratovým typom, pričom sa však návratová hodnota tejto metódy odignoruje.

Anotácia <tt>@FunctionalInterface</tt> používaná v nasledujúcich príkladoch je nepovinná (všetko by rovnako dobre fungovalo aj bez nej), ale odporúčaná &ndash; kompilátor totiž vyhodí chybu kedykoľvek je táto anotácia použitá inde ako pri funkcionálnom rozhraní.

''Príklad 1'':
<syntaxhighlight lang="java">
@FunctionalInterface
public interface MyFunctionalInterface {
    int f(int a, int b);
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Trieda {

    public static void main(String[] args) {
        MyFunctionalInterface instance1 = (a, b) -> {
            if (a < b) {
                return 0;
            }
            return a + b;
        };
        MyFunctionalInterface instance2 = (a, b) -> a * b;

        System.out.println(instance1.f(2, 3));
        System.out.println(instance2.f(2, 3));
    }
}
</syntaxhighlight>

''Príklad 2'':
<syntaxhighlight lang="java">
@FunctionalInterface
public interface MyFunctionalInterface {
    int f(int a);
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Trieda {

    public static void main(String[] args) {
        MyFunctionalInterface instance1 = (a) -> {return a + 1;};
        MyFunctionalInterface instance2 = a -> {return a - 1;};
        MyFunctionalInterface instance3 = x -> x + 3;

        System.out.println(instance1.f(2));
        System.out.println(instance2.f(2));
        System.out.println(instance3.f(2));
    }
}
</syntaxhighlight>

''Príklad 3'':
<syntaxhighlight lang="java">
@FunctionalInterface
public interface MyFunctionalInterface {
    void f();
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class Trieda {

    public static void main(String[] args) {
        MyFunctionalInterface instance1 = () -> {System.out.println("Hello, lambda!");};
        MyFunctionalInterface instance2 = () -> System.out.println("Hello, lambda!");

        instance1.f();
        instance2.f();
    }
}
</syntaxhighlight>

Rovnako ako z lokálnych a anonymných tried, možno aj z definícií lambda výrazov pristupovať k premenným inštancií, či k finálnym alebo &bdquo;v podstate finálnym&rdquo; lokálnym premenným metód, ktorých sú súčasťou.

=== Ďalší príklad použitia lambda výrazov ===

Rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/Iterable.html <tt>Iterable<T></tt>] deklaruje okrem iného aj metódu [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/Iterable.html#forEach(java.util.function.Consumer) <tt>forEach</tt>], ktorá postupne pre všetky prvky vracané iterátorom vykoná danú akciu a predstavuje tak alternatívu k použitiu cyklu <tt>for each</tt>. Akcia, ktorá sa má pre všetky prvky vykonať, je daná inštanciou nejakej triedy implementujúcej funkcionálne rozhranie [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/function/Consumer.html <tt>Consumer<T></tt>] z balíka <tt>java.util.function</tt>. V ňom je deklarovaná jediná abstraktná metóda [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/function/Consumer.html#accept(T) <tt>accept</tt>] s návratovým typom <tt>void</tt> a jediným argumentom typu <tt>T</tt>. Metóda <tt>forEach</tt> zavolá túto metódu <tt>accept</tt> postupne pre všetky prvky vracané iterátorom.

''Príklad'':
Uvažujme napríklad nasledujúci kód postupne vypisujúci všetky prvky zoznamu <tt>a</tt>.
<syntaxhighlight lang="java">
List<Integer> a = new ArrayList<>();

// ...

for (int x : a) {
    System.out.print(x + " ");
}
</syntaxhighlight>
Pomocou metódy <tt>forEach</tt> a anonymnej triedy môžeme rovnaké vypísanie prvkov zoznamu napísať aj nasledovne.
<syntaxhighlight lang="java">
List<Integer> a = new ArrayList<>();
    
// ...

a.forEach(new Consumer<>() {
    @Override
    public void accept(Integer x) {
        System.out.print(x + " ");
    }
});
</syntaxhighlight>
Keďže je rozhranie <tt>Consumer</tt> funkcionálne, môžeme namiesto anonymnej triedy použiť lambda výraz.
<syntaxhighlight lang="java">
List<Integer> a = new ArrayList<>();

// ...

a.forEach(x -> System.out.print(x + " "));
</syntaxhighlight>

Viacero ďalších funkcionálnych rozhraní, ktorých inštancie možno definovať pomocou lambda výrazov, je definovaných v balíku [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/function/package-summary.html <tt>java.util.function</tt>].

=== Referencie na metódy ===

Občas sa stáva, že lambda výraz pozostáva iba z priameho volania nejakej už pomenovanej metódy. Pre takéto lambda výrazy existuje v Jave špeciálna syntax umožňujúca vyjadriť toto správanie o niečo stručnejším spôsobom. Lambda výrazy zadané pomocou tejto syntaxe sa nazývajú aj ''referenciami na metódy''.

Pre triedu <tt>Trieda</tt> poskytujúcu statickú metódu <tt>statickaMetoda(T1 arg1, ..., Tn argn)</tt> a nestatickú metódu <tt>nestatickaMetoda(U1 arg1, ..., Um argm)</tt> a pre inštanciu <tt>instancia</tt> triedy <tt>Trieda</tt> možno písať:
* <tt>Trieda::statickaMetoda</tt> namiesto lambda výrazu <tt>(arg1, ..., argn) -> Trieda.statickaMetoda(arg1, ..., argn)</tt>,
* <tt>instancia::nestatickaMetoda</tt> namiesto lambda výrazu <tt>(arg1, ..., argm) -> instancia.nestatickaMetoda(arg1, ..., argm)</tt>,
* <tt>Trieda::nestatickaMetoda</tt> namiesto lambda výrazu <tt>(arg, arg1, ..., argm) -> arg.nestatickaMetoda(arg1, ..., argm)</tt>, kde <tt>arg</tt> je inštancia typu <tt>Trieda</tt>.

''Príklad'': Keby sme v príklade uvedenom vyššie prvky <tt>x</tt> zoznamu <tt>a</tt> vypisovali namiesto metódy <tt>System.out.print(x + " ")</tt> metódou <tt>System.out.println(x)</tt>, mohli by sme celé vypisovanie zoznamu prepísať aj nasledovne.
<syntaxhighlight lang="java">
List<Integer> a = new ArrayList<>();

// ...

a.forEach(System.out::println);
</syntaxhighlight>

== Úvod do JavaFX ==

''JavaFX'' je platforma, ktorú možno využiť na tvorbu aplikácií s grafickým používateľským rozhraním (GUI). Namiesto konzolových aplikácií teda budeme v nasledujúcich niekoľkých prednáškach vytvárať aplikácie grafické (typicky pozostávajúce z jedného alebo niekoľkých okien s ovládacími prvkami, akými sú napríklad tlačidlá, textové polia, a podobne).

* Pokyny k inštalácii JavaFX, ako aj návod na skompilovanie a spustenie prvého programu z IntelliJ IDEA a z príkazového riadku možno nájsť [[#Letný semester, softvér|tu]]. 
* [https://openjfx.io/javadoc/15/ Dokumentácia k JavaFX 15 API].
* Ďalšie dokumentácie a tutoriály možno nájsť na [https://openjfx.io/ stránke projektu]. 

=== Vytvorenie aplikácie s jedným grafickým oknom ===

Minimalistickú JavaFX aplikáciu zobrazujúcu jedno prázdne okno o 300 krát 250 pixeloch s titulkom &bdquo;''Hello, World!''&rdquo; vytvoríme nasledovne:
<syntaxhighlight lang="java">
import javafx.application.*;
import javafx.stage.*;
import javafx.scene.*;
import javafx.scene.layout.*;

public class HelloFX extends Application {
    @Override
    public void start(Stage primaryStage) {
        Pane pane = new Pane();
        Scene scene = new Scene(pane, 300, 250);
        
        primaryStage.setTitle("Hello, World!");
        primaryStage.setScene(scene);
        primaryStage.show();
    }
    
    public static void main(String[] args) {
        launch(args);
    }
}
</syntaxhighlight>

[[Image:Okno1.png|thumb|Okno zobrazené po spustení aplikácie.|300px]]

Uvedený kód si teraz rozoberme:
* Hlavná trieda JavaFX aplikácie (tzn. trieda obsahujúca metódu <tt>main</tt>) sa vyznačuje tým, že dedí od abstraktnej triedy <tt>[https://openjfx.io/javadoc/15/javafx.graphics/javafx/application/Application.html Application]</tt> definovanej v balíku <tt>javafx.application</tt>, ktorý je potrebné importovať.
* Každá trieda dediaca od triedy <tt>Application</tt> musí implementovať jej abstraktnú metódu <tt>start</tt>, ktorej argumentom je objekt <tt>primaryStage</tt> typu <tt>[https://openjfx.io/javadoc/15/javafx.graphics/javafx/stage/Stage.html Stage]</tt> reprezentujúci hlavné grafické okno aplikácie (trieda <tt>Stage</tt> je definovaná v balíku <tt>javafx.stage</tt>, ktorý je potrebné importovať). Metóda <tt>start</tt> sa vykoná hneď po spustení aplikácie. V rámci metódy <tt>start</tt> sa typicky vytvárajú jednotlivé ovládacie prvky aplikácie a špecifikujú sa ich vlastnosti. 
** V našom prípade je kľúčovým riadkom metódy <tt>start</tt> volanie <tt>primaryStage.show()</tt>, ktorým zobrazíme hlavné okno aplikácie. Bez tohto volania by aplikácia bežala &bdquo;na pozadí&rdquo;.  
** Volaním <tt>primaryStage.setTitle("Hello, World!")</tt> nastavíme titulok hlavného okna na text &bdquo;''Hello, World!''&rdquo;.  
** Uvedené dva riadky často stačia na zobrazenie grafického okna s titulkom &bdquo;''Hello, World!''&rdquo; a &bdquo;náhodne&rdquo; zvolenou veľkosťou. V závislosti od systému sa však môže stať aj to, že sa nezobrazí nič &ndash; grafické okno totiž zatiaľ nič neobsahuje a systém nemá ako &bdquo;rozumne&rdquo; vypočítať jeho veľkosť; môže teda túto situáciu vyhodnotiť aj tak, že ešte nie je čo zobraziť.
** Zvyšnými riadkami už len hovoríme, že &bdquo;obsahom&rdquo; hlavného okna má byť prázdna oblasť o veľkosti 300 krát 250 pixelov:
*** Kontajnerom pre obsah okna je inštancia triedy <tt>[https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/Scene.html Scene]</tt>. Ide tu o analógiu s divadelnou terminológiou: okno zodpovedá javisku; na javisku následne možno umiestniť scénu pozostávajúcu z jednotlivých rekvizít. Scénu <tt>scene</tt> možno oknu <tt>primaryStage</tt> priradiť volaním <tt>primaryStage.setScene(scene)</tt>. Trieda <tt>Scene</tt> je definovaná v balíku <tt>javafx.scene</tt>, ktorý je potrebné importovať.
*** Scéna je daná predovšetkým hierarchickým stromom uzlov (detaily neskôr), pričom uzlami môžu byť napríklad oblasti, ale aj ovládacie prvky ako napríklad tlačidlá, či textové polia. Volaním konštruktora <tt>Scene scene = Scene(pane, 300, 250)</tt> vytvoríme scénu o rozmeroch 300 krát 250 pixelov, ktorej koreňovým uzlom je objekt <tt>pane</tt>; ten bude v našom prípade reprezentovať prázdnu oblasť.
*** Volaním konštruktora <tt>Pane pane = new Pane()</tt> vytvoríme novú oblasť <tt>pane</tt>. Tá môže neskôr slúžiť ako kontajner pre pridávanie rôznych ovládacích prvkov a podobne. Trieda <tt>[https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/layout/Pane.html Pane]</tt> je definovaná v balíku <tt>javafx.scene.layout</tt>, ktorý je potrebné importovať.
* Metóda <tt>main</tt> JavaFX aplikácie typicky pozostáva z jediného riadku, v ktorom sa volá statická metóda <tt>launch</tt> triedy <tt>Application</tt>. Tá sa postará o vytvorenie inštancie našej triedy <tt>HelloFX</tt>, o vytvorenie hlavného grafického okna aplikácie, ako aj o následné zavolanie metódy <tt>start</tt>, ktorá dostane vytvorené okno ako argument.

=== Okno s niekoľkými jednoduchými ovládacími prvkami ===

Podbne ako v príklade vyššie vytvorme aplikáciu pozostávajúcu s jediného grafického okna.

<syntaxhighlight lang="java">
import javafx.application.*;
import javafx.stage.*;
import javafx.scene.*;
import javafx.scene.layout.*;

public class Aplikacia extends Application {
    @Override
    public void start(Stage primaryStage) {
        Pane pane = new Pane();
                                
        Scene scene = new Scene(pane, 340, 100);
        
        primaryStage.setTitle("Zadávanie textu");
        primaryStage.setScene(scene);
        primaryStage.show();
    }
    
    public static void main(String[] args) {
        launch(args);
    }
}
</syntaxhighlight>

[[Image:Okno2.png|thumb|Hlavné okno výslednej aplikácie.|300px]]

Pridáme teraz do hlavného okna niekoľko ovládacích prvkov tak, ako na obrázku vpravo. Naším cieľom bude vytvorenie aplikácie umožňujúcej zadať text, ktorý sa pri kliknutí na tlačidlo <tt>OK</tt> zjaví v textovom popisku červenej farby. Ovládacie prvky ako textové pole alebo tlačidlo sú definované v balíku <tt>javafx.scene.control</tt>, ktorý je tak nutné importovať. Podobne na prácu s fontmi budeme potrebovať balík <tt>javafx.scene.text</tt> a na prácu s farbami balík <tt>javafx.scene.paint</tt>.

Začnime s pridaním textového popisku &bdquo;Zadaj text&rdquo;. Takéto textové popisky sú v JavaFX reprezentované triedou <tt>[https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/Label.html Label]</tt>, pričom popisok <tt>label1</tt> obsahujúci nami požadovaný text vytvoríme nasledovne:
<syntaxhighlight lang="java">
import javafx.scene.control.*;

// ...

Label label1 = new Label("Zadaj text:");
</syntaxhighlight> 
Rovnako dobre by sme mohli použiť aj konštruktor bez argumentov, ktorý je ekvivalentný volaniu konštruktora s argumentom <tt>""</tt> &ndash; text popisku <tt>label1</tt> možno upraviť aj neskôr volaním <tt>label1.setText("Nový text")</tt>.

Po jeho vytvorení ešte musíme popisok <tt>label1</tt> pridať do našej scény &ndash; presnejšie do oblasti <tt>pane</tt>, ktorá je jej koreňovým uzlom (čo znamená, že všetky ostatné uzly budú umiestnené v tejto oblasti). Vytvorený popisok <tt>label1</tt> teda ''pridáme do zoznamu synov'' oblasti <tt>pane</tt> nasledujúcim volaním:
<syntaxhighlight lang="java">
pane.getChildren().add(label1);
</syntaxhighlight>
Následne môžeme upraviť niektoré vlastnosti vytvoreného popisku, ako napríklad jeho pozíciu a font:
<syntaxhighlight lang="java">
import javafx.scene.text.*; // Kvoli triede Font.

// ...

label1.setFont(Font.font("Tahoma", FontWeight.BOLD, 12));
label1.setLayoutX(20);
label1.setLayoutY(10);
</syntaxhighlight>  

Analogicky vytvoríme aj ostatné komponenty:
<syntaxhighlight lang="java">
import javafx.scene.paint.*; // Kvoli triede Color.

// ...

TextField textField = new TextField();
pane.getChildren().add(textField);
textField.setFont(Font.font("Tahoma", FontWeight.BOLD, 12));
textField.setLayoutX(20);
textField.setLayoutY(30);
textField.setPrefWidth(300);
        
Label label2 = new Label("(Zatiaľ nebolo zadané nič)");
pane.getChildren().add(label2);
label2.setFont(Font.font("Tahoma", 12));
label2.setTextFill(Color.RED);
label2.setLayoutX(20);
label2.setLayoutY(70);
        
Button button = new Button("OK");
pane.getChildren().add(button);
button.setFont(Font.font("Tahoma", FontWeight.BOLD, 12));
button.setLayoutX(280);
button.setLayoutY(60);
button.setPrefWidth(40);
button.setPrefHeight(30);
</syntaxhighlight>

Uvedený spôsob grafického návrhu scény má však hneď dva zásadné nedostatky:
* Môžeme si všimnúť, že takéto pevné rozloženie ovládacích prvkov na scéne nevyzerá dobre, keď zmeníme veľkosť okna. Provizórne môžeme tento problém vyriešiť tým, že menenie rozmerov okna jednoducho zakážeme: <tt>primaryStage.setResizable(false)</tt>. Takéto riešenie má však ďaleko od ideálneho. Odporúčaným prístupom je využiť namiesto triedy <tt>Pane</tt> niektorú z jej &bdquo;inteligentnejších&rdquo; podtried umožňujúcich (polo)automatické škálovanie scény v závislosti od veľkosti okna. V takom prípade sa absolútne súradnice ovládacích prvkov zvyčajne vôbec nenastavujú.
* Formát jednotlivých ovládacích prvkov (ako napríklad font alebo farba) by sa po správnosti nemal nastavovať priamo v zdrojovom kóde. Namiesto toho je odporúčaným prístupom využitie štýlov definovaných v pomocných súboroch JavaFX CSS. Takto je možné meniť formátovanie bez väčších zásahov do zdrojového kódu. 

Obidva tieto nedostatky napravíme v rámci nasledujúcej prednášky.

=== Oživenie ovládacích prvkov (spracovanie udalostí) ===

Dokončime našu jednoduchú aplikáciu so zadávaním textu pridaním jej kľúčovej funkcionality: po stlačení tlačidla OK (t.j. <tt>button</tt>) sa má do &bdquo;červeného&rdquo; popisku prekopírovať text zadaný používateľom do textového poľa.

Po stlačení tlačidla <tt>button</tt> je systémom vygenerovaná tzv. ''udalosť'', ktorá je v tomto prípade typu <tt>[https://openjfx.io/javadoc/15/javafx.base/javafx/event/ActionEvent.html ActionEvent]</tt>. Udalosť je teda akýsi objekt nesúci informáciu o tom, že bolo stlačené dané tlačidlo. Každé tlačidlo &ndash; objekt typu <tt>[https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/Button.html Button]</tt> &ndash; má navyše k dispozícii (zdedenú) metódu 
<syntaxhighlight lang="java">
public final void setOnAction(EventHandler<ActionEvent> value)
</syntaxhighlight>
umožňujúcu &bdquo;zaregistrovať&rdquo; pre dané tlačidlo jeho spracovávateľa udalostí typu <tt>ActionEvent</tt>. Ním môže byť ľubovoľná trieda implementujúca rozhranie <tt>[https://openjfx.io/javadoc/15/javafx.base/javafx/event/EventHandler.html EventHandler]<ActionEvent></tt>, ktoré vyžaduje implementáciu jedinej metódy
<syntaxhighlight lang="java">
void handle(ActionEvent event)
</syntaxhighlight>
Po zaregistrovaní objektu <tt>eventHandler</tt> ako spracovávateľa udalostí <tt>ActionEvent</tt> pre tlačidlo <tt>button</tt> volaním
<syntaxhighlight lang="java">
button.setOnAction(eventHandler);
</syntaxhighlight> 
sa po každom stlačení tlačidla <tt>button</tt> vykoná metóda <tt>eventHandler.handle</tt>.

Nami požadovanú funkcionalitu tlačidla <tt>button</tt> tak vieme vyjadriť napríklad pomocou lokálnej triedy <tt>ButtonActionEventHandler</tt>.
<syntaxhighlight lang="java">
import javafx.event.*;

// ...

public void start(Stage primaryStage) {
    
    // ...

    class ButtonActionEventHandler implements EventHandler<ActionEvent> {
        @Override
        public void handle(ActionEvent event) {
            label2.setText(textField.getText());
        }
    }
        
    EventHandler<ActionEvent> eventHandler = new ButtonActionEventHandler();
    button.setOnAction(eventHandler);

    // ...

}
</syntaxhighlight>

Skrátene môžeme to isté napísať s použitím anonymnej triedy.
<syntaxhighlight lang="java">
public void start(Stage primaryStage) {
    
    // ...

    button.setOnAction(new EventHandler<>() {
        @Override
        public void handle(ActionEvent event) {
            label2.setText(textField.getText());
        }
    });

    // ...

}
</syntaxhighlight>

Ak si navyše uvedomíme, že je rozhraní <tt>EventHandler</tt> deklarovaná jediná abstraktná metóda &ndash; ide teda o ''funkcionálne rozhranie'' &ndash; môžeme tento zápis ešte ďalej zjednodušiť použitím lambda výrazu.
<syntaxhighlight lang="java">
public void start(Stage primaryStage) {
    
    // ...

    button.setOnAction(event -> label2.setText(textField.getText()));

    // ...

}
</syntaxhighlight>

Podrobnejšie sa spracúvaním udalostí v JavaFX budeme zaoberať na nasledujúcej prednáške.

=== Geometrické útvary ===

Špeciálnym typom uzlov, ktoré možno umiestňovať do scén, sú geometrické útvary ako napríklad <tt>[https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/shape/Circle.html Circle]</tt>, <tt>[https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/shape/Rectangle.html Rectangle]</tt>, <tt>[https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/shape/Arc.html Arc]</tt>, <tt>[https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/shape/Ellipse.html Ellipse]</tt>, <tt>[https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/shape/Line.html Line]</tt>, <tt>[https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/shape/Polygon.html Polygon]</tt>, atď. Všetky útvary dedia od spoločnej abstraktnej nadtriedy <tt>[https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/shape/Shape.html Shape]</tt>. Sú definované v balíku <tt>javafx.scene.shape</tt>, ktorý je nutné na prácu s nimi importovať.

Aj keď útvary nevedia vyvolať udalosť typu <tt>ActionEvent</tt>, môžu vyvolávať udalosti iných typov. Napríklad kliknutie na útvar myšou vyústi v udalosť typu <tt>[https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/input/MouseEvent.html MouseEvent]</tt> (definovanú v balíku <tt>javafx.scene.input</tt>) a spracovávateľa takejto udalosti možno pre útvar <tt>shape</tt> zaregistrovať pomocou metódy <tt>shape.setOnMouseClicked</tt>.

Nasledujúci kód vykreslí &bdquo;tabuľku&rdquo; o 10 krát 10 útvaroch, pričom pre každý sa náhodne určí, či pôjde o štvorec, alebo o kruh. Farba každého z útvarov sa taktiež určí náhodne. Navyše po kliknutí myšou na ktorýkoľvek z útvarov sa jeho farba náhodne zmení.  

[[Image:Okno3.png|thumb|Výsledná aplikácia.|360px]]

<syntaxhighlight lang="java">
import javafx.application.*;
import javafx.stage.*;
import javafx.scene.*;
import javafx.scene.layout.*;
import javafx.scene.shape.*;
import javafx.scene.paint.*;
import java.util.*;

public class Aplikacia extends Application {

    private Color randomColour(Random random) {
        return Color.color(random.nextDouble(), random.nextDouble(), random.nextDouble());
    }

    @Override
    public void start(Stage primaryStage) {
        Pane pane = new Pane();

        Random random = new Random();
        for (int i = 0; i <= 9; i++) {
            for (int j = 0; j <= 9; j++) {
                Shape shape;
                Color colour = randomColour(random);
                if (random.nextBoolean()) {
                    shape = new Rectangle(j * 60 + 5, i * 60 + 5, 50, 50);
                } else {
                    shape = new Circle(j * 60 + 30, i * 60 + 30, 25);
                }
                shape.setFill(colour);
                shape.setOnMouseClicked(event -> shape.setFill(randomColour(random)));
                pane.getChildren().add(shape);
            }
        }

        Scene scene = new Scene(pane, 600, 600);

        primaryStage.setTitle("Geometrické útvary");
        primaryStage.setResizable(false);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}
</syntaxhighlight>

== Odkazy ==

* [https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html Java tutoriál: Lambda Expressions]
* [https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html Java tutoriál: Method References]
* [https://openjfx.io/javadoc/15/ Dokumentácia k JavaFX]
=Letný semester, prednáška č. 11=
== Oznamy ==

* Do začiatku stredajších cvičení treba odovzdať tretiu bonusovú úlohu.
* Dnes od 11:00 je v AISe otvorené prihlasovanie na skúšky.
* Každý termín skúšky bude pozostávať z praktickej a ústnej časti (v ten istý deň):
** Praktická časť: individuálne riešenie troch programátorských úloh a ich odovzdávanie na testovač. Je potrebné získať aspoň 15 bodov z 30. Čas na riešenie praktickej časti skúšky bude 135 minút.
** Najneskôr pol hodinu pred avizovaným začiatkom ústnych skúšok sa na testovači u všetkých zúčastnených študentov objavia body z praktickej časti a v komentári aj očakávaný čas začiatku ústnej skúšky.
** Ústna časť: diskusia o teórii z prednášok alebo o odovzdaných programoch, prípadne riešenie jednoduchých úloh. Účasť na ústnej skúške je možná iba v prípade zisku aspoň 15 bodov z praktickej časti a 50 bodov zo semestra celkom; aj v prípade neúspechu je ale možné čas vyhradený na ústnu skúšku využiť na konzultáciu.
* Po dnešnej prednáške bude na testovači zverejnené zadanie piatej domácej úlohy s termínom odovzdania ''do pondelka 10. mája, 9:00'', za ktorú bude možné získať aj dva bonusové body.
* Počas cvičení ''v stredu 28. apríla'' bude prebiehať piaty test. Počas nasledujúcich dvoch cvičení budú prebiehať náhradné termíny testov.

== Grafický návrh scény: jednoduchá kalkulačka ==

Prístup ku grafickému návrhu aplikácií z minulej prednášky, v ktorom sme každému ovládaciemu prvku na scéne manuálne nastavovali jeho polohu a štýl, sa už pri o čo i len málo rozsiahlejších aplikáciách javí byť príliš prácnym a nemotorným. V nasledujúcom sa preto zameriame na alternatívny prístup založený predovšetkým na dvoch základných technikách:
* Namiesto koreňovej oblasti typu <tt>Pane</tt> budeme používať jej &bdquo;inteligentnejšie&rdquo; podtriedy, ktoré presnú polohu ovládacích prvkov určujú automaticky na základe preferencií daných programátorom.
* Formátovanie ovládacích prvkov (napríklad font textu, farba výplne, atď.) obvykle nebudeme nastavovať priamo zo zdrojového kódu, ale pomocou štýlov definovaných v externých JavaFX CSS súboroch. (Tie sa podobajú na klasické CSS používané pri návrhu webových stránok. Na zvládnutie tejto prednášky však ''nie je'' potrebná žiadna predošlá znalosť CSS; obmedzíme sa navyše len na naznačenie niektorých základných možností JavaFX CSS štýlov). Výhodou použitia externých CSS štýlov je aj možnosť meniť vzhľad aplikácie bez zásahov do jej zdrojového kódu.

[[Image:Kalkulacka1.png|thumb|Výsledný vzhľad aplikácie.|420px]]

Uvedené techniky demonštrujeme na ukážkovej aplikácii: (azda až priveľmi) jednoduchej kalkulačke. Výsledný vzhľad tejto aplikácie je na obrázku vpravo. Jej základná funkcionalita bude pozostávať z možnosti zadať dve reálne čísla a zvoliť jednu zo štyroch operácií &ndash; sčítanie, odčítanie, násobenie, prípadne delenie. Po stlačení tlačidla <tt>Počítaj!</tt> sa zobrazí výsledok vybranej operácie na zadanej dvojici čísel. Okrem toho aplikácia obsahuje tlačidlo na zmazanie všetkých vstupných údajov a zobrazeného výsledku a tlačidlo na ukončenie aplikácie.

Základom pre túto aplikáciu bude podobná kostra programu ako na minulej prednáške &ndash; jedine rozmery scény už nebudeme nastavovať manuálne, pretože by to neskôr mohlo viesť k rozličným problémom.

<syntaxhighlight lang="java">
import javafx.application.*;
import javafx.stage.*;
import javafx.scene.*;
import javafx.scene.layout.*;
import javafx.scene.control.*;
import javafx.event.*;

public class Calculator extends Application {

    @Override
    public void start(Stage primaryStage) {
        Pane pane = new Pane();

        Scene scene = new Scene(pane);

        primaryStage.setScene(scene);
        primaryStage.setTitle("Kalkulačka");
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}
</syntaxhighlight> 

=== Formátovanie pomocou JavaFX CSS štýlov (1. časť) ===

Predpokladajme, že potrebujeme vytvoriť aplikáciu s dostatočnou veľkosťou písma všetkých jej textových prvkov (napríklad 11 typografických bodov). Mohli by sme túto vlastnosť nastavovať manuálne pre všetky jednotlivé ovládacie prvky, podobne ako na minulej prednáške &ndash; takýto prístup však po čase omrzí. Podobne každá zmena požadovanej veľkosti písma (napríklad na 12 bodov) by v budúcnosti vyžadovala vynaloženie rovnakého úsilia. Vhodnejším prístupom je použitie [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/doc-files/cssref.html JavaFX CSS štýlov] definovaných v externom súbore.

Vytvorme textový súbor <tt>styles.css</tt> s nasledujúcim obsahom:
<syntaxhighlight lang="css">
.root {
    -fx-font-size: 11pt;
}
</syntaxhighlight>
Následne si v prípade práce s IntelliJ vyberme jednu z nasledujúcich možností:
* Súbor uložme do adresára <tt><Koreňový adresár projektu>/src</tt>. To je najjednoduchšia možnosť, ktorá ale hlavne pri väčších projektoch môže zneprehľadniť súborovú štruktúru projektu.
* V koreňovom adresári projektu &ndash; t. j. na rovnakej úrovni ako je adresár <tt>src</tt> &ndash; vytvorme nový adresár, ktorý môžeme nazvať napríklad <tt>resources</tt>. Následne v IntelliJ na tento adresár kliknime pravou myšou a označme ho prostredníctvom možnosti <tt>Mark Directory as --> Resources Root</tt>. Súbor <tt>styles.css</tt> uložme do tohto novovytvoreného adresára.

JavaFX CSS súbor s uvedeným obsahom hovorí, že východzia veľkosť písma má byť 11 bodov. Zostáva tak súbor <tt>styles.css</tt> &bdquo;aplikovať&rdquo; na našu scénu:
<syntaxhighlight lang="java">
@Override
public void start(Stage primaryStage) {
        
    // ...   

    scene.getStylesheets().add("styles.css");
        
    // ...
}
</syntaxhighlight>

Ako argument metódy <tt>add</tt> tu môžeme zadať aj cestu relatívnu od niektorého z umiestnení opísaných vyššie, prípadne adresu URL.

=== Scéna a strom uzlov ===

Obsah JavaFX scény sa reprezentuje v podobe tzv. ''stromu uzlov'' alebo ''grafu uzlov''. (Druhý termín je o niečo presnejší, pretože v skutočnosti môže ísť o niekoľko stromov tvoriacich les, pričom viditeľné sú uzly iba jedného z nich.)

* Prvky umiestňované na scénu sa nazývajú ''uzly'' &ndash; triedy reprezentujúce tieto prvky majú ako spoločného predka triedu <tt>[https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/Node.html Node]</tt>.
* Niektoré z uzlov môžu byť rodičmi iných uzlov na scéne &ndash; typickým príkladom sú napríklad oblasti typu [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/layout/Pane.html <tt>Pane</tt>], s ktorými sme sa stretli už minule a ktoré sme využívali ako kontajnery pre ovládacie prvky umiestňované na scénu (tie sa tak stali deťmi danej oblasti). Všetky triedy reprezentujúce uzly, ktoré môžu byť rodičmi iných uzlov, sú potomkami triedy [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/Parent.html <tt>Parent</tt>]; tá je priamou podtriedou triedy <tt>Node</tt>. Medzi takéto triedy okrem <tt>Pane</tt> patria aj triedy pre ovládacie prvky ako napríklad [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/Button.html <tt>Button</tt>] alebo [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/Label.html <tt>Label</tt>]. ''Nepatria'' medzi ne napríklad triedy pre geometrické útvary (trieda [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/shape/Shape.html <tt>Shape</tt>] a jej potomkovia).
* Pri vytváraní scény je ako argument konštruktora potrebné zadať koreňový uzol stromu &ndash; tým môže byť inštancia ľubovoľnej triedy, ktorá je potomkom triedy <tt>Parent</tt>. Ďalšie &bdquo;poschodia&rdquo; stromu uzlov sa typicky pridávajú podobne ako na minulej prednáške, napríklad s využitím metódy <tt>getChildren().add</tt> pre jednotlivé rodičovské uzly.

=== Rozloženie uzlov na scéne ===

Vráťme sa teraz k nášmu projektu jednoduchej kalkulačky. Naším najbližším cieľom bude umiestnenie jednotlivých ovládacích prvkov na scénu. Chceli by sme sa pritom vyhnúť manuálnemu nastavovaniu ich polôh; namiesto oblasti typu <tt>Pane</tt> preto ako koreňový uzol použijeme oblasť, ktorá sa bude o rozloženie ovládacích prvkov starať do veľkej miery samostatne.

==== <tt>GridPane</tt> ====

Odmyslime si na chvíľu tlačidlá &bdquo;<tt>Zmaž</tt>&rdquo; a &bdquo;<tt>Skonči</tt>&rdquo; a umiestnime na scénu zvyšné ovládacie prvky. Ako koreňový uzol použijeme namiesto oblasti typu <tt>Pane</tt> oblasť typu [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/layout/GridPane.html <tt>GridPane</tt>]. Trieda <tt>GridPane</tt> je jednou z podtried triedy <tt>Pane</tt> umožňujúcich &bdquo;inteligentné&rdquo; spravovanie rozloženia uzlov. 

<syntaxhighlight lang="java">
@Override
public void start(Stage primaryStage) {

    // ...

    // Pane pane = new Pane();
    GridPane grid = new GridPane();
     
    // Scene scene = new Scene(pane);
    Scene scene = new Scene(grid);

    // ...
}
</syntaxhighlight>

Oblasť typu <tt>GridPane</tt> umožňuje pridávanie ovládacích prvkov do obdĺžnikovej mriežky. Pridajme teda prvý ovládací prvok &ndash; popisok obsahujúci text &bdquo;<tt>Zadajte vstupné hodnoty:</tt>&rdquo;. Riadky aj stĺpce mriežky sa pri <tt>GridPane</tt> indexujú počínajúc nulou; maximálny index je (takmer) neobmedzený. Vytvorený textový popisok teda vložíme do políčka v nultom stĺpci a v nultom riadku. Okrem toho povieme, že obsah vytvoreného textového popisku môže prípadne zabrať až dva stĺpce mriežky, ale iba jeden riadok.

<syntaxhighlight lang="java">
Label lblHeader = new Label("Zadajte vstupné hodnoty:");  // Vytvorenie textoveho popisku
grid.getChildren().add(lblHeader);                        // Pridanie do stromu uzlov za syna oblasti grid 
GridPane.setColumnIndex(lblHeader, 0);                    // Vytvoreny popisok bude v 0-tom stlpci
GridPane.setRowIndex(lblHeader, 0);                       // Vytvoreny popisok bude v 0-tom riadku
GridPane.setColumnSpan(lblHeader, 2);                     // Moze zabrat az 2 stlpce...
GridPane.setRowSpan(lblHeader, 1);                        // ... ale iba 1 riadok
</syntaxhighlight>

Všimnime si, že pozíciu <tt>lblHeader</tt> v mriežke nastavujeme pomocou ''statických'' metód triedy <tt>GridPane</tt>. Ak sa riadok resp. stĺpec nenastavia ručne, použije sa východzia hodnota <tt>0</tt>. Podobne sa pri nenastavení zvyšných dvoch hodnôt použije východzia hodnota <tt>1</tt> (na čo sa budeme často spoliehať).

Uvedený spôsob pridania ovládacieho prvku do mriežky je však pomerne prácny &ndash; vyžaduje si až päť príkazov. Existuje preto skratka: všetkých päť príkazov možno vykonať v rámci jediného volania metódy <tt>grid.add</tt>:
<syntaxhighlight lang="java">
Label lblHeader = new Label("Zadajte vstupné hodnoty:");  
grid.add(lblHeader, 0, 0, 2, 1);

// grid.getChildren().add(lblHeader);                        
// GridPane.setColumnIndex(lblHeader, 0);                   
// GridPane.setRowIndex(lblHeader, 0);                       
// GridPane.setColumnSpan(lblHeader, 2);                     
// GridPane.setRowSpan(lblHeader, 1);    
</syntaxhighlight>
(Bez explicitného uvedenia posledných dvoch parametrov metódy <tt>add</tt> by sa použili ich východzie hodnoty <tt>1, 1</tt>.)

Podobne môžeme do mriežky umiestniť aj ďalšie ovládacie prvky:
<syntaxhighlight lang="java">
Label lblNumber1 = new Label("Prvý argument:");
grid.add(lblNumber1, 0, 1);

Label lblNumber2 = new Label("Druhý argument:");
grid.add(lblNumber2, 0, 2);

Label lblOperation = new Label("Operácia:");
grid.add(lblOperation, 0, 3);

Label lblResultText = new Label("Výsledok:");
grid.add(lblResultText, 0, 5);

Label lblResult = new Label("0");
grid.add(lblResult, 1, 5);

TextField tfNumber1 = new TextField();
grid.add(tfNumber1, 1, 1);

TextField tfNumber2 = new TextField();
grid.add(tfNumber2, 1, 2);

ComboBox<String> cbOperation = new ComboBox<>();
grid.add(cbOperation, 1, 3);
cbOperation.getItems().addAll("+", "-", "*", "/");
cbOperation.setValue("+");

Button btnOK = new Button("Počítaj!");
grid.add(btnOK, 1, 4);
</syntaxhighlight>

Novým prvkom je tu &bdquo;vyskakovací zoznam&rdquo; <tt>[https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/ComboBox.html ComboBox<T>]</tt> prvkov typu <tt>T</tt>. Jeho metóda <tt>getItems</tt> vráti zoznam všetkých možností na výber (ten je na začiatku prázdny), do ktorého následne vkladáme možnosti zodpovedajúce jednotlivým operáciám. Metóda <tt>setValue</tt> nastaví aktuálne zvolenú možnosť. (V takomto východzom stave nemožno do <tt>ComboBox</tt>-u zadávať text manuálne; v prípade potreby je ale možné túto možnosť aktivovať metódou <tt>setEditable</tt> s parametrom <tt>true</tt>.)

Pre účely ladenia ešte môžeme zviditeľniť deliace čiary mriežky nasledujúcim spôsobom:
<syntaxhighlight lang="java">
grid.setGridLinesVisible(true);
</syntaxhighlight>

<gallery mode="packed" widths="300px" heights="200px">
Image:Kalkulacka2.png|Vzhľad aplikácie po pridaní ovládacích prvkov.
Image:Kalkulacka3.png|Po zviditeľnení deliacich čiar mriežky.
</gallery>

Môžeme ďalej napríklad nastaviť preferované rozmery niektorých ovládacích prvkov (neskôr ale uvidíme lepší spôsob, ako to robiť):
<syntaxhighlight lang="java">
tfNumber1.setPrefWidth(300);
tfNumber2.setPrefWidth(300);
cbOperation.setPrefWidth(300);
</syntaxhighlight>
Tiež si môžeme všimnúť, že medzi jednotlivými políčkami mriežky nie sú žiadne medzery. To vyriešime napríklad nasledovne:
<syntaxhighlight lang="java">
grid.setHgap(10);  // Horizontalna medzera medzi dvoma polickami mriezky bude 10 pixelov
grid.setVgap(10);  // To iste pre vertikalnu medzeru
</syntaxhighlight>
Podobne nie je žiadna medzera medzi mriežkou a okrajmi okna. To možno vyriešiť pomocou nastavenia &bdquo;okrajov&rdquo;:
<syntaxhighlight lang="java">
import javafx.geometry.*;

// ...

grid.setPadding(new Insets(10,20,10,20));  // horny okraj 10 pixelov, pravy 20, dolny 10, lavy 20
</syntaxhighlight>
[[Image:Kalkulacka4.png|thumb|340px|Vzhľad aplikácie po nastavení okrajov.]]

Trieda [https://openjfx.io/javadoc/15/javafx.graphics/javafx/geometry/Insets.html <tt>Insets</tt>] (skratka od angl. ''Inside Offsets'') reprezentuje iba súbor štyroch hodnôt pre &bdquo;veľkosti okrajov&rdquo; a je definovaná v balíku <tt>javafx.geometry</tt>. Vzhľad aplikácie v tomto momente je na obrázku vpravo.

Ďalej si môžeme všimnúť, že obsah mriežky zostáva aj pri zväčšovaní veľkosti okna v jeho ľavom hornom rohu. Zarovnanie obsahu mriežky na stred dostaneme volaním
<syntaxhighlight lang="java">
grid.setAlignment(Pos.CENTER);
</syntaxhighlight>
Pre oblasť <tt>grid</tt> je vyhradené prakticky celé okno; uvedeným volaním hovoríme, že jej reálny obsah sa má zarovnať na stred tejto vyhradenej oblasti.

Pomerne žiadúcim správaním aplikácie pri zväčšovaní šírky okna je súčasné rozširovanie textových polí a &bdquo;vyskakovacieho zoznamu&rdquo;. Zrušme najprv manuálne nastavenú preferovanú šírku uvedených ovládacích prvkov:
<syntaxhighlight lang="java">
// tfNumber1.setPrefWidth(300);
// tfNumber2.setPrefWidth(300);
// cbOperation.setPrefWidth(300);
</syntaxhighlight>
Cielený efekt dosiahneme naplnením zoznamu &bdquo;obmedezní pre jednotlivé stĺpce&rdquo;, ktorý si každá oblasť typu <tt>GridPane</tt> udržiava. &bdquo;Obmedzenia&rdquo; na nultý stĺpec nebudú žiadne; v &bdquo;obmedzeniach&rdquo; nasledujúceho stĺpca nastavíme jeho preferovanú šírku na 300 pixelov a povieme tiež, aby sa pri rozširovaní oblasti rozširoval aj daný stĺpec. &bdquo;Obmedzenia&rdquo; pre jednotlivé stĺpce sú reprezentované triedou [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/layout/ColumnConstraints.html <tt>ColumnConstraints</tt>]. (Analogicky je možné nastavovať &bdquo;obmedzenia&rdquo; aj pre jednotlivé riadky.)
<syntaxhighlight lang="java">
ColumnConstraints cc = new ColumnConstraints();
cc.setPrefWidth(300);
cc.setHgrow(Priority.ALWAYS);
grid.getColumnConstraints().addAll(new ColumnConstraints(), cc); 
</syntaxhighlight>
Uvedený kód funguje až na jeden detail: pri rozširovaní okna sa nemení veľkosť &bdquo;vyskakovacieho zoznamu&rdquo;. To je dané tým, že jeho východzia ''maximálna'' veľkosť je totožná s jeho preferovanou veľkosťou; na dosiahnutie kýženého efektu je teda potrebné prestaviť túto maximálnu veľkosť tak, aby viac &bdquo;neprekážala&rdquo;:
<syntaxhighlight lang="java">
cbOperation.setMaxWidth(Integer.MAX_VALUE);
</syntaxhighlight>

Nastavme ešte zarovnanie niektorých ovládacích prvkov na pravý okraj ich políčka mriežky. Využijeme pritom ''statickú'' metódu <tt>setHalignment</tt> triedy <tt>GridPane</tt>:
[[Image:Kalkulacka5.png|thumb|340px|Vzhľad aplikácie po dokončení návrhu rozloženia ovládacích prvkov v mriežke.]]
<syntaxhighlight lang="java">
GridPane.setHalignment(lblNumber1, HPos.RIGHT);
GridPane.setHalignment(lblNumber2, HPos.RIGHT);
GridPane.setHalignment(lblOperation, HPos.RIGHT);
GridPane.setHalignment(lblResultText, HPos.RIGHT);
GridPane.setHalignment(lblResult, HPos.RIGHT);
GridPane.setHalignment(btnOK, HPos.RIGHT);
</syntaxhighlight>
S návrhom rozloženia ovládacích prvkov v mriežke sme teraz hotoví a môžeme teda aj zrušiť zobrazovanie deliacich čiar:
<syntaxhighlight lang="java">
// grid.setGridLinesVisible(true);
</syntaxhighlight>
Momentálny vzhľad aplikácie je na obrázku vpravo.

==== <tt>BorderPane</tt> a <tt>VBox</tt> ====

Pridáme teraz tlačidlá &bdquo;<tt>Zmaž</tt>&rdquo; a &bdquo;<tt>Skonči</tt>&rdquo;. Mohli by sme ich samozrejme umiestniť napríklad do ďalšieho stĺpca mriežky <tt>grid</tt>. Tu si však ukážeme odlišný prístup &ndash; namiesto oblasti typu <tt>GridPane</tt> použijeme ako koreňový uzol scény oblasť typu [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/layout/BorderPane.html <tt>BorderPane</tt>]. Tá sa ako koreňový uzol scény používa asi najčastejšie, pretože umožňuje nastaviť päť základných častí scény: hornú, pravú, dolnú, ľavú a stredovú časť. 

Typicky každá z týchto častí (ak je definovaná) pozostáva z ďalšej oblasti nejakého iného typu &ndash; v našom prípade za centrálnu časť zvolíme už vytvorenú mriežku <tt>grid</tt>:
<syntaxhighlight lang="java">
BorderPane border = new BorderPane();
border.setCenter(grid);
        
// Scene scene = new Scene(grid);
Scene scene = new Scene(border);
</syntaxhighlight>

Zostáva si teraz vytvoriť &bdquo;kontajnerovú&rdquo; oblasť pre pravú časť a umiestniť do nej spomínané dve tlačidlá. Keďže majú byť tieto tlačidlá umiestnené nad sebou, pravdepodobne najlepšou voľbou ich &bdquo;kontajnerovej&rdquo; oblasti je oblasť typu <tt>[https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/layout/VBox.html VBox]</tt>, do ktorej sa jednotlivé uzly vkladajú vertikálne jeden pod druhý:
<syntaxhighlight lang="java">
VBox right = new VBox();                       // Vytvorenie oblasti typu VBox
right.setPadding(new Insets(10, 20, 10, 60));  // Nastavenie okrajov (v poradi horny, pravy, dolny, lavy)
right.setSpacing(10);                          // Vertikalne medzery medzi vkladanymi uzlami
right.setAlignment(Pos.BOTTOM_LEFT);           // Zarovnanie obsahu oblasti vertikalne nadol a horizontalne dolava  

border.setRight(right);                        // Nastavenie oblasti right ako pravej casti oblasti border
</syntaxhighlight>
Vložíme teraz do oblasti <tt>right</tt> obidve tlačidlá:
<syntaxhighlight lang="java">
Button btnClear = new Button("Zmaž");
right.getChildren().add(btnClear);
        
Button btnExit = new Button("Skonči");
right.getChildren().add(btnExit);
</syntaxhighlight>
[[Image:Kalkulacka6.png|thumb|400px|Vzhľad aplikácie po pridaní prvkov v pravej časti okna.]]
Vidíme ale, že tlačidlá majú rôznu šírku, čo nevyzerá veľmi dobre. Rovnakú šírku by sme samozrejme vedeli dosiahnuť manuálnym nastavením veľkosti tlačidiel na nejakú fixnú hodnotu; to však nie je najideálnejší prístup. Na dosiahnutie rovnakého efektu využijeme skutočnosť, že šírka oblasti <tt>right</tt> sa automaticky nastaví na preferovanú šírku širšieho z oboch tlačidiel. Užšie z tlačidiel ostáva menšie preto, lebo jeho východzia maximálna šírka je rovná jeho preferovanej šírke. Po prestavení maximálnej šírky na dostatočne veľkú hodnotu sa toto tlačidlo taktiež roztiahne na celú šírku oblasti <tt>right</tt>:
<syntaxhighlight lang="java">
btnClear.setMaxWidth(Double.MAX_VALUE);
btnExit.setMaxWidth(Double.MAX_VALUE);
</syntaxhighlight>
Momentálny vzhľad aplikácie je na obrázku vpravo.

==== Ďalšie rozloženia ====

Okrem <tt>GridPane</tt>, <tt>BorderPane</tt> a <tt>VBox</tt> existuje v JavaFX aj niekoľko ďalších oblastí umožňujúcich (polo)automaticky spravovať rozloženie jednotlivých uzlov:
* [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/layout/HBox.html <tt>HBox</tt>]: ide o horizontálnu obdobu <tt>VBox</tt>-u.
* [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/layout/StackPane.html <tt>StackPane</tt>]: umiestňuje prvky na seba (dá sa použiť napríklad pri tvorbe grafických komponentov; môžeme dajme tomu jednoducho vytvoriť obdĺžnik obsahujúci nejaký text, atď.).
* [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/layout/FlowPane.html <tt>FlowPane</tt>]: umiestňuje prvky za seba po riadkoch, prípadne po stĺpcoch. Pri zmene rozmerov okna môže dôjsť k zmene pozície jednotlivých prvkov.
* [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/layout/TilePane.html <tt>TilePane</tt>]: udržiava &bdquo;dlaždice&rdquo; rovnakej veľkosti.
* [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/layout/AnchorPane.html <tt>AnchorPane</tt>]: umožňuje ukotvenie prvkov na danú pozíciu.

=== Kalkulačka: oživenie aplikácie ===

Pridajme teraz jednotlivým ovládacím prvkom aplikácie ich funkcionalitu (vystačíme si pritom s metódami z minulej prednášky). Kľúčovou je pritom funkcionalita tlačidla <tt>btnOK</tt>.
<syntaxhighlight lang="java">
public class Calculator extends Application {

    // ...

    /**
     * Metoda, ktora aplikuje na argumenty arg1, arg2 operaciu reprezentovanu retazcom op.
     * @param operation Jeden z retazcov "+", "-", "*", "/" reprezentujucich vykonavanu operaciu.
     * @param arg1      Prvy operand.
     * @param arg2      Druhy operand.
     * @return          Vysledok operacie operation aplikovanej na operandy arg1, arg2.
     */
    private double calculate(String operation, double arg1, double arg2) {
        switch (operation) {
            case "+":
                return arg1 + arg2;
            case "-":
                return arg1 - arg2;
            case "*":
                return arg1 * arg2;
            case "/":
                return arg1 / arg2;
            default:
                throw new IllegalArgumentException();
        }
    }

    // ...

    @Override
    public void start(Stage primaryStage) {

        // ...
    
        btnOK.setOnAction(event -> {
            try {
                lblResult.setText(Double.toString(calculate(
                        cbOperation.getValue(),
                        Double.parseDouble(tfNumber1.getText()),
                        Double.parseDouble(tfNumber2.getText()))));
            } catch (NumberFormatException exception) {
                lblResult.setText("Výnimka!");
            }
        });

        // ...
    }
}
</syntaxhighlight>

Podobne môžeme pridať aj funkcionalitu zostávajúcich dvoch tlačidiel.
<syntaxhighlight lang="java">
@Override
public void start(Stage primaryStage) {

    // ...

    btnClear.setOnAction(event -> {
        tfNumber1.clear();
        tfNumber2.clear();
        cbOperation.setValue("+");
        lblResult.setText("0");
    });
        
    btnExit.setOnAction(event -> {
        Platform.exit();
    });
    
    // ...
}
</syntaxhighlight>

=== Formátovanie pomocou JavaFX CSS štýlov (2. časť) ===

Finálny vzhľad aplikácie získame doplnením súboru <tt>styles.css</tt>. Môžeme začať tým, že okrem východzej veľkosti fontu nastavíme aj východziu skupinu fontov a textúru na pozadí aplikácie:
<syntaxhighlight lang="css">
.root {
    -fx-font-size: 11pt;
    -fx-font-family: 'Tahoma';
    -fx-background-image: url("texture.jpg");
    -fx-background-size: cover;
}
</syntaxhighlight>
Na internete je množstvo textúr dostupných pod licenciou ''Public Domain'' (CC0) &ndash; to je aj prípad textúry z ukážky finálneho vzhľadu aplikácie z úvodu tejto prednášky. Súbor s textúrou je potrebné uložiť do rovnakého adresára ako súbor <tt>styles.css</tt>.

Možno tiež nastavovať formát jednotlivých skupín ovládacích prvkov. Nasledovne napríklad docielime, aby sa pri všetkých tlačidlách a textových popiskoch použilo tučné písmo; textové popisky navyše ofarbíme bielou farbou:
<syntaxhighlight lang="css">
.label {
    -fx-font-weight: bold;
    -fx-text-fill: white;
}

.button {
    -fx-font-weight: bold;
}
</syntaxhighlight>

Formát ovládacích prvkov je možné nastavovať aj individuálne &ndash; v takom prípade ale musíme dotknutým prvkom v zdrojovom kóde aplikácie nastaviť ich identifikátor:
<syntaxhighlight lang="java">
@Override
    public void start(Stage primaryStage) {

    ...    
    
    lblHeader.setId("header");
    lblResult.setId("result");

    ...
}
</syntaxhighlight>
V JavaFX CSS súbore následne vieme prispôsobiť formát pomenovaných ovládacích prvkov:
<syntaxhighlight lang="css">
#header {
    -fx-font-size: 18pt;
}

#result {
    -fx-font-size: 16pt;  
    -fx-text-fill: black;
}
</syntaxhighlight>

=== Kalkulačka: kompletný kód aplikácie ===

''Zdrojový kód aplikácie'':

<syntaxhighlight lang="java">
import javafx.application.*;
import javafx.stage.*;
import javafx.scene.*;
import javafx.scene.layout.*;
import javafx.scene.control.*;
import javafx.event.*;
import javafx.geometry.*;

public class Calculator extends Application {

    /**
     * Metoda, ktora aplikuje na argumenty arg1, arg2 operaciu reprezentovanu retazcom op.
     * @param operation Jeden z retazcov "+", "-", "*", "/" reprezentujucich vykonavanu operaciu.
     * @param arg1      Prvy operand.
     * @param arg2      Druhy operand.
     * @return          Vysledok operacie operation aplikovanej na operandy arg1, arg2.
     */
    public double calculate(String operation, double arg1, double arg2) {
        switch (operation) {
            case "+":
                return arg1 + arg2;
            case "-":
                return arg1 - arg2;
            case "*":
                return arg1 * arg2;
            case "/":
                return arg1 / arg2;
            default:
                throw new IllegalArgumentException();
        }
    }

    @Override
    public void start(Stage primaryStage) {
        GridPane grid = new GridPane();

        Label lblHeader = new Label("Zadajte vstupné hodnoty:");
        grid.add(lblHeader, 0, 0, 2, 1);
        lblHeader.setId("header");

        Label lblNumber1 = new Label("Prvý argument:");
        grid.add(lblNumber1, 0, 1);
        GridPane.setHalignment(lblNumber1, HPos.RIGHT);

        Label lblNumber2 = new Label("Druhý argument:");
        grid.add(lblNumber2, 0, 2);
        GridPane.setHalignment(lblNumber2, HPos.RIGHT);

        Label lblOperation = new Label("Operácia:");
        grid.add(lblOperation, 0, 3);
        GridPane.setHalignment(lblOperation, HPos.RIGHT);

        Label lblResultText = new Label("Výsledok:");
        grid.add(lblResultText, 0, 5);
        GridPane.setHalignment(lblResultText, HPos.RIGHT);

        Label lblResult = new Label("0");
        grid.add(lblResult, 1, 5);
        GridPane.setHalignment(lblResult, HPos.RIGHT);
        lblResult.setId("result");

        TextField tfNumber1 = new TextField();
        grid.add(tfNumber1, 1, 1);

        TextField tfNumber2 = new TextField();
        grid.add(tfNumber2, 1, 2);

        ComboBox<String> cbOperation = new ComboBox<>();
        grid.add(cbOperation, 1, 3);
        cbOperation.getItems().addAll("+", "-", "*", "/");
        cbOperation.setValue("+");
        cbOperation.setMaxWidth(Integer.MAX_VALUE);

        Button btnOK = new Button("Počítaj!");
        grid.add(btnOK, 1, 4);
        GridPane.setHalignment(btnOK, HPos.RIGHT);

        ColumnConstraints cc = new ColumnConstraints();
        cc.setPrefWidth(300);
        cc.setHgrow(Priority.ALWAYS);
        grid.getColumnConstraints().addAll(new ColumnConstraints(), cc);

        grid.setHgap(10);
        grid.setVgap(10);
        grid.setPadding(new Insets(10,20,10,20));
        grid.setAlignment(Pos.CENTER);


        VBox right = new VBox();
        right.setPadding(new Insets(10, 20, 10, 60));
        right.setSpacing(10);
        right.setAlignment(Pos.BOTTOM_LEFT);

        Button btnClear = new Button("Zmaž");
        right.getChildren().add(btnClear);
        btnClear.setMaxWidth(Double.MAX_VALUE);

        Button btnExit = new Button("Skonči");
        right.getChildren().add(btnExit);
        btnExit.setMaxWidth(Double.MAX_VALUE);


        BorderPane border = new BorderPane();
        border.setCenter(grid);
        border.setRight(right);


        btnOK.setOnAction(event -> {
            try {
                lblResult.setText(Double.toString(calculate(
                        cbOperation.getValue(),
                        Double.parseDouble(tfNumber1.getText()),
                        Double.parseDouble(tfNumber2.getText()))));
            } catch (NumberFormatException exception) {
                lblResult.setText("Výnimka!");
            }
        });

        btnClear.setOnAction(event -> {
            tfNumber1.setText("");
            tfNumber2.setText("");
            cbOperation.setValue("+");
            lblResult.setText("0");
        });

        btnExit.setOnAction(event -> {
            Platform.exit();
        });


        Scene scene = new Scene(border);
        scene.getStylesheets().add("styles.css");

        primaryStage.setScene(scene);
        primaryStage.setTitle("Kalkulačka");
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}
</syntaxhighlight>

''Súbor JavaFX CSS'':
<syntaxhighlight lang="css">
.root {
    -fx-font-size: 11pt;
    -fx-font-family: 'Tahoma';
    -fx-background-image: url("texture.jpg");
    -fx-background-size: cover;
}

.label {
    -fx-font-weight: bold;
    -fx-text-fill: white;
}

.button {
    -fx-font-weight: bold;
}

#header {
    -fx-font-size: 18pt;
}

#result {
    -fx-font-size: 16pt;  
    -fx-text-fill: black;
}
</syntaxhighlight>

== Programovanie riadené udalosťami ==

=== Základné princípy programovania riadeného udalosťami ===

V súvislosti s JavaFX sme začali používať novú paradigmu: ''programovanie riadené udalosťami''. Namiesto sekvenčného vykonávania jednotlivých príkazov sa tu s vykonávaním kódu čaká na udalosť zvonka, ktorou môže byť napríklad stlačenie tlačidla používateľom. Tento spôsob programovania má svoje špecifiká &ndash; s niektorými z nich sme sa už koniec koncov stretli. Na lepšie ozrejmenie princípov programovania riadeného udalosťami teraz na chvíľu odbočíme od programovania aplikácií s grafickým používateľským rozhraním a demonštrujeme esenciu tejto paradigmy na jednoduchej konzolovej aplikácii. Stále však budeme využívať triedy pre udalosti definované v balíku <tt>javafx.event</tt>.

Pre zmysluplnú prácu s udalosťami potrebujeme minimálne tri triedy: aspoň jednu triedu pre samotnú udalosť, aspoň jednu triedu pre spracovávateľa udalostí a aspoň jednu triedu schopnú udalosti spúšťať (o spúšťanie udalostí v JavaFX sa zvyčajne stará prostredie). 

Definujme teda najprv triedu <tt>MyEvent</tt> reprezentujúcu jednoduchú udalosť obsahujúcu nejakú správu o sebe.
<syntaxhighlight lang="java">
package events;

import javafx.event.*;

public class MyEvent extends Event {                                  // Nasa trieda dedi od Event, ktora je najvyssou triedou pre udalosti v JavaFX
    private static EventType myEventType = new EventType("MyEvent");  // Typ udalosti zodpovedajuci udalostiam MyEvent (pre nas nepodstatna technikalita)

    private String message;

    public MyEvent(Object source, String message) {                   // Konstruktor, ktory ma vytvorit udalost s danym odosielatelom source a spravou message
        super(source, NULL_SOURCE_TARGET, myEventType);               // Volanie konstruktora nadtriedy. Druhy a treti parameter su pre nase ucely nepodstatne
        this.message = message;                                       // Nastavime spravu zodpovedajucu nasej udalosti
    }

    public String getMessage() {                                      // Metoda, ktora vrati spravu zodpovedajucu udalosti
        return message;
    }
}
</syntaxhighlight>

Spracovávateľ JavaFX udalostí typu <tt>T</tt> sa vyznačuje tým, že implementuje rozhranie [https://openjfx.io/javadoc/15/javafx.base/javafx/event/EventHandler.html <tt>EventHandler<T></tt>]. S týmto rozhraním sme sa stretli už minule a vieme, že vyžaduje implementáciu jedinej metódy <tt>handle</tt> (čo okrem iného umožňuje nahradiť inštancie takýchto tried lambda výrazmi). Vytvorme teda jednoduchú triedu <tt>MyEventHandler</tt> pre spracovávateľa udalostí <tt>MyEvent</tt>.
<syntaxhighlight lang="java">
package events;

import javafx.event.*;

public class MyEventHandler implements EventHandler<MyEvent> {
    @Override
    public void handle(MyEvent event) {
        System.out.println("Spracuvam udalost: " + event.getMessage());
    }
}
</syntaxhighlight>

Potrebujeme ešte triedu <tt>MyEventSender</tt>, ktorá bude schopná udalosti typu <tt>MyEvent</tt> vytvárať. Tá bude zo všetkých najkomplikovanejšia. Musí totiž:
* Uchovávať zoznam <tt>actionListeners</tt> všetkých spracovávateľov udalostí, ktoré čakajú na ňou generované udalosti (v JavaFX sme zatiaľ pracovali len so situáciou, keď na jednu udalosť čaká najviac jeden spracovávateľ; hoci je to najčastejší prípad, nebýva to vždy tak).
* Poskytovať metódu <tt>addActionListener</tt> pridávajúcu spracovávateľa udalosti. (Tá sa podobá napríklad na metódu <tt>Button.setOnAction</tt> s tým rozdielom, že <tt>Button.setOnAction</tt> nepridáva ''ďalšieho'' spracovávateľa, ale pridáva ''nového jediného'' spracovávateľa. Aj <tt>Button</tt> však poskytuje metódu <tt>addEventHandler</tt>, ktorá je dokonca o niečo všeobecnejšia, než bude naša metóda <tt>addActionListener</tt>).
* Poskytovať metódu <tt>fireAction</tt>, ktorá udalosť spustí. To si vyžaduje zavolať metódu <tt>handle</tt> všetkých spracovávateľov zo zoznamu <tt>actionListeners</tt>.
<syntaxhighlight lang="java">
package events;

import java.util.*;
import javafx.event.*;

public class MyEventSender {
    private String name;
    private ArrayList<EventHandler<MyEvent>> actionListeners;  // Zoznam spracovavatelov udalosti

    public MyEventSender(String name) {
        this.name = name;
        actionListeners = new ArrayList<>();
    }

    public String getName() {
        return this.name;
    }

    public void addActionListener(EventHandler<MyEvent> handler) {   // Metoda pridavajuca spracovavatela udalosti
        actionListeners.add(handler);
    }

    public void fireAction(int type) {                               // Metoda spustajuca udalost
        MyEvent event = new MyEvent(this, "UDALOST " + type);
        for (EventHandler<MyEvent> eventHandler : actionListeners) {
            eventHandler.handle(event);
        }
    }
}
</syntaxhighlight>

Môžeme teraz ešte upraviť triedu <tt>MyEventHandler</tt> tak, aby využívala metódu <tt>getName</tt> inštancie triedy <tt>MyEventSender</tt>.
<syntaxhighlight lang="java">
public class MyEventHandler implements EventHandler<MyEvent> {
    @Override
    public void handle(MyEvent event) {
        System.out.println("Spracuvam udalost: " + event.getMessage());
        Object sender = event.getSource();
        if (sender instanceof MyEventSender) {
            System.out.println("Odosielatel udalosti: " + ((MyEventSender) sender).getName());
        }
    }
}
</syntaxhighlight>

Trieda s metódou <tt>main</tt> potom môže vyzerať napríklad nasledovne.
<syntaxhighlight lang="java">
package events;

public class SimpleEvents {

    public static void main(String[] args) {
        MyEventSender sender1 = new MyEventSender("prvy");
        MyEventSender sender2 = new MyEventSender("druhy");

        MyEventHandler handler = new MyEventHandler();
        sender1.addActionListener(handler);
        sender2.addActionListener((MyEvent event) -> {
            System.out.println("Spracuvavam udalost " + event.getMessage() + " inym sposobom.");
        });
        sender2.addActionListener(handler);
        sender2.addActionListener((MyEvent event) -> {
            System.out.println("Spracuvavam udalost " + event.getMessage() + " este inym sposobom.");
        });

        sender1.fireAction(1000);
        sender2.fireAction(2000);
    }
}
</syntaxhighlight>

=== Konzumácia udalostí ===

V triede [https://openjfx.io/javadoc/15/javafx.base/javafx/event/Event.html <tt>Event</tt>] sú okrem iného definované dve špeciálne metódy: <tt>consume()</tt> a <tt>isConsumed()</tt>. Ak je udalosť skonzumovaná, znamená to zhruba toľko, že už je spracovaná a nemusí sa predávať prípadným ďalším spracovávateľom. V našom jednoduchom programe vyššie napríklad môžeme upraviť triedu <tt>MyEventHandler</tt> tak, aby pri spracovaní udalosti túto udalosť aj rovno skonzumovala; triedu <tt>MyEventSender</tt> naopak upravíme tak, aby metódy <tt>handle</tt> jednotlivých spracovávateľov volala len kým ešte udalosť nie je skonzumovaná.
<syntaxhighlight lang="java">
public class MyEventHandler implements EventHandler<MyEvent> {
    @Override
    public void handle(MyEvent event) {
        System.out.println("Spracuvam udalost: " + event.getMessage());
        Object sender = event.getSource();
        if (sender instanceof MyEventSender) {
            System.out.println("Odosielatel udalosti: " + ((MyEventSender) sender).getName());
        }
        event.consume();
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class MyEventSender {
    
    // ...
    
   public void fireAction(int type) {                              
        MyEvent event = new MyEvent(this, "UDALOST " + type);
        for (EventHandler<MyEvent> eventHandler : actionListeners) {
            eventHandler.handle(event);
            if (event.isConsumed()) {
                break;
            }
        }
    }

    // ...
}
</syntaxhighlight>  

V JavaFX je mechanizmus konzumovania udalostí o niečo zložitejší.

=== JavaFX: udalosti myši ===

* Udalosti nejakým spôsobom súvisiace s myšou (napríklad stlačenie alebo uvoľnenie tlačidla) v JavaFX reprezentuje trieda [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/input/MouseEvent.html <tt>MouseEvent</tt>].
* Obsahuje napríklad metódy <tt>getButton()</tt>, <tt>getSceneX()</tt>, <tt>getSceneY()</tt> umožňujúce získať informácie o danej udalosti.

Vytváranie a spracovanie udalostí myši v JavaFX funguje nasledovne:
* Ako prvá sa udalosť vytvorí na tom uzle, ktorý je v mieste udalosti na scéne viditeľný (zaujímavé najmä v prípade prekrývajúcich sa uzlov).
* Spracovávatelia danej udalosti na danom uzle môžu udalosť spracovať.
* Ak po vykonaní predchádzajúceho kroku ešte nie je udalosť skonzumovaná, môže sa dostať aj k iným uzlom.
* Celkovo je predávanie udalostí k ďalším uzlom relatívne komplikovaný proces (viac detailov [https://docs.oracle.com/javafx/2/events/processing.htm tu]).

=== JavaFX: udalosti klávesnice ===
* Udalosti súvisiace s klávesnicou v JavaFX reprezentuje trieda [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/input/KeyEvent.html <tt>KeyEvent</tt>].
* Kľúčovou metódou tejto triedy je <tt>getCode</tt>, ktorá vracia kód stlačeného tlačidla klávesnice.
* Udalosť sa vytvorí na uzle, ktorý má tzv. fokus &ndash; každý uzol oň môže požiadať metódou <tt>requestFocus()</tt>.

== Časovač: pohybujúci sa kruh ==

V balíku <tt>javafx.animation</tt> je definovaná ''abstraktná'' trieda [https://openjfx.io/javadoc/15/javafx.graphics/javafx/animation/AnimationTimer.html <tt>AnimationTimer</tt>], ktorá umožňuje &bdquo;periodické&rdquo; vykonávanie určitej udalosti (zakaždým, keď sa nanovo prekreslí obsah scény). Obsahuje implementované metódy <tt>start()</tt> a <tt>stop()</tt> a abstraktnú metódu s hlavičkou 
<syntaxhighlight lang="java">
abstract void handle(long now)
</syntaxhighlight>
Prekrytím tejto metódy v podtriede dediacej od <tt>AnimationTimer</tt> možno špecifikovať udalosť, ktorá sa bude &bdquo;periodicky&rdquo; vykonávať. Jej vstupným argumentom je &bdquo;časová pečiatka&rdquo; <tt>now</tt> reprezentujúca čas v nanosekundách; pomocou nej sa dá ako-tak prispôsobiť interval vykonávania jednotlivých udalostí.

''Použitie takéhoto časovača demonštrujeme na jednoduchej aplikácii:'' v okne sa bude buď vodorovne alebo zvisle pohybovať kruh určitej veľkosti. Pri každom &bdquo;náraze&rdquo; na okraj scény sa otočí o 180 stupňov. Pri stlačení niektorej zo šípok klávesnice sa kruh začne pohybovať daným smerom. Navyše sa raz za cca. pol sekundy náhodne zmení farba kruhu.
<syntaxhighlight lang="java">
import javafx.application.*;
import javafx.stage.*;
import javafx.scene.*;
import javafx.scene.layout.*;
import javafx.scene.shape.*;
import javafx.scene.paint.*;
import javafx.animation.*;
import javafx.scene.input.*;
import java.util.*;

public class MovingCircle extends Application {

    private enum MoveDirection {                         // Vymenovany typ reprezentujuci mozne smery pohybu kruhu
        UP,
        RIGHT,
        DOWN,
        LEFT
    };

    private MoveDirection moveDirection;         // Aktualny smer pohybu kruhu

    // Metoda, ktora na scene scene posunie kruh circle smerom moveDirection o pocet pixelov delta:
    private void moveCircle(Scene scene, Circle circle, MoveDirection moveDirection, double delta) {
        double newX;
        double newY;
        switch (moveDirection) {
            case UP:
                newY = circle.getCenterY() - delta;
                if (newY >= circle.getRadius()) {                       // Ak kruh nevyjde von zo sceny, posun ho
                    circle.setCenterY(newY);
                } else {                                                // V opacnom pripade zmen smer o 180 stupnov 
                    this.moveDirection = MoveDirection.DOWN;
                }
                break;
            case DOWN:
                newY = circle.getCenterY() + delta;
                if (newY <= scene.getHeight() - circle.getRadius()) {   // Ak kruh nevyjde von zo sceny, posun ho
                    circle.setCenterY(newY);
                } else {                                                // V opacnom pripade zmen smer o 180 stupnov   
                    this.moveDirection = MoveDirection.UP;
                }
                break;
            case LEFT:
                newX = circle.getCenterX() - delta;
                if (newX >= circle.getRadius()) {                       // Ak kruh nevyjde von zo sceny, posun ho  
                    circle.setCenterX(newX);
                } else {                                                // V opacnom pripade zmen smer o 180 stupnov
                    this.moveDirection = MoveDirection.RIGHT;
                }
                break;
            case RIGHT:
                newX = circle.getCenterX() + delta;
                if (newX <= scene.getWidth() - circle.getRadius()) {    // Ak kruh nevyjde von zo sceny, posun ho
                    circle.setCenterX(newX);
                } else {                                                // V opacnom pripade zmen smer o 180 stupnov
                    this.moveDirection = MoveDirection.LEFT;
                }
                break;
        }
    }

    private Color randomColour(Random random) {
        return Color.color(random.nextDouble(), random.nextDouble(), random.nextDouble());
    }

    @Override
    public void start(Stage primaryStage) {
        Pane pane = new Pane();

        Scene scene = new Scene(pane, 400, 400);

        Random random = new Random();

        double radius = 20;                                                            // Fixny polomer kruhu
        double x = radius + (random.nextDouble() * (scene.getWidth() - 2 * radius));   // Nahodna pociatocna x-ova suradnica kruhu
        double y = radius + (random.nextDouble() * (scene.getHeight() - 2 * radius));  // Nahodna pociatocna y-ova suradnica kruhu 

        Circle circle = new Circle(x , y, radius);                                     // Vytvorenie kruhu s danymi parametrami 
        pane.getChildren().add(circle);
        circle.setFill(randomColour(random));

        moveDirection = MoveDirection.values()[random.nextInt(4)];       // Nahodne zvoleny pociatocny smer pohybu

        circle.requestFocus();                                           // Kruh dostane fokus, aby mohol reagovat na klavesnicu
        circle.setOnKeyPressed(event -> {                                // Nastavime reakciu kruhu na stlacenie klavesy
            switch (event.getCode()) {
                case UP:                                                 // Ak bola stlacena niektora zo sipok, zmenime podla nej smer 
                    moveDirection = MoveDirection.UP;
                    break;
                case RIGHT:
                    moveDirection = MoveDirection.RIGHT;
                    break;
                case DOWN:
                    moveDirection = MoveDirection.DOWN;
                    break;
                case LEFT:
                    moveDirection = MoveDirection.LEFT;
                    break;
            }
        });

        AnimationTimer animationTimer = new AnimationTimer() {  // Vytvorenie casovaca
            private long lastMoveTime = 0;                      // Casova peciatka posledneho pohybu kruhu 
            private long lastColourChangeTime = 0;               // Casova peciatka poslednej zmeny farby kruhu

            @Override
            public void handle(long now) {
                // Ak bol kruh naposledy posunuty pred viac ako 20 milisekundami, posun ho o 5 pixelov  
                if (now - lastMoveTime >= 20000000) {
                    moveCircle(scene, circle, moveDirection, 5);
                    lastMoveTime = now;
                }

                // Ak sa farba kruhu naposledy zmenila pred viac ako 500 milisekundami, zmen ju nahodne 
                if (now - lastColourChangeTime >= 500000000) {
                    circle.setFill(randomColour(random));
                    lastColourChangeTime = now;
                }
            }
        };
        animationTimer.start();                                    // Spusti casovac 

        primaryStage.setScene(scene);
        primaryStage.setTitle("Pohyblivý kruh");
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}
</syntaxhighlight>

== Odkazy ==

* [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/doc-files/cssref.html Dokumentácia k JavaFX CSS štýlom.]
=Riešenia testu č. 5=
== Úloha č. 1 ==

<syntaxhighlight lang="java">
btnLarger.setOnAction(event -> {
    circle.setRadius(circle.getRadius() + 10);
    if (circle.getRadius() == 100) {
        btnLarger.setDisable(true);
    }
    if (circle.getRadius() == 20) {
        btnSmaller.setDisable(false);
    }
});

btnSmaller.setOnAction(event -> {
    circle.setRadius(circle.getRadius() - 10);
    if (circle.getRadius() == 10) {
        btnSmaller.setDisable(true);
    }
    if (circle.getRadius() == 90) {
        btnLarger.setDisable(false);
    }
});
</syntaxhighlight>

== Úloha č. 2 ==

<syntaxhighlight lang="java">
public static Node<Boolean> createBooleanExpressionTree() {
    return new UnaryNode<>(a -> !a,
            new BinaryNode<>((a, b) -> a && b,
                    new NullaryNode<>(true),
                    new BinaryNode<>((a, b) -> a || b, new NullaryNode<>(false), new NullaryNode<>(true))));
}

public static Node<Integer> createArithmeticExpressionTree(int a, int n) {
    if (n == 1) {
        return new NullaryNode<>(a);
    } else {
        return new BinaryNode<>((x, y) -> x + y,
                createArithmeticExpressionTree(a, 1),
                createArithmeticExpressionTree(a, n - 1));
    }
}
</syntaxhighlight>

== Úloha č. 3 ==

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

public class CommonTopologicalOrder {

    /* Metoda z prednasky: */
    public static List<Integer> topologicalSort(Graph g) {
        /* Inicializacia: */
        int n = g.getNumberOfVertices();
        List<Integer> edgesFromUnprocessedVertices = new ArrayList<>();
        for (int v = 0; v <= n - 1; v++) {
            edgesFromUnprocessedVertices.add(0);
        }
        for (int v = 0; v <= n - 1; v++) {
            for (int successor : g.outgoingEdgesDestinations(v)) {
                edgesFromUnprocessedVertices.set(successor, edgesFromUnprocessedVertices.get(successor) + 1);
            }
        }
        Queue<Integer> ready = new LinkedList<>();
        for (int v = 0; v <= n - 1; v++) {
            if (edgesFromUnprocessedVertices.get(v) == 0) {
                ready.add(v);
            }
        }
        List<Integer> result = new LinkedList<>();

        /* Samotne topologicke triedenie: */
        while (!ready.isEmpty()) {
            int vertex = ready.remove();
            result.add(vertex);
            for (int successor : g.outgoingEdgesDestinations(vertex)) {
                edgesFromUnprocessedVertices.set(successor, edgesFromUnprocessedVertices.get(successor) - 1);
                if (edgesFromUnprocessedVertices.get(successor) == 0) {
                    ready.add(successor);
                }
            }
        }

        if (result.size() == n) {
            return result;
        } else {
            return null;
        }
    }

    public static List<Integer> commonTopologicalOrder(Graph g1, Graph g2) {
        if (g1.getNumberOfVertices() != g2.getNumberOfVertices()) {
            throw new IllegalArgumentException();
        }
        int n = g1.getNumberOfVertices();
        List<Edge> edges = new ArrayList<>();
        for (int u = 0; u <= n - 1; u++) {
            for (int v : g1.outgoingEdgesDestinations(u)) {
                edges.add(new Edge(u, v));
            }
            for (int v : g2.outgoingEdgesDestinations(u)) {
                edges.add(new Edge(u, v));
            }
        }
        Graph g = new SuccessorListsGraph(n, edges);
        return topologicalSort(g);
    }
}
</syntaxhighlight>
=Letný semester, prednáška č. 12=
== Oznamy ==

* Počas stredajších cvičení bude prebiehať prvý náhradný test. Okrem toho budú zverejnené ďalšie nebodované úlohy na JavaFX.
* Piatu domácu úlohu treba odovzdať ''do pondelka 10. mája, 9:00'' (čiže najneskôr do začiatku trinástej prednášky).

== Zložitejšie ovládacie prvky a aplikácie s viacerými oknami: jednoduchý textový editor ==

Cieľom tejto a sčasti aj nasledujúcej prednášky je demonštrovať použitie niektorých zložitejších ovládacích prvkov v JavaFX (ako napríklad [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/Menu.html <tt>Menu</tt>], [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/RadioButton.html <tt>RadioButton</tt>], či [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/ListView.html <tt>ListView</tt>]) a štandardných dialógov ([https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/Alert.html <tt>Alert</tt>] resp. [https://openjfx.io/javadoc/15/javafx.graphics/javafx/stage/FileChooser.html <tt>FileChooser</tt>]), tvorbu aplikácií s viacerými oknami, ako aj mechanizmus tzv. vlastností.

Urobíme tak na ukážkovej aplikácii (opäť až priveľmi) jednoduchého textového editora zvládajúceho nasledujúce úkony:
* Vytvorenie prázdneho textového dokumentu a jeho následná modifikácia.
* Vytvorenie textového dokumentu pozostávajúceho z nejakého fixného počtu náhodných cifier (nezmyselná funkcionalita slúžiaca len na ukážku možností triedy <tt>Menu</tt>).
* Načítanie textu z používateľom zvoleného textového súboru (v našom prípade budeme predpokladať kódovanie UTF-8).
* Uloženie textu do súboru.
* V prípade požiadavky na zatvorenie neuloženého súboru výzva na jeho uloženie.
* Do určitej miery aj zmena fontu, ktorým sa text vypisuje.

=== Základ aplikácie ===

Ako koreňovú oblasť hlavného okna aplikácie zvolíme inštanciu triedy [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/layout/BorderPane.html <tt>BorderPane</tt>], s ktorou sme sa stretli už minule. Vzhľadom na o niečo väčší rozsah našej aplikácie sa navyše zdá rozumné nepracovať výhradne s lokálnymi premennými metódy <tt>start</tt>, ale dôležitejšie ovládacie prvky uchovávať ako premenné inštancie samotnej hlavnej triedy <tt>Editor</tt>, čo umožňí ich neskoršiu modifikáciu z rôznych pomocných metód. Takto si okrem iného budeme uchovávať aj referenciu <tt>primaryStage</tt> na hlavné okno aplikácie.

Základ programu tak môže vyzerať napríklad nasledovne.

<syntaxhighlight lang="java">
package editor;

import javafx.application.*;
import javafx.stage.*;
import javafx.scene.*;
import javafx.scene.layout.*;
import javafx.scene.control.*;

public class Editor extends Application {

    private Stage primaryStage;

    public void start(Stage primaryStage) {
        this.primaryStage = primaryStage;

        BorderPane borderPane = new BorderPane();
        Scene scene = new Scene(borderPane);

        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}
</syntaxhighlight>

Predpokladajme, že titulok hlavného okna má obsahovať text <tt>Textový editor</tt>, za ktorým v zátvorke nasleduje názov momentálne otvoreného súboru (alebo informácia o tom, že dokument nie je uložený v žiadnom súbore). Za zátvorkou sa navyše bude zobrazovať znak <tt>*</tt> v prípade, že sa obsah dokumentu od jeho posledného uloženia zmenil. 

V danom momente otvorený súbor si budeme pamätať v premennej <tt>openedFile</tt>; v prípade, že nie je otvorený žiaden súbor, bude obsahom tejto premennej referencia <tt>null</tt>. Premenná <tt>openedFileChanged</tt> bude rovná <tt>true</tt> práve vtedy, keď od posledného uloženia dokumentu došlo k jeho zmene alebo keď dokument nie je uložený v žiadnom súbore. Metóda <tt>updateOpenedFileInformation</tt> dostane dvojicu premenných s rovnakým významom a nastaví podľa nich premenné <tt>openedFile</tt> a <tt>openedFileChanged</tt>; vhodným spôsobom pritom upraví aj titulok hlavného okna. Z metódy <tt>start</tt> budeme volať <tt>updateOpenedFileInformation(null, true)</tt>, keďže po spustení aplikácie nebude dokument uložený v žiadnom súbore.

<syntaxhighlight lang="java">
// ...

import java.io.*;

// ...

public class Editor extends Application {

    private File openedFile; 
    private boolean openedFileChanged; 
    
    // ...
    
    private void updateOpenedFileInformation(File file, boolean hasChanged) {
        openedFile = file;
        openedFileChanged = hasChanged;
        updatePrimaryStageTitle();
    }

    private void updatePrimaryStageTitle() {
        StringBuilder title = new StringBuilder("Textový editor (");
        if (openedFile == null) {
            title.append("neuložené v žiadnom súbore");
        } else {
            title.append(openedFile.getName());
        }
        title.append(")");
        if (openedFileChanged) {
            title.append("*");
        }
        primaryStage.setTitle(title.toString());
    }
    
    @Override
    public void start(Stage primaryStage) {
        // ...

        updateOpenedFileInformation(null, true);
        
        // ... 
    }
}
</syntaxhighlight>

=== Ovládací prvok <tt>TextArea</tt> ===

Môžeme pokračovať pridaním kľúčového ovládacieho prvku našej aplikácie &ndash; priestoru na písanie samotného textu. Takýto ovládací prvok má v JavaFX názov [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/TextArea.html <tt>TextArea</tt>] a my inštanciu tejto triedy zvolíme za stredovú časť koreňovej oblasti <tt>border</tt>.

Podobne ako vyššie budeme referenciu <tt>textArea</tt> na prvok typu <tt>TextArea</tt> uchovávať ako premennú triedy <tt>Editor</tt>. Navyše si v premenných triedy <tt>Editor</tt> budeme pamätať aj kľúčové atribúty fontu, ktoré vhodne inicializujeme. Na font použitý v priestore <tt>textArea</tt> tieto atribúty aplikujeme v pomocnej metóde <tt>applyFont</tt>, ktorú zavoláme hneď po inicializácii premennej <tt>textArea</tt>.

<syntaxhighlight lang="java">
// ...

import javafx.scene.text.*;
import javafx.geometry.*;

// ...

public class Editor extends Application {
    // ...

    private TextArea textArea;
    
    private String fontFamily = "Tahoma";
    private FontWeight fontWeight = FontWeight.NORMAL;
    private FontPosture fontPosture = FontPosture.REGULAR;
    private double fontSize = 16;

    // ...

    private void applyFont() {
        textArea.setFont(Font.font(fontFamily, fontWeight, fontPosture, fontSize));
    }

    // ...
    
    @Override
    public void start(Stage primaryStage) {
        // ...

        textArea = new TextArea();
        borderPane.setCenter(textArea);
        textArea.setPadding(new Insets(5, 5, 5, 5));
        textArea.setPrefWidth(1000);
        textArea.setPrefHeight(700);
        applyFont();

        // ... 
    }
}
</syntaxhighlight>

=== Vlastnosti a spracovanie ich zmeny ===

Chceli by sme teraz pomocou metódy <tt>updateOpenedFileInformation</tt> prestaviť premennú <tt>openedFileChanged</tt> na <tt>true</tt> zakaždým, keď sa v textovom poli udeje nejaká zmena (viditeľný efekt to bude mať až po implementácii ukladania do súboru; po vhodných ''dočasných'' zmenách v našom programe ale môžeme funkčnosť nasledujúceho kódu testovať už teraz).

To znamená: zakaždým, keď sa zmení obsah priestoru <tt>textArea</tt>, potrebujeme vykonať nasledujúcu metódu:
<syntaxhighlight lang="java">
private void handleTextAreaChange() {
    if (!openedFileChanged) {
        updateOpenedFileInformation(openedFile, true);
    }
}
</syntaxhighlight>

Aby sme takúto akciu vedeli vykonať po každej zmene textového obsahu priestoru <tt>textArea</tt>, využijeme mechanizmus takzvaných ''vlastností''. Pod ''vlastnosťou'' sa v JavaFX rozumie trieda implementujúca generické rozhranie [https://openjfx.io/javadoc/15/javafx.base/javafx/beans/property/Property.html <tt>Property<T></tt>] a možno si ju predstaviť ako &bdquo;značne pokročilý obal pre nejakú hodnotu typu <tt>T</tt>&rdquo;. Rozhranie <tt>Property<T></tt> je rozšírením rozhrania [https://openjfx.io/javadoc/15/javafx.base/javafx/beans/value/ObservableValue.html <tt>ObservableValue<T></tt>] reprezentujúceho hodnoty typu <tt>T</tt>, ktorých zmeny možno v určitom presne definovanom zmysle sledovať.

Podobne ako sme k ovládacím prvkom pridávali spracúvateľov udalostí, možno k vlastnostiam a ďalším inštanciám rozhrania <tt>ObservableValue<T></tt> pridávať &bdquo;spracúvateľov zmien&rdquo; volaných zakaždým, keď sa zmení nimi &bdquo;obalená&rdquo; hodnota. Týmito spracúvateľmi však teraz nebudú inštancie tried implementujúcich rozhranie <tt>EventHandler<T></tt>, ale inštancie tried implementujúcich rozhranie [https://openjfx.io/javadoc/15/javafx.base/javafx/beans/value/ChangeListener.html <tt>ChangeListener<T></tt>]. To vyžaduje implementáciu jedinej metódy
<syntaxhighlight lang="java">
void changed(ObservableValue<? extends T> observable, T oldValue, T newValue)
</syntaxhighlight>
ktorá sa vykoná pri zmene hodnoty &bdquo;obalenej&rdquo; inštanciou <tt>observable</tt> z <tt>oldValue</tt> na <tt>newValue</tt>. Ide pritom o funkcionálne rozhranie, takže na jeho implementáciu možno použiť aj lambda výrazy. Registráciu inštancie rozhrania <tt>ChangeListener<T></tt> ako &bdquo;spracúvateľa zmeny&rdquo; pre inštanciu <tt>observable</tt> rozhrania <tt>ObservableValue<T></tt> vykonáme pomocou metódy <tt>observable.addListener</tt>.

Vráťme sa teraz k nášmu textovému editoru: textový obsah priestoru <tt>textArea</tt> je reprezentovaný ako vlastnosť, ktorú môžeme získať volaním metódy <tt>textArea.textProperty()</tt>. Ide tu o inštanciu triedy [https://openjfx.io/javadoc/15/javafx.base/javafx/beans/property/StringProperty.html <tt>StringProperty</tt>] implementujúcej rozhranie <tt>Property<String></tt>. Môžeme tak pre ňu zaregistrovať &bdquo;spracúvateľa zmien&rdquo; pomocou metódy <tt>addListener</tt>, ktorej jediným argumentom bude inštancia takéhoto spracúvateľa. To možno realizovať pomocou anonymnej triedy 
<syntaxhighlight lang="java">
import javafx.beans.value.*;

// ...

public void start(Stage primaryStage) {
    // ...

    textArea.textProperty().addListener(new ChangeListener<>() {
        @Override
        public void changed(ObservableValue<? extends String> observable, String oldValue, String newValue) {
            handleTextAreaChange();
        }
    });

    // ...
}
</syntaxhighlight>
alebo alternatívne prostredníctvom lambda výrazu
<syntaxhighlight lang="java">
public void start(Stage primaryStage) {
    // ...

    textArea.textProperty().addListener((observable, oldValue, newValue) -> handleTextAreaChange());

    // ...
}
</syntaxhighlight>
''Poznámky'':
* Textový obsah priestoru typu <tt>TextArea</tt> je v JavaFX iba jednou z obrovského množstva vlastností, na ktorých zmenu možno reagovať. Ovládacie prvky typicky ponúkajú veľké množstvo vlastností, o ktorých sa možno dočítať v dokumentácii (ako príklady uveďme napríklad text alebo font tlačidla resp. textového popisku, rozmery okna, atď.).
* V prípade, že nejaký ovládací prvok ponúka vlastnosť, ku ktorej sa pristupuje metódou <tt>cokolvekProperty</tt>, typicky ponúka aj metódu <tt>getCokolvek</tt>, ktorá vráti hodnotu obalenú danou vlastnosťou. V prípade, že možno meniť hodnotu danej vlastnosti, môže byť k dispozícii aj metóda <tt>setCokolvek</tt>.
* Vlastnosti navyše možno medzi sebou aj vzájomne previazať (napríklad veľkosť kruhu vykresleného na scéne možno previazať s veľkosťou okna tak, aby bol polomer kruhu rovný tretine menšieho z rozmerov okna). S príkladom previazania vlastností sa stretneme nižšie.

=== Hlavné ponuky (<tt>MenuItem</tt>, <tt>Menu</tt> a <tt>MenuBar</tt>) ===

Kľúčovou súčasťou mnohých aplikácií bývajú hlavné ponuky (menu). V JavaFX ich do aplikácie možno pridať nasledujúcim spôsobom:
* Do hlavného okna aplikácie sa umiestní ovládací prvok typu [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/MenuBar.html <tt>MenuBar</tt>], ktorý reprezentuje priestor, v ktorom sa budú jednotlivé ponuky zobrazovať. Každý <tt>MenuBar</tt> si udržiava zoznam ponúk v ňom umiestnených.
* Každá ponuka (ako napríklad <tt>Súbor</tt>, <tt>Formát</tt>, ...) je reprezentovaná inštanciou triedy [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/Menu.html <tt>Menu</tt>], ktorá si okrem iného pamätá zoznam všetkých položiek danej ponuky.  
* Položka ponuky je reprezentovaná inštanciou triedy [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/MenuItem.html <tt>MenuItem</tt>]. Každej položke možno napríklad pomocou metódy <tt>setOnAction</tt> priradiť akciu, ktorá sa má vykonať po jej zvolení používateľom.
* Trieda <tt>Menu</tt> je podtriedou triedy <tt>MenuItem</tt>, z čoho okrem iného vyplýva, že položkou ponuky môže byť aj ďalšia podponuka.
* Špeciálne položky ponúk sú reprezentované inštanciami tried [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/CheckMenuItem.html <tt>CheckMenuItem</tt>] (takúto položku ponuky možno zvolením zaškrtnúť resp. odškrtnúť) a [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/SeparatorMenuItem.html <tt>SeparatorMenuItem</tt>] (reprezentuje vodorovnú čiaru na vizuálne oddelenie častí ponuky).

V našej aplikácii teraz vytvoríme <tt>MenuBar</tt> s dvojicou ponúk <tt>Súbor</tt> a <tt>Formát</tt> s nasledujúcou štruktúrou.
<pre>
Súbor (Menu)                                    Formát (Menu)
|                                               |
|- Nový (Menu) --- Prázdny súbor (MenuItem)     |- Písmo... (MenuItem)
|               |                               |  
|               |- Náhodné cifry (MenuItem)     |- Zalamovať riadky (CheckMenuItem)
|  
|- Otvoriť... (MenuItem)
|
|- Uložiť (MenuItem)
|
|- Uložiť ako... (MenuItem) 
|
|--------------- (SeparatorMenuItem)
|
|- Koniec (MenuItem)               
</pre>

Vytvorenie takýchto ponúk realizujeme nasledujúcim kódom (v ktorom ponuky a ich položky reprezentujeme ako premenné triedy <tt>Editor</tt>, kým <tt>MenuBar</tt> vytvárame iba lokálne v metóde <tt>start</tt>).

<syntaxhighlight lang="java">
// ...

public class Editor extends Application {
    // ...

    private Menu mFile;
    private Menu mFileNew;
    private MenuItem miFileNewEmpty;
    private MenuItem miFileNewRandom;
    private MenuItem miFileOpen;
    private MenuItem miFileSave;
    private MenuItem miFileSaveAs;
    private MenuItem miFileExit;
    private Menu mFormat;
    private MenuItem miFormatFont;
    private CheckMenuItem miFormatWrap;   

    // ...

    @Override
    public void start(Stage primaryStage) {   
        // ...

        MenuBar menuBar = new MenuBar();
        borderPane.setTop(menuBar);
        
        mFile = new Menu("Súbor");
        mFileNew = new Menu("Nový");
        miFileNewEmpty = new MenuItem("Prázdny súbor");
        miFileNewRandom = new MenuItem("Náhodné cifry");
        mFileNew.getItems().addAll(miFileNewEmpty, miFileNewRandom);
        miFileOpen = new MenuItem("Otvoriť...");
        miFileSave = new MenuItem("Uložiť");
        miFileSaveAs = new MenuItem("Uložiť ako...");
        miFileExit = new MenuItem("Koniec");
        mFile.getItems().addAll(mFileNew, miFileOpen, miFileSave, miFileSaveAs, new SeparatorMenuItem(), miFileExit); 
        
        mFormat = new Menu("Formát");
        miFormatFont = new MenuItem("Písmo...");
        miFormatWrap = new CheckMenuItem("Zalamovať riadky");
        miFormatWrap.setSelected(false);                        // Nie je nutne, kedze false je tu vychodzia hodnota
        mFormat.getItems().addAll(miFormatFont, miFormatWrap);
        
        menuBar.getMenus().addAll(mFile, mFormat);   

        // ...
    } 
}
</syntaxhighlight>

K dôležitejším položkám môžeme priradiť aj klávesové skratky.
<syntaxhighlight lang="java">
// ...

import javafx.scene.input.*;

// ...

@Override
public void start(Stage primaryStage) {
    // ...

    miFileNewEmpty.setAccelerator(new KeyCodeCombination(KeyCode.N, KeyCombination.CONTROL_DOWN)); // Ctrl + N
    miFileOpen.setAccelerator(new KeyCodeCombination(KeyCode.O, KeyCombination.CONTROL_DOWN));     // Ctrl + O
    miFileSave.setAccelerator(new KeyCodeCombination(KeyCode.S, KeyCombination.CONTROL_DOWN));     // Ctrl + S

    // ...
}
</syntaxhighlight>

[[Image:Textovyeditor1.png|thumb|Vzhľad aplikácie po pridaní panelu s ponukami.|400px]]

V rámci metódy <tt>updateOpenedFileInformation</tt> ešte môžeme zabezpečiť, aby položka <tt>miFileSave</tt> bola aktívna práve vtedy, keď má argument <tt>hasChanged</tt> hodnotu <tt>true</tt> (v opačnom prípade nie je čo ukladať).

<syntaxhighlight lang="java">
private void updateOpenedFileInformation(File file, boolean hasChanged) { 
    // ...

    miFileSave.setDisable(!hasChanged);

    // ...
}
</syntaxhighlight>

Výsledný vzhľad aplikácie je na obrázku vpravo.

=== Kontextové ponuky (<tt>ContextMenu</tt>) ===

Ďalším užitočným typom ponúk sú kontextové (resp. vyskakovacie) ponuky, ktoré sa zobrazia po kliknutí na nejaký ovládací prvok pravou myšou. Všimnime si, že <tt>TextArea</tt> už prichádza s prednastavenou kontextovou ponukou. Chceli by sme teraz túto ponuku nahradiť vlastnou, obsahujúcou rovnaké dve položky ako ponuka <tt>mFormat</tt> (budeme však musieť tieto položky vytvárať nanovo, pretože každá položka môže patriť iba do jedinej ponuky). 

Jediný rozdiel oproti tvorbe hlavnej ponuky bude spočívať v použití inštancie triedy [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/ContextMenu.html <tt>ContextMenu</tt>]. Tú následne pomocou metódy <tt>setContextMenu</tt> priradíme ako kontextovú ponuku ovládaciemu prvku <tt>textArea</tt>. Výsledný vzhľad kontextovej ponuky je na obrázku vpravo.

[[Image:Textovyeditor2.png|thumb|Výsledný vzhľad kontextovej ponuky.|250px]]

<syntaxhighlight lang="java">
public class Editor extends Application {
    // ...
    
    private ContextMenu contextMenu;
    private MenuItem cmiFormatFont;
    private CheckMenuItem cmiFormatWrap;

    // ...

    @Override
    public void start(Stage primaryStage) {
        // ...       
        
        contextMenu = new ContextMenu();
        textArea.setContextMenu(contextMenu);
        cmiFormatFont = new MenuItem("Formát písma...");
        cmiFormatWrap = new CheckMenuItem("Zalamovať riadky");
        cmiFormatWrap.setSelected(false);
        contextMenu.getItems().addAll(cmiFormatFont, cmiFormatWrap);

        // ...
    } 
}
</syntaxhighlight>

=== Priradenie udalostí k jednotlivým položkám ponúk ===

Môžeme teraz k jednotlivým položkám ponúk (okrem položiek typu <tt>CheckMenuItem</tt>) priradiť ich funkcionalitu, ktorá bude zatiaľ pozostávať z volania metód s takmer prázdnym telom. Všetky tieto metódy budú mať návratový typ <tt>boolean</tt>, pričom výstupná hodnota bude hovoriť o tom, či sa zamýšľaná akcia podarila alebo nie &ndash; táto črta sa nám zíde neskôr.

<syntaxhighlight lang="java">
public class Editor extends Application {
    // ...
    
    private boolean newEmptyAction() {
        return true;  // Neskor nahradime zmysluplnym telom metody
    }
    
    private boolean newRandomAction() {
        return true;
    }
    
    private boolean openAction() {
        return true;
    }
    
    private boolean saveAction() {
        return true;
    }    
    
    private boolean saveAsAction() {
        return true;
    }
    
    private boolean exitAction() {
        return true;
    }    
    
    private boolean fontAction() {
        return true;
    }

    // ...

    @Override
    public void start(Stage primaryStage) {
        // ...

        miFileNewEmpty.setOnAction(event -> newEmptyAction());
        miFileNewRandom.setOnAction(event -> newRandomAction());
        miFileOpen.setOnAction(event -> openAction());
        miFileSave.setOnAction(event -> saveAction());
        miFileSaveAs.setOnAction(event -> saveAsAction());
        miFileExit.setOnAction(event -> exitAction());
        miFormatFont.setOnAction(event -> fontAction());

        // ...

        cmiFormatFont.setOnAction(event -> fontAction());

        // ...
    }
}
</syntaxhighlight>

=== Previazanie vlastností ===

Na implementáciu funkcionality položiek <tt>miFormatWrap</tt> a <tt>cmiFormatWrap</tt> použijeme ďalšiu črtu vlastností &ndash; možnosť ich (obojstranného) previazania. Pri zmene niektorej z vlastností sa automaticky zmenia aj všetky vlastnosti s ňou previazané. V našom prípade navzájom previažeme vlastnosti hovoriace o zaškrtnutí položiek <tt>miFormatWrap</tt> a <tt>cmiFormatWrap</tt> a tiež vlastnosť hovoriacu o zalamovaní riadkov v textovom priestore <tt>textArea</tt>.
<syntaxhighlight lang="java">
@Override
public void start(Stage primaryStage) {
    // ...

    miFormatWrap.selectedProperty().bindBidirectional(cmiFormatWrap.selectedProperty());
    miFormatWrap.selectedProperty().bindBidirectional(textArea.wrapTextProperty());

    // ...
}
</syntaxhighlight>

* Previazanie vlastností možno využiť aj v rôzličných ďalších situáciách. Užitočným cvičením môže byť napísať aplikáciu, v ktorej hlavnom okne je vykreslený kruh, ktorého polomer ostáva rovný jednej tretine menšieho z rozmerov okna (a to aj v prípade, že sa rozmery okna zmenia). Pri tejto úlohe sa zídu metódy triedy [https://openjfx.io/javadoc/15/javafx.base/javafx/beans/binding/Bindings.html <tt>Bindings</tt>].
* Viac sa o vlastnostiach a ich previazaní možno dočítať napríklad v [https://docs.oracle.com/javase/8/javafx/properties-binding-tutorial/binding.htm tomto tutoriáli].

=== Jednoduché dialógy (<tt>Alert</tt>) ===

Naším najbližším cieľom teraz bude implementácia metód <tt>newEmptyAction</tt>, <tt>newRandomAction</tt> a <tt>exitAction</tt>. Spoločnou črtou týchto akcií je, že vyžadujú zatvorenie práve otvoreného dokumentu. V takom prípade by sme ale chceli &ndash; pokiaľ boli v práve otvorenom dokumente vykonané nejaké neuložené zmeny &ndash; zobraziť výzvu na uloženie dokumentu ako na obrázku nižšie.

<gallery mode="packed" widths="400px" heights="150px">
Image:Textovyeditor3.png|Výzva na uloženie dokumentu.
</gallery>

Na zobrazenie takejto výzvy využijeme jeden z jednoduchých štandardných dialógov &ndash; inštanciu triedy [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/Alert.html <tt>Alert</tt>].
<syntaxhighlight lang="java">
// ...

import java.util.*;                                                   // Kvoli triede Optional

// ...

public class Editor extends Application {

    // ...

    private boolean saveBeforeClosingAlert() {
        if (openedFileChanged) {                                      // Ak dokument nie je ulozeny
            Alert alert = new Alert(Alert.AlertType.CONFIRMATION);    // Vytvor dialog typu Alert, variant CONFIRMATION
            alert.setTitle("Uložiť súbor?");                          // Nastav titulok dialogu
            alert.setHeaderText(null);                                // Dialog nebude mat ziaden "nadpis"
            alert.setContentText("Uložiť zmeny v súbore?");           // Nastav text dialogu

            ButtonType buttonTypeYes = new ButtonType("Áno");         // Vytvor instancie reprezentujuce typy tlacidiel
            ButtonType buttonTypeNo = new ButtonType("Nie");

            // Vdaka druhemu argumentu sa bude ako tlacidlo "Zrusit" spravat aj "krizik" v dialogovom okne vpravo hore:
            ButtonType buttonTypeCancel = new ButtonType("Zrušiť", ButtonBar.ButtonData.CANCEL_CLOSE);

            alert.getButtonTypes().setAll(buttonTypeYes, buttonTypeNo, buttonTypeCancel); // Nastav typy tlacidiel

            Optional<ButtonType> result = alert.showAndWait();        // Zobraz dialog a cakaj, kym sa zavrie
            if (result.get() == buttonTypeYes) {                      // Pokracuj podla typu stlaceneho tlacidla
                return saveAction();
            } else if (result.get() == buttonTypeNo) {
                return true;
            } else {
                return false;
            }
        } else {                                                      // Ak je dokument ulozeny, netreba robit nic
            return true;
        }
    }
    
    // ...
}
</syntaxhighlight>
Dialóg typu <tt>Alert</tt> by ideálne mal obsahovať práve jedno tlačidlo, ktorého &bdquo;dáta&rdquo; sú nastavené na <tt>CANCEL_CLOSE</tt>. V opačnom prípade sa &bdquo;krížik&rdquo; v pravom hornom rohu dialógového okna nemusí správať korektne (v niektorých prípadoch sa dialógové okno po kliknutí naň dokonca ani nemusí zavrieť). Toto obmedzenie sa ale dá eliminovať ďalšími nastaveniami dialógu.

Môžeme teraz pristúpiť k implementácii spomínaných troch akcií.
<syntaxhighlight lang="java">
public class Editor extends Application {
    // ...

    private final int N = 1000;  // V metode newRandomAction budeme generovat N riadkov o N nahodnych cifrach

    // ...

    private boolean newEmptyAction() {               
        if (saveBeforeClosingAlert()) {               // Pokracuj len ak sa podarilo zavriet dokument  
            updateOpenedFileInformation(null, true);  // Nebude teraz otvoreny ziaden subor...
            textArea.clear();                         // Zmazeme obsah textoveho priestoru textArea
            return true;
        } else {
            return false;
        }
    }

    private boolean newRandomAction() {
        if (newEmptyAction()) {                           // Skus vytvorit novy subor a pokracuj len, ak sa to podarilo
            StringBuilder builder = new StringBuilder();  // Vygeneruj retazec o N x N nahodnych cifrach
            Random random = new Random();
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    builder.append(random.nextInt(10));
                }
                builder.append(System.lineSeparator());
            }
            textArea.setText(builder.toString());         // Vypis vygenerovany retazec do textoveho priestoru textArea
            return true;
        } else {
            return false;
        }
    }

    private boolean exitAction() {
        if (saveBeforeClosingAlert()) {   // Pokracuj len ak sa podarilo zavriet dokument         
            Platform.exit();              // Ukonci aplikaciu
            return true;
        } else {
            return false;
        }
    }    
}
</syntaxhighlight>

=== Ďalšie typy jednoduchých dialógov ===

V JavaFX možno využívať aj ďalšie preddefinované jednoduché dialógy &ndash; od dialógu <tt>Alert</tt> s odlišným <tt>AlertType</tt> až po dialógy ako [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/TextInputDialog.html <tt>TextInputDialog</tt>] alebo [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/ChoiceDialog.html <tt>ChoiceDialog</tt>].
* Viac sa o preddefinovaných jednoduchých dialógoch v JavaFX možno dočítať napríklad [https://code.makery.ch/blog/javafx-dialogs-official/ tu].

=== Zatvorenie hlavného okna aplikácie &bdquo;krížikom&rdquo; ===

Metódu <tt>exitAction()</tt>, ktorá sa vykoná zakaždým, keď používateľ zvolí v hlavnej ponuke možnosť <tt>Súbor --> Koniec</tt>, sme implementovali tak, aby sa najprv zobrazila prípadná výzva na uloženie súboru. Táto výzva pritom v niektorých prípadoch môže ukončeniu aplikácie aj zamedziť (napríklad keď používateľ klikne na tlačidlo <tt>Zrušiť</tt> alebo keď bude tlačidlom <tt>Zrušiť</tt> ukončený ukladací dialóg).

Ak ale používateľ aplikáciu zavrie kliknutím na &bdquo;krížik&rdquo; v pravom hornom rohu okna, aplikácia sa zavrie bez akejkoľvek ďalšej akcie. Chceli by sme pritom, aby sa vykonali rovnaké operácie, ako pri ukončení aplikácie pomocou položky hlavnej ponuky. To môžeme zariadiť nastavením spracúvateľa udalosti, ktorá vznikne pri požiadavke na zatvorenie okna. Ak túto udalosť v rámci jej spracovania skonzumujeme, zatvoreniu okna sa v konečnom dôsledku zamedzí.
<syntaxhighlight lang="java">
public class Editor extends Application {
    // ...

    private boolean handleStageCloseRequest(WindowEvent event) {
        if (saveBeforeClosingAlert()) {  // Ak sa podarilo zavriet subor
            return true;
        } else {                         // Ak sa nepodarilo zavriet subor ... 
            event.consume();             // ... nechceme ani zavriet okno 
            return false;
        }
    }

    // ...

    @Override
    public void start(Stage primaryStage) {
        // ...
        
        primaryStage.setOnCloseRequest(event -> handleStageCloseRequest(event));
    
        // ...
    }
}
</syntaxhighlight>

=== Otvárací a ukladací dialóg (<tt>FileChooser</tt>) ===

Implementujeme teraz kľúčovú funkcionalitu textového editora &ndash; metódy <tt>openAction</tt>, <tt>saveAction</tt> a <tt>saveAsAction</tt> realizujúce otváranie resp. ukladanie textových súborov.

Na výber súboru môžeme pri oboch typoch akcií využiť preddefinovaný dialóg [https://openjfx.io/javadoc/15/javafx.graphics/javafx/stage/FileChooser.html <tt>FileChooser</tt>].

<gallery mode="packed" widths="600px" heights="400px">
Image:Textovyeditor4.png|Možný vzhľad otváracieho dialógu typu <tt>FileChooser</tt>.
</gallery>

Pomocné metódy realizujúce výber súboru na otvorenie resp. uloženie môžu s jeho použitím vyzerať napríklad nasledovne.
<syntaxhighlight lang="java">
public class Editor extends Application {    
    // ...

    /**
     * Pomocna metoda, ktora vytvori dialog typu FileChooser a prednastavi niektore jeho vlastnosti.
     * @return Vytvoreny dialog typu FileChooser.
     */
    private FileChooser prepareFileChooser() {
        FileChooser fileChooser = new FileChooser();                                // Vytvorenie dialogoveho okna
        fileChooser.setInitialDirectory(new File(System.getProperty("user.dir")));  // Nastavenie vychodzieho adresara
        fileChooser.getExtensionFilters().addAll(                                   // Filtre na pripony
                new FileChooser.ExtensionFilter("Textové súbory (*.txt)", "*.txt"),
                new FileChooser.ExtensionFilter("Všetky súbory (*.*)", "*.*"));
        return fileChooser;
    }

    /**
     * Pomocna metoda realizujuca vyber suboru na otvorenie.
     * @return Vybrany subor alebo null v pripade, ze ziaden subor vybrany nebol.
     */
    private File chooseFileToOpen() {
        FileChooser fileChooser = prepareFileChooser();
        fileChooser.setTitle("Otvoriť");
        return fileChooser.showOpenDialog(primaryStage);
    }

    /**
     * Pomocna metoda realizujuca vyber suboru na ulozenie.
     * @return Vybrany subor alebo null v pripade, ze ziaden subor vybrany nebol.
     */
    private File chooseFileToSave() {
        FileChooser fileChooser = prepareFileChooser();
        fileChooser.setTitle("Uložiť");
        return fileChooser.showSaveDialog(primaryStage);
    }
    
    // ...
}
</syntaxhighlight>

Môžeme teraz pristúpiť k samotnej implementácii otváracích a ukladacích metód. Na čítanie a zápis do textového súboru použijeme statické metódy triedy [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/nio/file/Files.html <tt>Files</tt>] z balíka <tt>java.nio.file</tt>, ktoré načítajú kompletný obsah súboru do reťazca resp. zapíšu obsah reťazca do súboru. Takýto prístup síce nie je úplne vhodný pre veľmi veľké súbory, no na manipuláciu s nimi by bolo potrebné našu aplikáciu vylepšiť aj v iných ohľadoch &ndash; v prvom rade by sme v rámci ovládacieho prvku typu <tt>TextArea</tt> nemali uchovávať kompletný obsah textového súboru. Použijeme preto teraz spomenuté jednoduché riešenie, hoci rovnako dobre by sme mohli použiť napríklad aj <tt>BufferedReader</tt>. U všetkých textových súborov predpokladáme kódovanie UTF-8.
<syntaxhighlight lang="java">
// ...

import java.nio.file.*;
import java.nio.charset.*;

// ...

public class Editor extends Application {    
    // ...
    
    private String loadFromFile(File file) throws IOException {
        return Files.readString(Paths.get(file.getPath()));
    }

    private void writeToFile(File file, String s) throws IOException {
        Files.writeString(Paths.get(file.getPath()), s);
    }

    // ...

    private boolean openAction() {
        if (saveBeforeClosingAlert()) {                        // Ak sa podarilo zavriet dokument
            File file = chooseFileToOpen();                    // Vyber subor na otvorenie
            if (file != null) {                                // Ak bol nejaky subor vybrany ...
                try {
                    textArea.setText(loadFromFile(file));      // ... vypis jeho obsah do textArea
                    updateOpenedFileInformation(file, false);  // Aktualizuj informacie o otvorenom subore
                } catch (IOException e) {
                    System.err.println("Nieco sa pokazilo.");
                }
                return true;                                   
            } else {
                return false;
            }
        } else {
            return false;
        }
    }

    private boolean saveAction() {
        if (openedFile == null) {                                // Ak nebol otvoreny ziaden subor ... 
            return saveAsAction();                               // ... realizuj to iste ako pri "Ulozit ako"
        } else {                                                 // V opacnom pripade ...
            try {
                writeToFile(openedFile, textArea.getText());     // ... prepis aktualne otvoreny subor
                updateOpenedFileInformation(openedFile, false);  // Aktualizuj informacie o otvorenom subore
            } catch (IOException e) {
                System.err.println("Nieco sa pokazilo.");
            }
            return true;
        }
    }    
    
    private boolean saveAsAction() {
        File file = chooseFileToSave();                    // Vyber subor, do ktoreho sa ma ukladat
        if (file != null) {                                // Ak bol nejaky subor vybrany ...
            try {
                writeToFile(file, textArea.getText());     // ... zapis don obsah textArea
                updateOpenedFileInformation(file, false);  // Aktualizuj informacie o otvorenom subore
            } catch (IOException e) {
                System.err.println("Nieco sa pokazilo.");
            }
            return true;
        } else {
            return false;
        }
    }

    // ...
}
</syntaxhighlight>

Zvyšnú funkcionalitu aplikácie implementujeme nabudúce.
=Riešenia náhradného testu č. 1=
== Úloha č. 1 ==

<syntaxhighlight lang="java">
public static <T extends Comparable<T>> void retainLocalMaxima(List<T> list) {
    if (list == null || list.contains(null)) {
        throw new IllegalArgumentException();
    }
    ArrayList<Boolean> toRetain = new ArrayList<>();
    for (int i = 0; i <= list.size() - 1; i++) {
        T current = list.get(i);
        toRetain.add((i == 0 || current.compareTo(list.get(i - 1)) >= 0)
                && (i == list.size() - 1 || current.compareTo(list.get(i + 1)) >= 0));
    }
    int i = 0;
    for (boolean b : toRetain) {
        if (!b) {
            list.remove(i);
        } else {
            i++;
        }
    }
}
</syntaxhighlight>

== Úloha č. 2 ==

<syntaxhighlight lang="java">
public static int bridgeCount(UndirectedGraph g) {
    int n = g.getNumberOfVertices();
    int componentCount = (new Components(g)).getComponentCount();
    ArrayList<Edge> allEdges = new ArrayList<>();
    for (int u = 0; u <= n - 1; u++) {
        for (int v : g.outgoingEdgesDestinations(u)) {
            if (u <= v) {
                allEdges.add(new Edge(u, v));
            }
        }
    }
    int result = 0;
    for (int e = 0; e <= allEdges.size() - 1; e++) {
        ArrayList<Edge> edges = new ArrayList<>(allEdges);
        edges.remove(e);
        if (new Components(new AdjacencyListsUndirectedGraph(n, edges)).getComponentCount() > componentCount) {
            result++;
        }
    }
    return result;
}
</syntaxhighlight>

== Úloha č. 3 ==

<syntaxhighlight lang="java">
import java.util.*;
import java.util.function.*;

public class FilteredIterator<E> implements Iterator<E> {
    private Iterator<E> iterator;
    private Predicate<E> filter;
    private E next;

    public FilteredIterator(Iterable<E> iterable, Predicate<E> filter) {
        iterator = iterable.iterator();
        this.filter = filter;
        findNext();
    }

    private void findNext() {
        while (iterator.hasNext()) {
            next = iterator.next();
            if (filter.test(next)) {
                return;
            }
        }
        next = null;
    }

    @Override
    public boolean hasNext() {
        return next != null;
    }

    @Override
    public E next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        E result = next;
        findNext();
        return result;
    }
}
</syntaxhighlight>
=Letný semester, prednáška č. 13=
== Oznamy ==

* Počas stredajších cvičení bude prebiehať druhý náhradný test. Okrem toho budú zverejnené ďalšie nebodované úlohy na JavaFX.
* Nezabudnite sa prihlásiť na niektorý zo skúškových termínov najneskôr 24 hodín pred jeho začiatkom. Na skúške sú vítaní všetci, čo zo semestra získali aspoň 20 bodov (a majú tak šancu na úspešné absolvovanie predmetu).
* Jedna z úloh praktickej časti skúšky bude vždy zameraná na JavaFX (vrátane látky z poslednej prednášky).

== Jednoduchý textový editor: pokračovanie ==

=== Zatvorenie hlavného okna aplikácie &bdquo;krížikom&rdquo; ===

Metódu <tt>exitAction()</tt>, ktorá sa vykoná zakaždým, keď používateľ zvolí v hlavnej ponuke možnosť <tt>Súbor --> Koniec</tt>, sme implementovali tak, aby sa najprv zobrazila prípadná výzva na uloženie súboru. Táto výzva pritom v niektorých prípadoch môže ukončeniu aplikácie aj zamedziť (napríklad keď používateľ klikne na tlačidlo <tt>Zrušiť</tt> alebo keď bude tlačidlom <tt>Zrušiť</tt> ukončený ukladací dialóg).

Ak ale používateľ aplikáciu zavrie kliknutím na &bdquo;krížik&rdquo; v pravom hornom rohu okna, aplikácia sa zavrie bez akejkoľvek ďalšej akcie. Chceli by sme pritom, aby sa vykonali rovnaké operácie, ako pri ukončení aplikácie pomocou položky hlavnej ponuky. To môžeme zariadiť nastavením spracúvateľa udalosti, ktorá vznikne pri požiadavke na zatvorenie okna. Ak túto udalosť v rámci jej spracovania skonzumujeme, zatvoreniu okna sa v konečnom dôsledku zamedzí.
<syntaxhighlight lang="java">
public class Editor extends Application {
    // ...

    private boolean handleStageCloseRequest(WindowEvent event) {
        if (saveBeforeClosingAlert()) {  // Ak sa podarilo zavriet subor
            return true;
        } else {                         // Ak sa nepodarilo zavriet subor ... 
            event.consume();             // ... nechceme ani zavriet okno 
            return false;
        }
    }

    // ...

    @Override
    public void start(Stage primaryStage) {
        // ...
        
        primaryStage.setOnCloseRequest(event -> handleStageCloseRequest(event));
    
        // ...
    }
}
</syntaxhighlight>

=== Otvárací a ukladací dialóg (<tt>FileChooser</tt>) ===

Implementujeme teraz kľúčovú funkcionalitu textového editora &ndash; metódy <tt>openAction</tt>, <tt>saveAction</tt> a <tt>saveAsAction</tt> realizujúce otváranie resp. ukladanie textových súborov.

Na výber súboru môžeme pri oboch typoch akcií využiť preddefinovaný dialóg [https://openjfx.io/javadoc/15/javafx.graphics/javafx/stage/FileChooser.html <tt>FileChooser</tt>].

<gallery mode="packed" widths="600px" heights="400px">
Image:Textovyeditor4.png|Možný vzhľad otváracieho dialógu typu <tt>FileChooser</tt>.
</gallery>

Pomocné metódy realizujúce výber súboru na otvorenie resp. uloženie môžu s jeho použitím vyzerať napríklad nasledovne.
<syntaxhighlight lang="java">
public class Editor extends Application {    
    // ...

    /**
     * Pomocna metoda, ktora vytvori dialog typu FileChooser a prednastavi niektore jeho vlastnosti.
     * @return Vytvoreny dialog typu FileChooser.
     */
    private FileChooser prepareFileChooser() {
        FileChooser fileChooser = new FileChooser();                                // Vytvorenie dialogoveho okna
        fileChooser.setInitialDirectory(new File(System.getProperty("user.dir")));  // Nastavenie vychodzieho adresara
        fileChooser.getExtensionFilters().addAll(                                   // Filtre na pripony
                new FileChooser.ExtensionFilter("Textové súbory (*.txt)", "*.txt"),
                new FileChooser.ExtensionFilter("Všetky súbory (*.*)", "*.*"));
        return fileChooser;
    }

    /**
     * Pomocna metoda realizujuca vyber suboru na otvorenie.
     * @return Vybrany subor alebo null v pripade, ze ziaden subor vybrany nebol.
     */
    private File chooseFileToOpen() {
        FileChooser fileChooser = prepareFileChooser();
        fileChooser.setTitle("Otvoriť");
        return fileChooser.showOpenDialog(primaryStage);
    }

    /**
     * Pomocna metoda realizujuca vyber suboru na ulozenie.
     * @return Vybrany subor alebo null v pripade, ze ziaden subor vybrany nebol.
     */
    private File chooseFileToSave() {
        FileChooser fileChooser = prepareFileChooser();
        fileChooser.setTitle("Uložiť");
        return fileChooser.showSaveDialog(primaryStage);
    }
    
    // ...
}
</syntaxhighlight>

Môžeme teraz pristúpiť k samotnej implementácii otváracích a ukladacích metód. Na čítanie a zápis do textového súboru použijeme statické metódy triedy [https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/nio/file/Files.html <tt>Files</tt>] z balíka <tt>java.nio.file</tt>, ktoré načítajú kompletný obsah súboru do reťazca resp. zapíšu obsah reťazca do súboru. Takýto prístup síce nie je úplne vhodný pre veľmi veľké súbory, no na manipuláciu s nimi by bolo potrebné našu aplikáciu vylepšiť aj v iných ohľadoch &ndash; v prvom rade by sme v rámci ovládacieho prvku typu <tt>TextArea</tt> nemali uchovávať kompletný obsah textového súboru. Použijeme preto teraz spomenuté jednoduché riešenie, hoci rovnako dobre by sme mohli použiť napríklad aj <tt>BufferedReader</tt>. U všetkých textových súborov predpokladáme kódovanie UTF-8.
<syntaxhighlight lang="java">
// ...

import java.nio.file.*;
import java.nio.charset.*;

// ...

public class Editor extends Application {    
    // ...
    
    private String loadFromFile(File file) throws IOException {
        return Files.readString(Paths.get(file.getPath()));
    }

    private void writeToFile(File file, String s) throws IOException {
        Files.writeString(Paths.get(file.getPath()), s);
    }

    // ...

    private boolean openAction() {
        if (saveBeforeClosingAlert()) {                        // Ak sa podarilo zavriet dokument
            File file = chooseFileToOpen();                    // Vyber subor na otvorenie
            if (file != null) {                                // Ak bol nejaky subor vybrany ...
                try {
                    textArea.setText(loadFromFile(file));      // ... vypis jeho obsah do textArea
                    updateOpenedFileInformation(file, false);  // Aktualizuj informacie o otvorenom subore
                } catch (IOException e) {
                    System.err.println("Nieco sa pokazilo.");
                }
                return true;                                   
            } else {
                return false;
            }
        } else {
            return false;
        }
    }

    private boolean saveAction() {
        if (openedFile == null) {                                // Ak nebol otvoreny ziaden subor ... 
            return saveAsAction();                               // ... realizuj to iste ako pri "Ulozit ako"
        } else {                                                 // V opacnom pripade ...
            try {
                writeToFile(openedFile, textArea.getText());     // ... prepis aktualne otvoreny subor
                updateOpenedFileInformation(openedFile, false);  // Aktualizuj informacie o otvorenom subore
            } catch (IOException e) {
                System.err.println("Nieco sa pokazilo.");
            }
            return true;
        }
    }    
    
    private boolean saveAsAction() {
        File file = chooseFileToSave();                    // Vyber subor, do ktoreho sa ma ukladat
        if (file != null) {                                // Ak bol nejaky subor vybrany ...
            try {
                writeToFile(file, textArea.getText());     // ... zapis don obsah textArea
                updateOpenedFileInformation(file, false);  // Aktualizuj informacie o otvorenom subore
            } catch (IOException e) {
                System.err.println("Nieco sa pokazilo.");
            }
            return true;
        } else {
            return false;
        }
    }

    // ...
}
</syntaxhighlight>

=== Vlastné dialógy (aplikácie s viacerými oknami) ===

Na rozdiel od dialógov na výber súboru JavaFX neobsahuje ako štandardnú súčasť žiaden dialóg na výber fontu (hoci viaceré takéto dialógy možno nájsť v externých knižniciach). Vytvoríme si teda dialóg vlastný (nebude úplne dokonalý), čo využijeme predovšetkým ako príležitosť na demonštráciu niekoľkých ďalších aspektov práce s JavaFX:
* Dialóg na výber fontu bude realizovaný pomocou ďalšieho okna (<tt>Stage</tt>) aplikácie; ukážeme si teda, ako možno tvoriť aplikácie s viacerými oknami.
* Tento dialóg navyše miestami schválne navrhneme trochu suboptimálne, čo nám umožní demonštrovať použitie ďalších dvoch ovládacích prvkov v JavaFX: [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/ListView.html <tt>ListView</tt>] a predovšetkým [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/RadioButton.html <tt>RadioButton</tt>].

Dialóg na výber fontu budeme reprezentovať inštanciou samostatnej triedy <tt>FontDialog</tt> s metódou <tt>showFontDialog</tt>, ktorá tento dialóg zobrazí a po jeho ukončení vráti informácie o vybratom fonte. Návratovou hodnotou tejto metódy bude inštancia novovytvorenej triedy <tt>FontAttributes</tt>, ktorá bude slúžiť ako &bdquo;obal&rdquo; pre niektoré atribúty fontu (z inštancií triedy [https://openjfx.io/javadoc/15/javafx.graphics/javafx/scene/text/Font.html <tt>Font</tt>], ktorá nie je navrhnutá úplne najideálnejším spôsobom, sa niektoré z týchto atribútov zisťujú pomerne ťažko).
<syntaxhighlight lang="java">
package editor;

import javafx.scene.text.*;

public class FontAttributes {
    private String family;
    private FontWeight weight;
    private FontPosture posture;
    private double size;

    public String getFamily() {
        return family;
    }

    public FontWeight getWeight() {
        return weight;
    }

    public FontPosture getPosture() {
        return posture;
    }

    public double getSize() {
        return size;
    }

    public FontAttributes(String family, FontWeight weight, FontPosture posture, double size) {
        this.family = family;
        this.weight = weight;
        this.posture = posture;
        this.size = size;
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
package editor;

import javafx.stage.*;
import javafx.scene.*;
import javafx.scene.layout.*;
import javafx.scene.control.*;
import javafx.scene.text.*;

public class FontDialog {
    private Stage stage;

    public FontDialog() {
        // Zatial iba zaklad implementacie.

        BorderPane borderPane = new BorderPane();

        Scene scene = new Scene(borderPane);

        stage = new Stage();
        stage.initStyle(StageStyle.UTILITY);             // Prejavi sa v systemovych ikonach okna
        stage.initModality(Modality.APPLICATION_MODAL);  // Pocas zobrazenia okna sa nebude dat pristupovat k ostatnym oknam
        stage.setScene(scene);
        stage.setTitle("Formát písma");
    }

    /**
     * Metoda, ktora zobrazi dialogove okno stage, pricom vychodzie nastavenie ovladacich prvkov bude urcene parametrom
     * oldFontAttributes. Po ukonceni dialogu vrati atributy fontu vybrane pouzivatelom.
     * @param oldFontAttributes Atributy fontu, ktorym sa text zobrazoval doposial. Na zaklade nich sa nastavia
     *                          vlastnosti zobrazovanych ovladacich prvkov dialogu.
     * @return                  Nova instancia triedy FontAttributes reprezentujuca atributy fontu vybraneho v dialogu
     *                          pouzivatelom. V pripade ukoncenia dialogu inym sposobom, nez potvrdenim, je navratovou
     *                          hodnotou metody referencia null.
     */
    public FontAttributes showFontDialog(FontAttributes oldFontAttributes) {
        // Zatial iba zaklad implementacie.

        stage.showAndWait(); // Od metody show sa showAndWait lisi tym, ze zvysok kodu sa vykona az po zavreti okna
        return new FontAttributes("Tahoma", FontWeight.NORMAL, FontPosture.REGULAR, 16); // Neskor nahradime zmysluplnym kodom
    }
}
</syntaxhighlight>

V hlavnej triede <tt>Editor</tt> vytvoríme inštanciu triedy <tt>FontDialog</tt> a implementujeme metódu <tt>fontAction</tt>.
<syntaxhighlight lang="java">
public class Editor extends Application {
    // ...

    private FontDialog fontDialog; 

    // ...

    private boolean fontAction() {
        FontAttributes fontAttributes = fontDialog.showFontDialog(
                new FontAttributes(fontFamily, fontWeight, fontPosture, fontSize));
        if (fontAttributes != null) {
            fontFamily = fontAttributes.getFamily();
            fontWeight = fontAttributes.getWeight();
            fontPosture = fontAttributes.getPosture();
            fontSize = fontAttributes.getSize();
            applyFont();
        }
        return true;
    }

    // ...

    @Override
    public void start(Stage primaryStage) {
        // ...

        fontDialog = new FontDialog();

        // ...
    }
}
</syntaxhighlight>

=== Ovládacie prvky <tt>ListView</tt> a <tt>RadioButton</tt> ===

[[Image:Textovyeditor5.png|thumb|Výsledný vzhľad dialógového okna.|420px]]

Pridáme teraz do nášho dialógového okna jednotlivé ovládacie prvky tak, aby dialóg vyzeral ako na obrázku vpravo. Okrem dvojice tlačidiel pozostáva dialóg z ovládacích prvkov, s ktorými sme sa doposiaľ nestretli:
* Z jedného &bdquo;zoznamu&rdquo; typu [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/ListView.html <tt>ListView</tt>]. Kľúčovou vlastnosťou inštancie triedy <tt>ListView</tt> je jej <tt>selectionModel</tt>, ktorý hovorí o móde výberu jednotlivých prvkov. My si vystačíme s východzím nastavením tejto vlastnosti, pri ktorom možno zo zoznamu vybrať najviac jeden prvok. Prístup k vybraným prvkom zoznamu je však vždy potrebné realizovať prostredníctvom metódy <tt>getSelectionModel</tt> vracajúcej inštanciu generickej triedy [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/MultipleSelectionModel.html <tt>MultipleSelectionModel<T></tt>], ktorá je vlastnosťou <tt>selectionModel</tt> &bdquo;obalená&rdquo;.
* Z viacerých tlačidiel typu [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/RadioButton.html <tt>RadioButton</tt>]. Toto pomenovanie je zvolené na základe toho, že pri ich typickom použití zvolenie jedného z tlačidiel &bdquo;na diaľku&rdquo; vypína doposiaľ zvolené tlačidlo v danej skupine.

Rozmiestnenie jednotlivých ovládacích prvkov na scéne realizujeme podobne ako na predminulej prednáške; tentokrát však v konštruktore triedy <tt>FontDialog</tt>.
<syntaxhighlight lang="java">
// ...

import java.util.*;
import javafx.geometry.*;
import javafx.collections.*;

// ...

public class FontDialog {
    // ...
    
    private ListView<String> lvFamilies;
    private ArrayList<RadioButton> rbSizes;
    private RadioButton rbRegular;
    private RadioButton rbBold;
    private RadioButton rbItalic;
    private RadioButton rbBoldItalic;
    
    public FontDialog() {
        // ...
        
        GridPane grid = new GridPane();
        borderPane.setCenter(grid);
        grid.setPadding(new Insets(10, 15, 10, 15));
        grid.setAlignment(Pos.CENTER);
        grid.setHgap(10);
        grid.setVgap(20);

        lvFamilies = new ListView<>();
        grid.add(lvFamilies, 0, 0);
        lvFamilies.setItems(FXCollections.observableList(Font.getFamilies()));
        lvFamilies.setPrefHeight(200);

        rbSizes = new ArrayList<>();
        for (int i = 8; i <= 24; i += 2) {
            rbSizes.add(new RadioButton(Integer.toString(i)));
        }

        VBox rbBox1 = new VBox();
        rbBox1.setSpacing(10);
        rbBox1.setPadding(new Insets(0, 20, 0, 10));
        rbBox1.getChildren().addAll(rbSizes);
        grid.add(rbBox1, 1, 0);

        rbRegular = new RadioButton("Obyčajný");
        rbBold = new RadioButton("Tučný");
        rbItalic = new RadioButton("Kurzíva");
        rbBoldItalic = new RadioButton("Tučná kurzíva");

        VBox rbBox2 = new VBox();
        rbBox2.setSpacing(20);
        rbBox2.setPadding(new Insets(0, 10, 0, 20));
        rbBox2.getChildren().addAll(rbRegular, rbBold, rbItalic, rbBoldItalic);
        grid.add(rbBox2, 2, 0);

        TilePane bottom = new TilePane();
        borderPane.setBottom(bottom);
        bottom.setPadding(new Insets(15, 15, 15, 15));
        bottom.setAlignment(Pos.BASELINE_RIGHT);
        bottom.setHgap(10);
        bottom.setVgap(10);

        Button btnOK = new Button("Potvrdiť");
        btnOK.setMaxWidth(Double.MAX_VALUE);
        Button btnCancel = new Button("Zrušiť");
        btnCancel.setMaxWidth(Double.MAX_VALUE);
        bottom.getChildren().addAll(btnOK, btnCancel);
        
        // ...
    }
    
    // ...   
}
</syntaxhighlight>

=== Skupiny tlačidiel typu <tt>RadioButton</tt> (<tt>ToggleGroup</tt>) ===

Po otvorení dialógu vytvoreného vyššie zisťujeme, že je možné &bdquo;zaškrtnúť&rdquo; ľubovoľnú podmnožinu <tt>RadioButton</tt>-ov. Ak totiž nepovieme inak, každý z nich tvorí osobitnú skupinu.

V nasledujúcom zabezpečíme, aby bolo možné &bdquo;zaškrtnúť&rdquo; najviac jedno z tlačidiel v zozname <tt>rbSizes</tt> a najviac jedno zo zvyšných tlačidiel. Urobíme to tak, že každé z tlačidiel pridáme do jednej z dvoch skupín reprezentovaných inštanciami triedy [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/ToggleGroup.html <tt>ToggleGroup</tt>].
<syntaxhighlight lang="java">
public class FontDialog {
    // ...
    
    private ToggleGroup toggleGroup1;        
    private ToggleGroup toggleGroup2;        

    // ...

    public FontDialog() {
        // ...

        toggleGroup1 = new ToggleGroup();           

        /* Cyklus for, v ktorom sa pridavaju prvky do zoznamu rbSizes, upravime nasledovne: */
        for (int i = 8; i <= 24; i += 2) {
            RadioButton rb = new RadioButton(Integer.toString(i));
            rb.setToggleGroup(toggleGroup1);       
            rbSizes.add(rb);
        } 

        // ...

        toggleGroup2 = new ToggleGroup();           
         
        rbRegular.setToggleGroup(toggleGroup2);     
        rbBold.setToggleGroup(toggleGroup2);        
        rbItalic.setToggleGroup(toggleGroup2);      
        rbBoldItalic.setToggleGroup(toggleGroup2);  

        // ...
    }

    // ...     
}     
</syntaxhighlight>

=== Dokončenie dialógu na výber fontu ===

Pridajme najprv funkcionalitu jednotlivých tlačidiel dialógu na výber fontu.
<syntaxhighlight lang="java">
public class FontDialog {
    // ...

    private boolean confirmed;
    
    private void okAction() {
        confirmed = true;
        stage.close();
    }
    
    private void cancelAction() {
        stage.close();
    }

    public FontDialog() {
        // ...
        
        btnOK.setOnAction(event -> okAction());
        btnCancel.setOnAction(event -> cancelAction());

        // ...
    }

    // ...
}        
</syntaxhighlight>

Teraz už len ostáva implementovať metódu <tt>showFontDialog</tt>, ktorá:
* Podľa vstupných parametrov &ndash; atribútov doposiaľ zvoleného fontu &ndash; nastaví predvolené hodnoty v dialógu.
* Otvorí dialóg metódou <tt>stage.showAndWait</tt> (vykonávanie programu sa teda zablokuje, až kým sa dialóg nezavrie; tým sa táto metóda líši od metódy <tt>show</tt>).
* V prípade, že dialóg skončil potvrdením (<tt>confirmed == true</tt>), vráti na výstupe atribúty fontu na základe tých zvolených v dialógu.

Jej implementácia môže byť napríklad nasledovná.
<syntaxhighlight lang="java">
public class FontDialog {
    // ...

    public FontAttributes showFontDialog(FontAttributes oldFontAttributes) {
        /* Nastav predvoleny font podla oldFontAttributes: */  
 
        lvFamilies.getSelectionModel().select(oldFontAttributes.getFamily());
        rbSizes.get((int)((oldFontAttributes.getSize() - 8) / 2)).setSelected(true);
        if (oldFontAttributes.getWeight() == FontWeight.NORMAL) {
            if (oldFontAttributes.getPosture() == FontPosture.REGULAR) {
                rbRegular.setSelected(true);
            } else if (oldFontAttributes.getPosture() == FontPosture.ITALIC) {
                rbItalic.setSelected(true);
            }
        } else if (oldFontAttributes.getWeight() == FontWeight.BOLD) {
            if (oldFontAttributes.getPosture() == FontPosture.REGULAR) {
                rbBold.setSelected(true);
            } else if (oldFontAttributes.getPosture() == FontPosture.ITALIC) {
                rbBoldItalic.setSelected(true);
            } 
        }

    
        /* Otvor dialogove okno: */
 
        confirmed = false;
        stage.showAndWait();


        /* Ak dialog skoncil potvrdenim, vrat zvolene hodnoty na vystupe: */

        if (confirmed) {
            String newFamily = "";
            FontWeight newWeight;
            FontPosture newPosture;
            double newSize = 0;
            newFamily = lvFamilies.getSelectionModel().getSelectedItem();
            if (rbRegular.isSelected() || rbItalic.isSelected()) {
                newWeight = FontWeight.NORMAL;
            } else {
                newWeight = FontWeight.BOLD;
            }
            if (rbRegular.isSelected() || rbBold.isSelected()) {
                newPosture = FontPosture.REGULAR;
            } else {
                newPosture = FontPosture.ITALIC;
            }
            int i = 8;
            for (RadioButton rb : rbSizes) {
                if (rb.isSelected()) {
                    newSize = i;
                }
                i += 2;
            }
            return new FontAttributes(newFamily, newWeight, newPosture, newSize);
        } else {
            return null;
        }
    }    
}
</syntaxhighlight>

=== Cvičenia ===
* Rozšírte textový editor o možnosť nastavovania farby fontu a farby výplne textového priestoru. Zísť sa tu môže ovládací prvok [https://openjfx.io/javadoc/15/javafx.controls/javafx/scene/control/ColorPicker.html <tt>ColorPicker</tt>].
* Ukončenie aplikácie sme implementovali tak, že pokiaľ bol dokument od posledného uloženia zmenený, zobrazí sa výzva na jeho uloženie; pokiaľ zmenený nebol, aplikácia sa priamo ukončí. Upravte aplikáciu tak, aby sa aj v druhom prípade zobrazila výzva na potvrdenie ukončenia programu (avšak bez toho, aby sa aplikácia pýtala na uloženie dokumentu).

=== Textový editor: kompletný zdrojový kód ===

* [[#Textový editor: kompletný zdrojový kód|Zobraziť kód]]

== Viacoknové aplikácie v JavaFX: minimalistický príklad ==

Zakončime teraz tému tvorby aplikácií v JavaFX príkladom aplikácie s dvoma oknami, ktorý je o niečo jednoduchší, než ten vyššie. Hlavné okno aplikácie bude pozostávať z jedného tlačidla a jedného textového popisku. Po stlačení tlačidla sa zobrazí druhé okno s dvoma tlačidlami (<tt>Áno</tt> resp. <tt>Nie</tt>). Každé z týchto tlačidiel toto druhé okno zavrie. Ak sa tak stane tlačidlom <tt>Áno</tt>, v textovom popisku hlavného okna sa objaví text <tt>Áno</tt>; ak je druhé okno zavreté tlačidlom <tt>Nie</tt> alebo &bdquo;krížikom&rdquo;, v textovom popisku sa objaví text <tt>Nie</tt>.

Základom aplikácie môže byť nasledujúci kód, v ktorom sú ovládacie prvky rozmiestnené v hlavnom okne.
<syntaxhighlight lang="java">
package nejakaaplikacia;

import javafx.application.*;
import javafx.stage.*;
import javafx.scene.*;
import javafx.scene.layout.*;
import javafx.scene.control.*;
import javafx.geometry.*;

public class NejakaAplikacia extends Application {

    private Stage primaryStage;
    private Button btnOpenDialog;
    private Label lblResult;

    @Override
    public void start(Stage primaryStage) {
        this.primaryStage = primaryStage;

        GridPane grid = new GridPane();
        grid.setAlignment(Pos.CENTER);
        grid.setPadding(new Insets(20,100,20,100));
        grid.setHgap(10);
        grid.setVgap(10);

        btnOpenDialog = new Button("Otvor dialóg");
        grid.add(btnOpenDialog, 0, 0);

        lblResult = new Label("");
        grid.add(lblResult, 0, 1);

        Scene scene = new Scene(grid);

        primaryStage.setTitle("Hlavné okno");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}
</syntaxhighlight>

Vytvorenie druhého okna a jeho zobrazenie po stlačení tlačidla <tt>btnOpenDialog</tt> potom môžeme priamočiaro implementovať napríklad nasledovne.
<syntaxhighlight lang="java">
public class NejakaAplikacia extends Application {
    // ...
    
    private Stage dialogStage;
    private Button btnYes;    
    private Button btnNo;
    
    private boolean result;    

    @Override
    public void start(Stage primaryStage) {
        // ...
        
        btnOpenDialog.setOnAction(event -> {
            result = false;
            dialogStage.showAndWait();
            if (result) {
                lblResult.setText("Áno");
            } else {
                lblResult.setText("Nie");
            }
        });      

        // ...

        dialogStage = new Stage();               
        
        HBox hb = new HBox();                    
        
        hb.setSpacing(10);
        hb.setPadding(new Insets(10,10,10,10));
        
        btnYes = new Button("Áno");              
        btnYes.setOnAction(event -> {  
            result = true;
            dialogStage.close();
        });
        btnNo = new Button("Nie");               
        btnNo.setOnAction(event -> dialogStage.close());
        hb.getChildren().addAll(btnYes, btnNo);
        
        Scene dialogScene = new Scene(hb, 120, 50);
        
        dialogStage.setScene(dialogScene);                     
        dialogStage.setTitle("Dialóg");                        
        dialogStage.initModality(Modality.APPLICATION_MODAL);  
        dialogStage.initStyle(StageStyle.UTILITY);             

        // ...
    }
}
</syntaxhighlight>

O niečo elegantnejším prístupom je však vytvorenie samostatnej triedy (napríklad <tt>CustomDialog</tt>) pre dialógové okno. Do konštruktora tejto triedy môžeme presunúť všetok kód rozmiestňujúci ovládacie prvky dialógového okna.
<syntaxhighlight lang="java">
package nejakaaplikacia;

import javafx.stage.*;
import javafx.scene.*;
import javafx.scene.layout.*;
import javafx.scene.control.*;
import javafx.geometry.*;

public class CustomDialog {
    private Stage dialogStage;
    private Button btnYes;
    private Button btnNo;

    private boolean result;

    public CustomDialog() {
        dialogStage = new Stage();

        HBox hb = new HBox();

        hb.setSpacing(10);
        hb.setPadding(new Insets(10,10,10,10));

        btnYes = new Button("Áno");
        btnYes.setOnAction(event -> {
            result = true;
            dialogStage.close();
        });
        btnNo = new Button("Nie");
        btnNo.setOnAction(event -> dialogStage.close());
        hb.getChildren().addAll(btnYes, btnNo);

        Scene dialogScene = new Scene(hb, 120, 50);

        dialogStage.setScene(dialogScene);
        dialogStage.setTitle("Dialóg");
        dialogStage.initModality(Modality.APPLICATION_MODAL);
        dialogStage.initStyle(StageStyle.UTILITY);
    }

    public String showCustomDialog() {
        result = false;
        dialogStage.showAndWait();
        if (result) {
            return "Áno";
        } else {
            return "Nie";
        }
    }
}
</syntaxhighlight>

<syntaxhighlight lang="java">
public class NejakaAplikacia extends Application {
    // ...     

    private CustomDialog dialog;
    
    @Override
    public void start(Stage primaryStage) {
        // ...

        dialog = new CustomDialog();
        btnOpenDialog.setOnAction(event -> lblResult.setText(dialog.showCustomDialog()));        

        // ...
    }
}
</syntaxhighlight>
=Textový editor: kompletný zdrojový kód=
<syntaxhighlight lang="Java">
package editor;

import java.io.*;
import java.util.*;
import java.nio.file.*;
import javafx.application.*;
import javafx.stage.*;
import javafx.scene.*;
import javafx.scene.layout.*;
import javafx.scene.control.*;
import javafx.scene.text.*;
import javafx.scene.input.*;
import javafx.geometry.*;

public class Editor extends Application {

    private Stage primaryStage;
    private TextArea textArea;
    private FontDialog fontDialog;

    private Menu mFile;
    private Menu mFileNew;
    private MenuItem miFileNewEmpty;
    private MenuItem miFileNewRandom;
    private MenuItem miFileOpen;
    private MenuItem miFileSave;
    private MenuItem miFileSaveAs;
    private MenuItem miFileExit;
    private Menu mFormat;
    private MenuItem miFormatFont;
    private CheckMenuItem miFormatWrap;

    private ContextMenu contextMenu;
    private MenuItem cmiFormatFont;
    private CheckMenuItem cmiFormatWrap;

    private File openedFile;
    private boolean openedFileChanged;

    private String fontFamily = "Tahoma";
    private FontWeight fontWeight = FontWeight.NORMAL;
    private FontPosture fontPosture = FontPosture.REGULAR;
    private double fontSize = 16;

    private final int N = 1000;  // V metode newRandomAction budeme generovat N riadkov o N nahodnych cifrach

    private void updateOpenedFileInformation(File file, boolean hasChanged) {
        openedFile = file;
        openedFileChanged = hasChanged;
        miFileSave.setDisable(!hasChanged);
        updatePrimaryStageTitle();
    }

    private void updatePrimaryStageTitle() {
        StringBuilder title = new StringBuilder("Textový editor (");
        if (openedFile == null) {
            title.append("neuložené v žiadnom súbore");
        } else {
            title.append(openedFile.getName());
        }
        title.append(")");
        if (openedFileChanged) {
            title.append("*");
        }
        primaryStage.setTitle(title.toString());
    }

    private void applyFont() {
        textArea.setFont(Font.font(fontFamily, fontWeight, fontPosture, fontSize));
    }

    private void handleTextAreaChange() {
        if (!openedFileChanged) {
            updateOpenedFileInformation(openedFile, true);
        }
    }

    private boolean saveBeforeClosingAlert() {
        if (openedFileChanged) {                                      // Ak dokument nie je ulozeny
            Alert alert = new Alert(Alert.AlertType.CONFIRMATION);    // Vytvor dialog typu Alert, variant CONFIRMATION
            alert.setTitle("Uložiť súbor?");                          // Nastav titulok dialogu
            alert.setHeaderText(null);                                // Dialog nebude mat ziaden "nadpis"
            alert.setContentText("Uložiť zmeny v súbore?");           // Nastav text dialogu

            ButtonType buttonTypeYes = new ButtonType("Áno");         // Vytvor instancie reprezentujuce typy tlacidiel
            ButtonType buttonTypeNo = new ButtonType("Nie");

            // Vdaka druhemu argumentu sa bude ako tlacidlo "Zrusit" spravat aj "krizik" v dialogovom okne vpravo hore:
            ButtonType buttonTypeCancel = new ButtonType("Zrušiť", ButtonBar.ButtonData.CANCEL_CLOSE);

            alert.getButtonTypes().setAll(buttonTypeYes, buttonTypeNo, buttonTypeCancel); // Nastav typy tlacidiel

            Optional<ButtonType> result = alert.showAndWait();        // Zobraz dialog a cakaj, kym sa zavrie
            if (result.get() == buttonTypeYes) {                      // Pokracuj podla typu stlaceneho tlacidla
                return saveAction();
            } else if (result.get() == buttonTypeNo) {
                return true;
            } else {
                return false;
            }
        } else {                                                      // Ak je dokument ulozeny, netreba robit nic
            return true;
        }
    }

    /**
     * Pomocna metoda, ktora vytvori dialog typu FileChooser a prednastavi niektore jeho vlastnosti.
     * @return Vytvoreny dialog typu FileChooser.
     */
    private FileChooser prepareFileChooser() {
        FileChooser fileChooser = new FileChooser();                                // Vytvorenie dialogoveho okna
        fileChooser.setInitialDirectory(new File(System.getProperty("user.dir")));  // Nastavenie vychodzieho adresara
        fileChooser.getExtensionFilters().addAll(                                   // Filtre na pripony
                new FileChooser.ExtensionFilter("Textové súbory (*.txt)", "*.txt"),
                new FileChooser.ExtensionFilter("Všetky súbory (*.*)", "*.*"));
        return fileChooser;
    }

    /**
     * Pomocna metoda realizujuca vyber suboru na otvorenie.
     * @return Vybrany subor alebo null v pripade, ze ziaden subor vybrany nebol.
     */
    private File chooseFileToOpen() {
        FileChooser fileChooser = prepareFileChooser();
        fileChooser.setTitle("Otvoriť");
        return fileChooser.showOpenDialog(primaryStage);
    }

    /**
     * Pomocna metoda realizujuca vyber suboru na ulozenie.
     * @return Vybrany subor alebo null v pripade, ze ziaden subor vybrany nebol.
     */
    private File chooseFileToSave() {
        FileChooser fileChooser = prepareFileChooser();
        fileChooser.setTitle("Uložiť");
        return fileChooser.showSaveDialog(primaryStage);
    }

    private String loadFromFile(File file) throws IOException {
        return Files.readString(Paths.get(file.getPath()));
    }

    private void writeToFile(File file, String s) throws IOException {
        Files.writeString(Paths.get(file.getPath()), s);
    }

    private boolean newEmptyAction() {
        if (saveBeforeClosingAlert()) {               // Pokracuj len ak sa podarilo zavriet dokument
            updateOpenedFileInformation(null, true);  // Nebude teraz otvoreny ziaden subor...
            textArea.clear();                         // Zmazeme obsah textoveho priestoru textArea
            return true;
        } else {
            return false;
        }
    }

    private boolean newRandomAction() {
        if (newEmptyAction()) {                           // Skus vytvorit novy subor a pokracuj len, ak sa to podarilo
            StringBuilder builder = new StringBuilder();  // Vygeneruj retazec o N x N nahodnych cifrach
            Random random = new Random();
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    builder.append(random.nextInt(10));
                }
                builder.append(System.lineSeparator());
            }
            textArea.setText(builder.toString());         // Vypis vygenerovany retazec do textoveho priestoru textArea
            return true;
        } else {
            return false;
        }
    }

    private boolean openAction() {
        if (saveBeforeClosingAlert()) {                        // Ak sa podarilo zavriet dokument
            File file = chooseFileToOpen();                    // Vyber subor na otvorenie
            if (file != null) {                                // Ak bol nejaky subor vybrany ...
                try {
                    textArea.setText(loadFromFile(file));      // ... vypis jeho obsah do textArea
                    updateOpenedFileInformation(file, false);  // Aktualizuj informacie o otvorenom subore
                } catch (IOException e) {
                    System.err.println("Nieco sa pokazilo.");
                }
                return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    }

    private boolean saveAction() {
        if (openedFile == null) {                                // Ak nebol otvoreny ziaden subor ...
            return saveAsAction();                               // ... realizuj to iste ako pri "Ulozit ako"
        } else {                                                 // V opacnom pripade ...
            try {
                writeToFile(openedFile, textArea.getText());     // ... prepis aktualne otvoreny subor
                updateOpenedFileInformation(openedFile, false);  // Aktualizuj informacie o otvorenom subore
            } catch (IOException e) {
                System.err.println("Nieco sa pokazilo.");
            }
            return true;
        }
    }

    private boolean saveAsAction() {
        File file = chooseFileToSave();                    // Vyber subor, do ktoreho sa ma ukladat
        if (file != null) {                                // Ak bol nejaky subor vybrany ...
            try {
                writeToFile(file, textArea.getText());     // ... zapis don obsah textArea
                updateOpenedFileInformation(file, false);  // Aktualizuj informacie o otvorenom subore
            } catch (IOException e) {
                System.err.println("Nieco sa pokazilo.");
            }
            return true;
        } else {
            return false;
        }
    }

    private boolean exitAction() {
        if (saveBeforeClosingAlert()) {   // Pokracuj len ak sa podarilo zavriet dokument
            Platform.exit();              // Ukonci aplikaciu
            return true;
        } else {
            return false;
        }
    }

    private boolean fontAction() {
        FontAttributes fontAttributes = fontDialog.showFontDialog(
                new FontAttributes(fontFamily, fontWeight, fontPosture, fontSize));
        if (fontAttributes != null) {
            fontFamily = fontAttributes.getFamily();
            fontWeight = fontAttributes.getWeight();
            fontPosture = fontAttributes.getPosture();
            fontSize = fontAttributes.getSize();
            applyFont();
        }
        return true;
    }

    private boolean handleStageCloseRequest(WindowEvent event) {
        if (saveBeforeClosingAlert()) {  // Ak sa podarilo zavriet subor
            return true;
        } else {                         // Ak sa nepodarilo zavriet subor ...
            event.consume();             // ... nechceme ani zavriet okno
            return false;
        }
    }

    public void start(Stage primaryStage) {
        this.primaryStage = primaryStage;

        BorderPane borderPane = new BorderPane();
        Scene scene = new Scene(borderPane);

        textArea = new TextArea();
        borderPane.setCenter(textArea);
        textArea.setPadding(new Insets(5, 5, 5, 5));
        textArea.setPrefWidth(1000);
        textArea.setPrefHeight(700);
        applyFont();
        textArea.textProperty().addListener((observable, oldValue, newValue) -> handleTextAreaChange());

        MenuBar menuBar = new MenuBar();
        borderPane.setTop(menuBar);

        mFile = new Menu("Súbor");
        mFileNew = new Menu("Nový");
        miFileNewEmpty = new MenuItem("Prázdny súbor");
        miFileNewRandom = new MenuItem("Náhodné cifry");
        mFileNew.getItems().addAll(miFileNewEmpty, miFileNewRandom);
        miFileOpen = new MenuItem("Otvoriť...");
        miFileSave = new MenuItem("Uložiť");
        miFileSaveAs = new MenuItem("Uložiť ako...");
        miFileExit = new MenuItem("Koniec");
        mFile.getItems().addAll(mFileNew, miFileOpen, miFileSave, miFileSaveAs, new SeparatorMenuItem(), miFileExit);

        mFormat = new Menu("Formát");
        miFormatFont = new MenuItem("Písmo...");
        miFormatWrap = new CheckMenuItem("Zalamovať riadky");
        miFormatWrap.setSelected(false);                        // Nie je nutne, kedze false je tu vychodzia hodnota
        mFormat.getItems().addAll(miFormatFont, miFormatWrap);

        menuBar.getMenus().addAll(mFile, mFormat);

        miFileNewEmpty.setAccelerator(new KeyCodeCombination(KeyCode.N, KeyCombination.CONTROL_DOWN)); // Ctrl + N
        miFileOpen.setAccelerator(new KeyCodeCombination(KeyCode.O, KeyCombination.CONTROL_DOWN));     // Ctrl + O
        miFileSave.setAccelerator(new KeyCodeCombination(KeyCode.S, KeyCombination.CONTROL_DOWN));     // Ctrl + S

        miFileNewEmpty.setOnAction(event -> newEmptyAction());
        miFileNewRandom.setOnAction(event -> newRandomAction());
        miFileOpen.setOnAction(event -> openAction());
        miFileSave.setOnAction(event -> saveAction());
        miFileSaveAs.setOnAction(event -> saveAsAction());
        miFileExit.setOnAction(event -> exitAction());
        miFormatFont.setOnAction(event -> fontAction());

        contextMenu = new ContextMenu();
        textArea.setContextMenu(contextMenu);
        cmiFormatFont = new MenuItem("Formát písma...");
        cmiFormatWrap = new CheckMenuItem("Zalamovať riadky");
        cmiFormatWrap.setSelected(false);
        contextMenu.getItems().addAll(cmiFormatFont, cmiFormatWrap);

        cmiFormatFont.setOnAction(event -> fontAction());

        miFormatWrap.selectedProperty().bindBidirectional(cmiFormatWrap.selectedProperty());
        miFormatWrap.selectedProperty().bindBidirectional(textArea.wrapTextProperty());

        fontDialog = new FontDialog();

        updateOpenedFileInformation(null, true);

        primaryStage.setOnCloseRequest(event -> handleStageCloseRequest(event));
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}
</syntaxhighlight>

<syntaxhighlight lang="Java">
package editor;

import javafx.scene.text.*;

public class FontAttributes {
    private String family;
    private FontWeight weight;
    private FontPosture posture;
    private double size;

    public String getFamily() {
        return family;
    }

    public FontWeight getWeight() {
        return weight;
    }

    public FontPosture getPosture() {
        return posture;
    }

    public double getSize() {
        return size;
    }

    public FontAttributes(String family, FontWeight weight, FontPosture posture, double size) {
        this.family = family;
        this.weight = weight;
        this.posture = posture;
        this.size = size;
    }
}
</syntaxhighlight>

<syntaxhighlight lang="Java">
package editor;

import java.util.*;
import javafx.stage.*;
import javafx.scene.*;
import javafx.scene.layout.*;
import javafx.scene.control.*;
import javafx.scene.text.*;
import javafx.geometry.*;
import javafx.collections.*;

public class FontDialog {
    private Stage stage;

    private ListView<String> lvFamilies;
    private ArrayList<RadioButton> rbSizes;
    private RadioButton rbRegular;
    private RadioButton rbBold;
    private RadioButton rbItalic;
    private RadioButton rbBoldItalic;

    private ToggleGroup toggleGroup1;
    private ToggleGroup toggleGroup2;

    private boolean confirmed;

    private void okAction() {
        confirmed = true;
        stage.close();
    }

    private void cancelAction() {
        stage.close();
    }

    public FontDialog() {
        BorderPane borderPane = new BorderPane();
        Scene scene = new Scene(borderPane);

        GridPane grid = new GridPane();
        borderPane.setCenter(grid);
        grid.setPadding(new Insets(10, 15, 10, 15));
        grid.setAlignment(Pos.CENTER);
        grid.setHgap(10);
        grid.setVgap(20);

        lvFamilies = new ListView<>();
        grid.add(lvFamilies, 0, 0);
        lvFamilies.setItems(FXCollections.observableList(Font.getFamilies()));
        lvFamilies.setPrefHeight(200);

        toggleGroup1 = new ToggleGroup();
        rbSizes = new ArrayList<>();
        for (int i = 8; i <= 24; i += 2) {
            RadioButton rb = new RadioButton(Integer.toString(i));
            rb.setToggleGroup(toggleGroup1);
            rbSizes.add(rb);
        }

        VBox rbBox1 = new VBox();
        rbBox1.setSpacing(10);
        rbBox1.setPadding(new Insets(0, 20, 0, 10));
        rbBox1.getChildren().addAll(rbSizes);
        grid.add(rbBox1, 1, 0);

        toggleGroup2 = new ToggleGroup();

        rbRegular = new RadioButton("Obyčajný");
        rbBold = new RadioButton("Tučný");
        rbItalic = new RadioButton("Kurzíva");
        rbBoldItalic = new RadioButton("Tučná kurzíva");

        rbRegular.setToggleGroup(toggleGroup2);
        rbBold.setToggleGroup(toggleGroup2);
        rbItalic.setToggleGroup(toggleGroup2);
        rbBoldItalic.setToggleGroup(toggleGroup2);

        VBox rbBox2 = new VBox();
        rbBox2.setSpacing(20);
        rbBox2.setPadding(new Insets(0, 10, 0, 20));
        rbBox2.getChildren().addAll(rbRegular, rbBold, rbItalic, rbBoldItalic);
        grid.add(rbBox2, 2, 0);

        TilePane bottom = new TilePane();
        borderPane.setBottom(bottom);
        bottom.setPadding(new Insets(15, 15, 15, 15));
        bottom.setAlignment(Pos.BASELINE_RIGHT);
        bottom.setHgap(10);
        bottom.setVgap(10);

        Button btnOK = new Button("Potvrdiť");
        btnOK.setMaxWidth(Double.MAX_VALUE);
        Button btnCancel = new Button("Zrušiť");
        btnCancel.setMaxWidth(Double.MAX_VALUE);
        bottom.getChildren().addAll(btnOK, btnCancel);

        btnOK.setOnAction(event -> okAction());
        btnCancel.setOnAction(event -> cancelAction());

        stage = new Stage();
        stage.initStyle(StageStyle.UTILITY);             // Prejavi sa v systemovych ikonach okna
        stage.initModality(Modality.APPLICATION_MODAL);  // Pocas zobrazenia okna sa nebude dat pristupovat k ostatnym oknam
        stage.setScene(scene);
        stage.setTitle("Formát písma");
    }

    /**
     * Metoda, ktora zobrazi dialogove okno stage, pricom vychodzie nastavenie ovladacich prvkov bude urcene parametrom
     * oldFontAttributes. Po ukonceni dialogu vrati atributy fontu vybrane pouzivatelom.
     * @param oldFontAttributes Atributy fontu, ktorym sa text zobrazoval doposial. Na zaklade nich sa nastavia
     *                          vlastnosti zobrazovanych ovladacich prvkov dialogu.
     * @return                  Nova instancia triedy FontAttributes reprezentujuca atributy fontu vybraneho v dialogu
     *                          pouzivatelom. V pripade ukoncenia dialogu inym sposobom, nez potvrdenim, je navratovou
     *                          hodnotou metody referencia null.
     */
    public FontAttributes showFontDialog(FontAttributes oldFontAttributes) {
        /* Nastav predvoleny font podla oldFontAttributes: */

        lvFamilies.getSelectionModel().select(oldFontAttributes.getFamily());
        rbSizes.get((int)((oldFontAttributes.getSize() - 8) / 2)).setSelected(true);
        if (oldFontAttributes.getWeight() == FontWeight.NORMAL) {
            if (oldFontAttributes.getPosture() == FontPosture.REGULAR) {
                rbRegular.setSelected(true);
            } else if (oldFontAttributes.getPosture() == FontPosture.ITALIC) {
                rbItalic.setSelected(true);
            }
        } else if (oldFontAttributes.getWeight() == FontWeight.BOLD) {
            if (oldFontAttributes.getPosture() == FontPosture.REGULAR) {
                rbBold.setSelected(true);
            } else if (oldFontAttributes.getPosture() == FontPosture.ITALIC) {
                rbBoldItalic.setSelected(true);
            }
        }

        /* Otvor dialogove okno: */

        confirmed = false;
        stage.showAndWait();

        /* Ak dialog skoncil potvrdenim, vrat zvolene hodnoty na vystupe: */

        if (confirmed) {
            String newFamily = "";
            FontWeight newWeight;
            FontPosture newPosture;
            double newSize = 0;
            newFamily = lvFamilies.getSelectionModel().getSelectedItem();
            if (rbRegular.isSelected() || rbItalic.isSelected()) {
                newWeight = FontWeight.NORMAL;
            } else {
                newWeight = FontWeight.BOLD;
            }
            if (rbRegular.isSelected() || rbBold.isSelected()) {
                newPosture = FontPosture.REGULAR;
            } else {
                newPosture = FontPosture.ITALIC;
            }
            int i = 8;
            for (RadioButton rb : rbSizes) {
                if (rb.isSelected()) {
                    newSize = i;
                }
                i += 2;
            }
            return new FontAttributes(newFamily, newWeight, newPosture, newSize);
        } else {
            return null;
        }
    }
}
</syntaxhighlight>
=Riešenia náhradného testu č. 2=
== Úloha č. 1 ==

<syntaxhighlight lang="java">
public class Circles extends Application {
    private int circleCount;

    private Color randomColour(Random random) {
        return Color.color(random.nextDouble(), random.nextDouble(), random.nextDouble());
    }

    @Override
    public void start(Stage primaryStage) {
    
        // ...
   
        Random random = new Random();

        btnAdd.setOnAction(actionEvent -> {
            Circle circle = new Circle(random.nextInt(261) + 20, random.nextInt(261) + 20, 20);
            circle.setFill(randomColour(random));
            left.getChildren().add(circle);
            lblCircleCount.setText("Počet kruhov: " + (++circleCount));
            circle.setOnMouseClicked(mouseEvent -> {
                left.getChildren().remove(circle);
                lblCircleCount.setText("Počet kruhov: " + (--circleCount));
            });
        });

        // ...
    }            
}
</syntaxhighlight>

== Úloha č. 2 ==

<syntaxhighlight lang="java">
package graphs;

import java.util.*;

public class MaximumIndependentSet {
    private UndirectedGraph g;
    private LinkedList<Integer> maximumIndependentSet;
    private LinkedList<Integer> currentVertices;

    public MaximumIndependentSet(UndirectedGraph g) {
        this.g = g;
        maximumIndependentSet = new LinkedList<>();
        currentVertices = new LinkedList<>();
        search(0);
    }

    private void search(int vertex) {
        if (vertex == g.getNumberOfVertices()) {
            if (isIndependentSet(currentVertices) && currentVertices.size() > maximumIndependentSet.size()) {
                maximumIndependentSet = new LinkedList<>(currentVertices);
            }
        } else {
            currentVertices.addLast(vertex);
            search(vertex + 1);
            currentVertices.removeLast();
            search(vertex + 1);
        }
    }

    private boolean isIndependentSet(Collection<Integer> vertices) {
        for (int u : vertices) {
            for (int v : vertices) {
                if (g.existsEdge(u, v)) {
                    return false;
                }
            }
        }
        return true;
    }

    public List<Integer> getMaximumIndependentSet() {
        return Collections.unmodifiableList(maximumIndependentSet);
    }
}
</syntaxhighlight>

== Úloha č. 3 ==

<syntaxhighlight lang="java">
import java.util.*;

public class FixedLengthList<E> implements Iterable<E> {
    private ArrayList<E> list;

    public FixedLengthList(int length, E element) {
        list = new ArrayList<>();
        for (int i = 1; i <= length; i++) {
            list.add(element);
        }
    }

    public FixedLengthList(List<E> list) {
        this.list = new ArrayList<>(list);
    }

    public E get(int index) {
        return list.get(index);
    }

    public E set(int index, E element) {
        return list.set(index, element);
    }

    public int length() {
        return list.size();
    }

    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int nextIndex = 0;

            @Override
            public boolean hasNext() {
                return nextIndex < list.size();
            }

            @Override
            public E next() {
                if (hasNext()) {
                    return get(nextIndex++);
                } else {
                    throw new NoSuchElementException();
                }
            }
        };
    }
}
</syntaxhighlight>