Zobrazenie zdroja stránky 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 {

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 anonymnej triedy ''implementujúcej funkcionálne rozhranie'' a 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 ===

=== Ďalšie príklady použitia lambda výrazov ===

=== Referencie na metódy ===

== Úvod do JavaFX ==

''JavaFX'' je knižnica, ktorú možno využiť ako nástroj 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).

* Staršia verzia JavaFX bola priamo súčasťou Java SE 8 a mala dobrú podporu v NetBeans (ide o verzie nainštalované v počítačových učebniach). 
* Novšie verzie Java SE už JavaFX neobsahujú, ale táto je vyvíjaná ako samostatný modul, ktorý je potrebné aj samostatne nainštalovať. Podpora v NetBeans je slabšia.
* [[#Inštalácia novších verzií JavaFX|Viac o inštalácii JavaFX pre novšie verzie Java SE a NetBeans]] (návod popisuje aj vytvorenie JavaFX projektu v novších verziách NetBeans).   
* [http://docs.oracle.com/javase/8/javase-clienttechnologies.htm Dokumentácia a tutoriály pre JavaFX 8].
* [https://openjfx.io/ Dokumentácia a tutoriály pre JavaFX 14].

=== 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">
package aplikacia;

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, 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://docs.oracle.com/javase/8/javafx/api/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://docs.oracle.com/javase/8/javafx/api/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 trieda <tt>[https://docs.oracle.com/javase/8/javafx/api/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 interpretovaná ako hierarchický strom 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://docs.oracle.com/javase/8/javafx/api/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>Aplikacia</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.
<!-- V NOVEJ VERZII NETBEANS UZ NEPLATI !!!
<span style="font-size:85%">''Poznámka'': V NetBeans je možné pri vytváraní projektu zvoliť ako typ projektu ''JavaFX -> JavaFX Application''. V takom prípade sa automaticky vygeneruje krátky kód aplikácie s jedným tlačidlom vypisujúcim na konzolu text <tt>Hello World!</tt>. Po zmazaní nepotrebných častí tohto vygenerovaného kódu možno pokračovať v písaní vlastnej JavaFX aplikácie. Alternatívne možno cez ''Tools -> Templates -> JavaFX -> JavaFX Main Class'' prestaviť obsah generovanej kostry podľa vlastných preferencií.</span>-->

=== 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">
package aplikacia;

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://docs.oracle.com/javase/8/javafx/api/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">
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">
label1.setFont(Font.font("Tahoma", FontWeight.BOLD, 12));
label1.setLayoutX(20);
label1.setLayoutY(10);
</syntaxhighlight>  

Analogicky vytvoríme aj ostatné komponenty:
<syntaxhighlight lang="java">
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. 

Obidvoma týmito problematikami sa budeme zaoberať 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 (Java Virtual Machine) vygenerovaná tzv. ''udalosť'', ktorá je v tomto prípade typu <tt>[https://docs.oracle.com/javase/8/javafx/api/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://docs.oracle.com/javase/8/javafx/api/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://docs.oracle.com/javase/8/javafx/api/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<ActionEvent>() {
        @Override
        public void handle(ActionEvent event) {
            label2.setText(textField.getText());
        }
    });

    ...

}
</syntaxhighlight>

Ak si navyše uvedomíme, že rozhranie EventHandler pozostáva z jedinej metódy, 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((ActionEvent e) -> {
        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://docs.oracle.com/javase/8/javafx/api/javafx/scene/shape/Circle.html Circle]</tt>, <tt>[https://docs.oracle.com/javase/8/javafx/api/javafx/scene/shape/Rectangle.html Rectangle]</tt>, <tt>[https://docs.oracle.com/javase/8/javafx/api/javafx/scene/shape/Arc.html Arc]</tt>, <tt>[https://docs.oracle.com/javase/8/javafx/api/javafx/scene/shape/Ellipse.html Ellipse]</tt>, <tt>[https://docs.oracle.com/javase/8/javafx/api/javafx/scene/shape/Line.html Line]</tt>, <tt>[https://docs.oracle.com/javase/8/javafx/api/javafx/scene/shape/Polygon.html Polygon]</tt>, atď. Všetky útvary dedia od spoločnej abstraktnej nadtriedy <tt>[https://docs.oracle.com/javase/8/javafx/api/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://docs.oracle.com/javase/8/javafx/api/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">
package aplikacia;

import javafx.application.*;
import javafx.stage.*;
import javafx.scene.*;
import javafx.scene.layout.*;
import javafx.scene.shape.*;
import javafx.scene.paint.*;
import javafx.scene.input.*;
import java.util.*;
 
public class Aplikacia extends Application {

    Color randomColor(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;
                boolean isSquare = random.nextBoolean();
                Color color = randomColor(random);
                if (isSquare) {
                    shape = new Rectangle(i * 60 + 5, j * 60 + 5, 50, 50);
                } else {
                    shape = new Circle(i * 60 + 30, j * 60 + 30, 25);
                }
                shape.setFill(color);
                shape.setOnMouseClicked((MouseEvent e) -> {
                    shape.setFill(randomColor(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]