AKCIA! CELOŽIVOTNÉ predplatné so zľavou 50%, nezmeškaj to!
Zisti viac
Späť na blog
Tipy a triky

Lambda výrazy v Jave - časť IV.

Skillmea
30.10.2019
9 minút čítania
Lambda výrazy v Jave - časť IV.

Funkcionálne rozhrania

Ak chcem používať lambda výraz, tak potrebujem na to rozhranie s jednou abstraktnou metódou. Daná metóda musí odpovedať popisu nášho lambda výrazu. 
Ak sa nad tým zamyslíš, tak v skutočnosti sa dané rozhranie môže volať hocijako. Na názve nezáleží. A aj metóda v tom rozhraní môže mať hocijaký názov, pre logiku lambda výrazu to nemá žiaden zmysel. Jediné, čo je dôležité je, aby metóda sedela s lamba výrazom v tom, čo vracia a to, čo je na vstupe metódy ako parameter. 
Bolo by úplne super, keby sme nemuseli vždy pri písaní lambda výrazu riešiť vytvorenie nového rozhrania, ktoré nám bude slúžiť ako typ daného lambda výrazu. Čo povieš? 
Povedali sme, si, že java nevytvorila nový typ pre lambdy. Pri písaní, sme si mohli všimnúť, že metódy sú často podobné. Vraciam nejaký typ alebo vraciam void a mám tam názov metódy tam sú alebo nie sú parametre. Sú tu nejaké paterny, nejaké vzorce, ktoré sa opakujú častejšie. 
Java nám ponúka niekoľko takých rozhraní, ktoré môžeme kľudne použiť. Tieto rozhrania sú v balíčku java.util.function. V tomto balíku je mnoho pred pripravených rozhraní, ktoré môžeš používať. Tieto rozhrania používajú generiká, tak si tam vieš dosadiť objekty aké potrebuješ. 
Napríklad Predicate je presne stvorený na to, ak potrebujeme zobrať na vstupe objekt a vrátiť boolean ako návratovú hodnotu. Takto môžeme použiť toto rozhranie namiesto toho rozhrania, čo sme si sami napísali, keď sme riešili predchádzajúcu úlohu

Ako ošetriť výnimky

 Spravme si príklad, ktorý bude obsahovať zoznam osôb, ktoré budem spracovávať – vypíšeme ich mená a dáme ich na veľké písmená.
public class ExceptionHandling {
    public static void main(String[] args) {
        ArrayList<Osoba> osoby = new ArrayList<>();
        osoby.add(new Osoba("jano", "beno", 3));
        osoby.add(new Osoba("peter", "beno", 0));
        osoby.add(new Osoba("jaro", "beno", 30));
        osoby.add(new Osoba("brano", "beno", 28));
        processOsoby(osoby);
    }
    private static void processOsoby(ArrayList<Osoba> osoby) {
        for (Osoba osoba : osoby){
            System.out.println(osoba.getMeno().toUpperCase());
        }
    }
}

Prepíšeme si to na lambda výraz. Náš kód, ktorý chceme metóde predať ako argument je System.out.println(osoba.getMeno().toUpperCase()). Pracujem teda len s objektom osoba. Výsledok napíšem na konzolu. Tým pádom mám jeden argument a tento kus kódu nevracia žiadnu hodnotu. Budeme na to potrebovať funkcionálne rozhranie, ktoré má metódu s jedným parametrom a nevracia nič. Takým je Consumer s jeho metódou accept.
public class ExceptionHandling {
    public static void main(String[] args) {
        ArrayList<Osoba> osoby = new ArrayList<>();
        osoby.add(new Osoba("jano", "beno", 3));
        osoby.add(new Osoba("peter", "beno", 0));
        osoby.add(new Osoba("jaro", "beno", 30));
        osoby.add(new Osoba("brano", "beno", 28));
        processOsoby(osoby, osoba -> System.out.println(osoba.getMeno().toUpperCase()));
    }
    private static void processOsoby(ArrayList<Osoba> osoby, Consumer<Osoba> consumer) {
        for (Osoba osoba : osoby){
            consumer.accept(osoba);
        }
    }
}

Teraz si náš zoznam osôb zmením tak, že namiesto mien dám do zoznamu null. Pri spracúvaní lamba výrazu nám program spadne na NullPointerException.
osoby.add(new Osoba("jano", "beno", 3));
osoby.add(new Osoba(null, "beno", 0));
osoby.add(new Osoba("jaro", "beno", 30));
osoby.add(new Osoba("brano", "beno", 28));
Musíme si ošetriť túto výnimku. Ako na to? Jedným zo spôsobov je obaliť volanie consumer.accept do try catch bloku.
private static void processOsoby(ArrayList<Osoba> osoby, Consumer<Osoba> consumer) {
    for (Osoba osoba : osoby){
        try {
            consumer.accept(osoba);
        }catch (NullPointerException e){
            //...
        }
    }
}
Ale to je škaredé riešenie. To čo príde do consumer môže byť všeličo možné a nemusí to dať NullPointerException, možno to bude iná výnimka. Náš kód chceme mať jednoduchší. Druhou možnosťou je, aby bola výnimka spracovaná priamo v lamba výraze.
public class ExceptionHandling {
    public static void main(String[] args) {
        ArrayList<Osoba> osoby = new ArrayList<>();
        osoby.add(new Osoba("jano", "beno", 3));
        osoby.add(new Osoba(null, "beno", 0));
        osoby.add(new Osoba("jaro", "beno", 30));
        osoby.add(new Osoba("brano", "beno", 28));
        processOsoby(osoby, osoba -> {
            try {
                System.out.println(osoba.getMeno().toUpperCase());
            }catch (NullPointerException e){
                e.printStackTrace();
            }
        });
    }
    private static void processOsoby(ArrayList<Osoba> osoby, Consumer<Osoba> consumer) {
        for (Osoba osoba : osoby){
            consumer.accept(osoba);
        }
    }
}
Dosiahol som to, že metóda processOsoby je krajšia, ale náš lambda výraz je teraz viacriadkový a nie pekný - jednoriadkový
Na jednej strane chceme mať pekné jednoduché lambda výrazy, na druhej strane chceme, aby bolo postarané o výnimky. 
V našom kóde sa vráťme k riešeniu, ktoré nepoužíva try catch blok. Na odchytenie výnimky použijeme wrapper metódu. Try catch blok si vyvedieme do osobitnej metódy a potom obalíme náš lambda výraz, ďalším lambda výrazom, ktorý má try catch blok. Urobme to, čo som teraz napísal.
Vytvoríme si novú metódu, ktorá bude akceptovať lambda výraz. V našom prípade sme na to použili Consumer rozhranie. A keďže je to wrapper, tak to čo mi príde na vstup tak dám aj na výstup.
private static Consumer<Osoba> wrapperLambda(Consumer<Osoba> consumer){
    return consumer;
}
V metóde processOsoby(osoby, osoba -> System.out.println(osoba.getMeno().toUpperCase())); zavolám namiesto lambda výrazu, wrapper metódu, ktorej argument bude lambda výraz. Urobí to to isté, ale použil som wrapper metódu.
public class ExceptionHandling {
    public static void main(String[] args) {
        ArrayList<Osoba> osoby = new ArrayList<>();
        osoby.add(new Osoba("jano", "beno", 3));
        osoby.add(new Osoba("peter", "beno", 0));
        osoby.add(new Osoba("jaro", "beno", 30));
        osoby.add(new Osoba("brano", "beno", 28));
        processOsoby(osoby, wrapperLambda(osoba -> System.out.println(osoba.getMeno().toUpperCase())));
    }
    private static void processOsoby(ArrayList<Osoba> osoby, Consumer<Osoba> consumer) {
        for (Osoba osoba : osoby){
            consumer.accept(osoba);
        }
    }
    private static Consumer<Osoba> wrapperLambda(Consumer<Osoba> consumer){
        return consumer;
    }
}
Tu môžem spraviť nasledujúcu vec. Namiesto toho aby som lambdu prehnal cez wrapper metódu, tak ju ani nepoužijem, ale použjime len jej vstupný parameter, čo je osoba. Môžem spraviť niečo takéto: 
private static Consumer<Osoba> wrapperLambda(Consumer<Osoba> consumer){
    return osoba -> System.out.println(osoba.getPriezvisko());
}
Namiesto toho, aby som využil vstupnú lambdu, ktorá mi prišla cez parameter consumer, som na ňu zabudol a len som využil vstupný parameter danej lambdy a vytvoril som novú lambdu. 
Pri volaní consumer.accept(osoba); v metóde processOsoby sa vykoná lambda výraz z wrapper metódy. Toto nie je skutočný wrapper. Skutočný wrapper, zoberie vstupnú lambdu a vykoná čo požaduje. Teraz máme istotu, že sa zavolá presne náš požadovaný lambda výraz a zároveň môžeme pridávať kód okolo.
private static Consumer<Osoba> wrapperLambda(Consumer<Osoba> consumer){
    return osoba -> consumer.accept(osoba);
}
Tu prichádza narad try catch blok v wrapper metóde. Upravíme si kód, aby nám hádzal výnimku.
public class ExceptionHandling {
    public static void main(String[] args) {
        ArrayList<Osoba> osoby = new ArrayList<>();
        osoby.add(new Osoba("jano", "beno", 3));
        osoby.add(new Osoba(null, "beno", 0));
        osoby.add(new Osoba("jaro", "beno", 30));
        osoby.add(new Osoba("brano", "beno", 28));
        processOsoby(osoby, wrapperLambda(osoba -> System.out.println(osoba.getMeno().toUpperCase())));
    }
    private static void processOsoby(ArrayList<Osoba> osoby, Consumer<Osoba> consumer) {
        for (Osoba osoba : osoby){
            consumer.accept(osoba);
        }
    }
    private static Consumer<Osoba> wrapperLambda(Consumer<Osoba> consumer){
        return osoba -> {
            try{
                consumer.accept(osoba);
            }catch (NullPointerException e){
                System.out.println("Null pointer exception in wrapper lambda");
            }
        };
    }
}
Ak sa zastavuješ pri myšlienke, že sme nič nezjednodušili, len sme presunuli kód na iné miesto, tak máš pravdu, ale! Ak si danú metódu spravíš generickú, tak si do tejto metódy môžeš zabaliť hocijakú lambdu, ktorej typ je Consumer rozhranie. Škoda, že tvorcovia javy nespravili takéto wrapper metódy pre všetky funkcionálne rozhrania z balíku java.util.function.
private static<T> Consumer<T> wrapperLambda(Consumer<T> consumer){
    return osoba -> {
        try{
            consumer.accept(osoba);
        }catch (NullPointerException e){
            System.out.println("Null pointer exception in wrapper lambda");
        }
    };
}


Pokračovať s Lambda výrazmi budeme opäť v ďalšom článku. Moje meno je Jaro Beňo a naučím ťa programovať v Jave. Ahoj.
Skillmea
🥇 Sme jednotka v online vzdelávaní na Slovensku.
Na našom webe nájdeš viac ako 300 rôznych videokurzov z oblastí ako programovanie, tvorba hier, testovanie softwaru, grafika, UX dizajn, online marketing, MS Office a pod. 
Vyber si kurz, ktorý ťa posunie vpred ⏩

Mohlo by ťa zaujímať

Ako zistiť, či je číslo zadané zo vstupu prvočíslom?
Tipy a triky
16.10.2019
Skillmea

Ako zistiť, či je číslo zadané zo vstupu prvočíslom?

V 15. kapitole online kurzu vyššieho programovacieho jazyka C++ úrovne Elementary II nájdete medzi zadaniami praktických príkladov na domáce precvičenie aj úlohu, v ktorej máte nájsť najväčší spoločný deliteľ dvoch čísel a taktiež úlohu, v ktorej máte nájsť najmenší spoločný násobok dvoch čísel alebo ich najväčší spoločný deliteľ. Ak siahnete do osnov matematiky druhého stupňa základnej školy niekde do 6. alebo 7. ročníka, zistíte, že kľúčom k vyriešeniu týchto dvoch úloh je rozklad obidvoch čísel na súčin prvočísel. Úlohy patria z hľadiska logiky a analytického myslenia medzi začiatočnícke. Napriek tomu viem, že sú náročnejšie. Práve preto som sa rozhodol napísať tento blog.  V tomto blogu nechcem riešiť túto úlohu za vás, ale aspoň by som vám rád podal návod, ako zistiť, či je načítané číslo zo vstupu prvočíslom. Táto úloha je jedna z čiastkových úloh, ktoré je potrebné riešiť pri dvoch spomenutých príkladoch, ktorých riešenie ste dostali za úlohu nájsť.  Tí, ktorí zabudli, čo je prvočíslo, ozrejmím aj tento pojem. Prvočíslo je celé kladné číslo, ktoré je deliteľné len jednotkou a svojou vlastnou hodnotou. Budeme sa teda pohybovať iba v množine kladných celých čísel. Príkladom prvočísla môže byť napr. číslo 5, pretože je deliteľné len číslom 1 a 5. ďalšími príkladmi sú 2, 3, 7, 11, 13, 17 atď. Samotné číslo 1 sa za prvočíslo nepovažuje. Povedzme, že máme číslo 60, jeho rozklad na súčin prvočísel je 2 x 2 x 3 x 5. Už z rozkladu je zrejmé, že ho môžeme vynásobiť číslom 1, nič by to totiž nezmenilo na výsledku, stále by ste dostali číslo 60. Vidíte, a práve preto sa matematici dohodli, že 1 prvočíslom nebude, nemá totiž už žiadny vplyv v súčine prvočísel, ktorého výsledkom je nejaké číslo. Takže bez zbytočných ďalších prázdnych fráz prejdem rovno k veci. Nasleduje teda zdrojový kód v jazyku C++, ktorý rieši titulok tohto blogu: 01: #include <iostream> 02: using namespace std; 03: 04: int main() 05: { 06: int iNumb; 07: 08: cout << "Zadaj lubovolne cele kladne cislo: "; 09: cin >> iNumb; 10: cout << endl; 11: 12: bool flag = true; 13: 14: if (iNumb == 1) 15: { 16: flag = false; 17: } 18: else 19: { 20: for (int i = 2; i <= iNumb / 2; i++) 21: { 22: if (iNumb % i == 0) 23: { 24: flag = false; 25: break; 26: } 27: } 28: } 29: 30: if (flag) 31: { 32: cout << "Cislo " << iNumb << " je prvocislo !" << endl; 33: } 34: else 35: { 36: cout << "Cislo " << iNumb << " nie je prvocislo !" << endl; 37: } 38: 39: cout << endl; 40: 41: cin.get(); 42: cin.get(); 43: 44: return 0; 45: } Na riadku 01 je uvedená direktíva preprocesora #include, ktorej parametrom je štandardná knižnica iostream. Potrebujeme ju z dôvodu používania objektov cout, cin a manipulátora endl. Na riadku 02 uvádzame do platnosti menný priestor std pre celý zdrojový súbor .cpp. Spomenuté objekty cout, cin a manipulátor endl je zároveň súčasťou tohto priestoru. Na riadku 04 je uvedená funkcia main aj so svojim návratovým typom, ktorým je int (integer). Túto funkciu volá operačný systém. Na riadku 05 je uvedená ľavá programová zátvorka, ktorou sa začína telo funkcie main. Na riadku 06 je deklarovaná premenná iNumb na údajový typ int. Táto premenná reprezentuje hodnotu celého kladného čísla, o ktorom chceme zistiť, či patrí medzi prvočísla. Na riadku 08 je pomocou objektu cout zapísaný na výstup konzolovej aplikácie textový reťazec, ktorý vyzve používateľa na zadanie hodnoty kladného celého čísla, ktorého vlastnosť prvočísla testujeme. Na riadku 09 je prostredníctvom objektu cin načítaná táto hodnota do premennej iNumb. Na riadku 10 je prostredníctvom objektu cout a manipulátora endl presunutý kurzor konzolovej aplikácie na ďalší riadok. Na riadku 12 je deklarovaná premenná flag a zároveň inicializovaná na hodnotu true. Táto premenná nám bude po otestovaní načítaného čísla ukladať informáciu, či je číslo prvočíslom alebo nie. Z hľadiska logiky algoritmu je nutné premennú flag inicializovať pred testovaním na hodnotu true. Algoritmom budeme totiž testovať, či načítané číslo medzi prvočísla nepatrí. Používa sa tu teda postup vylučovací. Na riadku 14 je testovaná podmienka, či v premennej iNumb nie je hodnota 1. Ak áno, program pokračuje kladnou vetvou a do premennej flag sa na riadku 16 zapíše hodnota false, ktorá reprezentuje stav, kedy načítané číslo prvočíslom nie je. Na riadku 13 a 15 sú len uvedené programové zátvorky, ktoré uzatvárajú blok kódu uvedený v kladnej vetve. Ak spomínaná podmienka splnená nie je, pokračuje sa zápornou vetvou. Blok kódu v zápornej vetve uzatvorený programovými zátvorkami na riadkoch 19 a 29. Na riadku 20 až 27 je uvedené jadro algoritmu, ktorý testuje vlastnosť prvočísla u čísel väčších ako 1.  A v čom spočíva idea jadra algoritmu ? V každej iterácii cyklu zisťujeme, či je číslo deliteľné hodnotou v premennej i. Najmenšie číslo, ktorým môže byť načítané testované deliteľné, je číslo 2 (viď. riadok 20 – for slučka) a preto iterujeme od tejto hodnoty. Premennú i postupne inkrementujeme (viď. riadok 20 – for slučka) a testujeme, či je hodnota premennej iNumb deliteľná bez zvyšku pomocou operácie modulo na riadku 22, ktorá je umiestnená v príkaze if. Ak je číslo deliteľné hodnotou v premennej i bez zvyšku, tak sa na riadku 24 uloží do premennej flag hodnota false, čo reprezentuje stav, kedy načítané číslo nie je prvočíslom. Premenná i sa inkrementuje po iNumb / 2 (viď. riadok 20 – for slučka). Dôvodom je fakt, že žiadne celé kladné číslo nemôže byť predsa deliteľné bez zvyšku číslom väčším ako je jeho polovica.  Ak sa teda nenájde číslo, ktorým je načítaná hodnota testovaného čísla deliteľná bez zvyšku, neuloží sa do premennej flag hodnota false, čiže po ukončení v nej bude uložená hodnota true, čo reprezentuje stav, kedy je načítané testované číslo prvočíslom. Na riadku 25 je uvedené kľúčové slovo break a to z toho dôvodu, že v prípade nájdenia jedného čísla, ktoré delí načítané testované číslo bez zvyšku, nie je nutné hľadať ďalšie delitele. Testované číslo už prvočíslo totiž byť nemôže a preto násilne ukončíme slučku for, urýchlime program, ktorý následne prejde až na riadok 30. Tu sa už len testuje hodnota v premennej flag. Ak je v tejto premennej uložená hodnota true, tak sa zapíše na výstup konzolovej aplikácie pomocou objektu cout informácia o tom, že je načítané testované číslo prvočíslom (viď. riadok 32), ak false tak informácia, že prvočíslom nie je.  Na riadku 41 a 42 je už len načítavaný vstup z konzolovej aplikácie pomocou objektu cin, čo slúži na to, aby sa hneď program neukončil a bol zobrazený výsledok v okne konzole, pokým používateľ nezatlačí ľubovoľná kláves. Na riadku 44 vracia funkcia main operačnému systému hodnotu 0, ktorá indikuje stav správneho ukončenia aplikácie. Na riadku 45 je ukončené telo programu pravou programovou zátvorkou. Algoritmus, ktorý som navrhol a implementoval v jazyku C++ nie je ešte optimálny. Je však pre účely kurzu úrovne začiatočník postačujúci. Medzi prvočíslami sa dajú ešte sledovať určité vlastnosti, nebudem ich však tomto bloku spomínať, aby som príliš poslucháča úrovne začiatočník zbytočne nadmerne nezaťažil. Optimálny algoritmus však budem ešte publikovať a rozoberať v ďalšom bloku a v kurze, ktorý bude zameraný aj na matematiku. Autorom blogu je Marek Šurka, lektor online kurzov jazyka C++ na Learn2Code
Lambda výrazy v Jave - časť III.
Tipy a triky
03.10.2019
Skillmea

Lambda výrazy v Jave - časť III.

Lambda a vnútorné anonymné triedyVeľmi sa nám žiada povedať, že lambda výrazy sú len skratky ako napísať vnútorné anonymné triedy. Ale pamätaj si, nie je to tak. Vyzerá to podobne ale lambda nie je implementácia rozhrania. Lambda je sama osobe nezávislá iná vec.   Pozrime sa na príklad. Namiesto toho aby sme použili implementačnú triedu nášho rozhrania IHelloWord, vytvoríme si vnútornú anonymnú triedu. IHelloWord helloWord3 = new IHelloWord() { @Override public void sayHello() { System.out.println("HelloWord impls inner anonymous class"); } };Všetky 3 možnosti, ktoré majú ako návratovú hodnotu rozhranie IHelloWord môžeme podsunúť do metody printHelloWord(IHelloWord helloWord). helloWord.printHelloWord(helloWord1); helloWord.printHelloWord(helloWord2); helloWord.printHelloWord(helloWord3); Ako to, ako to? Ako java vie, aký má použiť typ pre lamba výraz? Aby sme tomu porozumeli, vytvoríme si novú triedu, kde budeme pracovať s lambda výrazom. Vytvorme si rozhranie, ktoré bude mať jednu metódu, ktorá bude vracať int a na vstupe bude tiež int. interface Nasob{ int nasob(int a); } Ako by vyerala implementácia tohto rozhrania? class NasobPiatimi implements Nasob{ public int nasob(int a){ return a*5; } }Teraz si navrhnime lambda výraz, ktorý zodpovedá danej metóde. Nepotrebujeme návratovú hodnotu int, lebo java vie na ňu prísť sama a nepotrebujeme ani názov metódy a ani modifikátor prístupu public. Náš lambda výraz bude vyzerať takto: (int a) -> a*5;Teraz použime tento lambda výraz: public static void main(String[] args) { Nasob nasobPiatimi = (int a) -> a*5; System.out.println(nasobPiatimi.nasob(10)); }Na výstupe bude 50. V tomto príklade sa lambda tvári ako instancia rozhrania Nasob. V predchádzajúcich príkladoch, keď sme používali HelloWord sme takúto premennú vkladali ako parameter metódy printHelloWord (HelloWord3 v IDEi). Namiesto toho sme mohli túto lambdu vložiť priamo do metódy. helloWord.printHelloWord(() -> System.out.println("HelloWord impls lambda");); Java kompilátor vezme tento lambda výraz a pozrie sa kam ide. Ide to metódy printHelloWord a pozrie sa, čo akceptuje na vstupe. Akceptuje rozhranie HelloWord. Ak lambda sedí s požiadavkou, že dané rozhranie obsahuje len jednu metódu a tá vracia void a na vstupe nemá žiaden parameter, tak java povie, že daná lambda je typu HelloWord. Toto sa volá Type inference. Java si sama zistí typ. Teraz, keď vieš ako java dokáže zistiť typy, vrátime sa ku príkladu, ktorý sme začali písať v tejto kapitole. V našom príklade vieme ešte viacej skrátiť zápis nášho lambda výrazu. Nasob nasobPiatimi = (int a) -> a*5; System.out.println(nasobPiatimi.nasob(10));Keďže naša lamba ide do metódy rozhrania, ktorú poznáme interface Nasob{ int nasob(int a); } Tak vieme presne povedať aký typ má vstupný paramter metódy. Je to int. interface Nasob{ int nasob(int a); }Keď to vieme, tak nemusíme pri písaní lambda výrazu znovu špecifikovať typ vstupného parametru. Nasob nasobPiatimi = (a) -> a*5; A keďže máme len jeden parameter, nemusíme písať ani zátvorky. Nasob nasobPiatimi = a -> a*5; Už nebudeme nič mazať, lebo by nám už nič neostalo 😃 Teraz môžeme napísať metódu, ktorá bude na vstupe očakávať rozhranie Nasob a keď ju použijeme, tak do nej vložíme na vstup náš lambda výraz. public static void printNasob(Nasob nasob){ System.out.println(nasob.nasob(10)); } public static void main(String[] args) { printNasob(a -> a*5); }V jave mohli kľudne vytvoriť nový typ pre tieto lambda výrazy. Ale nespravili to a jedným z dôvodov je aj spätná kompatibilita so starším kódom. Ako už vieme, tak lambda výrazy môžeme použiť všade tam, kde máme vyhovujúce rozhranie. Vo vnútorných anonymných triedach, v metódach kde je na vstupe interface a podobne. Príklad: HelloWord helloWord3 = new HelloWord() { @Override public void sayHello() { System.out.println("HelloWord impls inner anonymous class"); } }; HelloWord helloWord3 = () -> System.out.println("HelloWord impls inner anonymous class"); Pri tomto musíme pamätať, aby rozhrania boli jedno metódové alebo aby ostatné metódy rozhrania boli default. A dané metódy v rozhraniach, aby sa zhodovali s lambda výrazom. Takéto rozhranie s jednou abstraktnou metódou (metóda, ktorá poskytuje opis nie implemntáciu) sa nazýva Functional interface. Predstav si, že používaš rozhranie, ktorý má len jednu metódu a používaš ho pre lambda výrazy. Teraz by niekto cudzí prišiel a do tohto rozhrania by pridal ďalšiu abstraktnú metódu, presnejšie jej opis bez implementácie. Takéto rozhranie by už viac nebolo functional interface a preto by sa nemohlo použiť pre lambda výraz a nastala by chyba – napriek tomu, že rozhranie by bolo v poriadku. Treba na to myslieť a ak chceme niečo pridať do functional interfac, tak len ako default metódy. Aby sme upozornili kohokoľvek, kto by chcel niečo pridať do nášho rozhrania, tak máme možnosť pridať anotáciu @FunctionalInterface. K anotáciam sa ešte dostaneme, tak sa nebojte. Teraz je dôležité vedieť, že je to pomôcka – táto pomôcka nám spraví to, že hneď ako napíšeme ďalšiu metódu do nášho rozhrania, tak nastane chyba. Danú anotáciu nemusíme písať, ale je to super. @FunctionalInterface public interface HelloWord { void sayHello(); }Príklady na vyskúšanie: 1. vytvor si zoznam miest  2. zotrieď zoznam  3. napíš metódu, ktorá vypíše všetko zo zoznamu miest  4. urob si metódu, ktorá vypíše len tie mestá, ktoré sa skladajú z jedného slova nepoužívaj pri tom lambda výrazy Pokračovanie nabudúce 👋 Články a online kurzy o Jave pre teba pripravuje Jaro Beňo.
Lambda výrazy v Jave - časť II.
Tipy a triky
23.08.2019
Skillmea

Lambda výrazy v Jave - časť II.

Typy lambda výrazovTento článok je pokračovaním prvej časti tutoriálu o Lambda výrazoch. Vráťme sa k nášmu príkladu na začiatku, kde sme do metódy vložili implementáciu rozhrania a zavolali sme metódu. Toto si teraz skúsime spolu prerobiť, tak aby sme použili lamba výraz.  HelloWord2.  Prepíšme metódu implementácie na lambda výraz. public void sayHello() { System.out.println("HelloWord impls"); } () -> System.out.println("HelloWord impls"); Znovu tá istá otázka, aký typ má lamba výraz ak ho chcem priradiť do premennej?  lambdaFunkcia = () -> System.out.println("HelloWord impls");Počkať! V Jave predsa máme možnosť ako deklarovať, vymenúvať metódy a tú použijeme. Tou možnosťou je použiť rozhrania.  1. vytvorenie rozhrania s jednou deklaráciou metódy  2. vytvorenie metódy, ktorá odpovedá našemu lambda výrazu  1. v našom prípade nemá žiadne argumenty a návratová hodnota je void  Ak by sme vytvorili rozhranie, kde budeme uvádzať viacero metód, tak to bude chyba. Jedine ak budú default – teda implementované. Viď sekciu o rozhraniach.  ILambda lambdaFunkcia = () -> System.out.println("HelloWord impls"); … public interface ILambda { void metoda(); // void metoda2(String s); // bude error } Použime lambda výraz s bezpečným delením. Napíšme si k tomu interface a premennú: bezpecneDelenieFunkcia = (int a, int b) -> { if(b==0) { return 0 ; } return a/b; }; public static void main(String[] args) { Hocijako hocijako = (int a, int b) -> { if(b==0){ return 0; } return a/b; }; double d = hocijako.hocico(10, 2); System.out.println(d); } interface Hocijako{ double hocico(int x, int y); }Tu si môžeme povedať, že názov rozhrania a názov metódy v rozhraní nie je dôležitý. Dôležité je, aby sedeli vlastnosti. Teda rozhranie má len jednu metódu (mimo default metód) a metóde sedí typ návratovej hodnoty a parametre metódy. Implemetačnú triedu už teda nepotrebujeme, lebo akoby implementáciou je lambda výraz. Môžem si to nechať, ak to potrebujem takto používať, ale v našom prípade nepotrebujem implementačnú triedu.  Lambda výraz sa správa ako implemtnácia rozhrania. Ale nie je to implementácia. Tento príklad bude fungovať:  HelloWord3 helloWord = new HelloWord3(); IHelloWord helloWord1 = new HelloWordImpl(); IHelloWord helloWord2 = () -> System.out.println("HelloWord impls lambda"); helloWord1.sayHello(); helloWord2.sayHello();Na výstupe bude:  HelloWord impls  HelloWord impls lambda Pokračovanie nabudúce 😗 Mrkni zatiaľ moje kurzy o Java programovaní alebo videá, ktoré máme na Youtube o Lambda výrazoch: https://www.youtube.com/watch?v=tzSFOgnDZZo&list=PL5dKLQR6-HyU7jyoTuZGFmPLAEFpIumi4

Nezmeškaj info o nových kurzoch a špeciálnych ponukách