Lambda-výrazy a metody implementované v interfejsu

Transkript

1 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 1 z 54 Lambda-výrazy a metody implementované v interfejsu Pecinovský rudolf@pecinovsky.cz

2 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 2 z 54 Obsah 1. Terminologie 2. Funkční interfejsy a lambda výrazy 3. Nová koncepce konstrukce interface 4. KONEC

3 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 3 z Terminologie Obsah 1.1 Rozhraní Interfejs 1.2 Přetížení zakrytí přebití předefinování Přetížení metody method overloading Zakrytí metody method hiding Přebití metody method overriding Časná a pozdní vazba early and late binding VMT Předefinování metody method redefining Přepsání metody method rewriting

4 1.1 Rozhraní Interfejs Rozhraní Vlastnost entity programu určující, co okolní program o dané entitě ví a jak s ní může komunikovat Rozhraní mí dvě složky: Signatura označuje tu jeho část, kterou může zkontrolovat překladač Kontrakt označuje část, o jejíž dodržení se musí postarat programátor Interfejs Programová konstrukce umožňující definovat rozhraní bez implementace Počeštěný (a jazykovými slovníky povolený) tvar používám proto, abych mohl termín v textu skloňovat Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 4 z 54

5 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 5 z Přetížení zakrytí přebití předefinování Přetížení metody method overloading Několik metod má stejný název a liší se pouze v počtu a/nebo typu svých parametrů Zakrytí metody method hiding Potomek definuje metodou se stejnou signaturou jako rodič, avšak rodičovská metoda zůstává nadále dostupná Přebití metody method overriding Potomek definuje vlastní verzi zděděné virtuální metody; tato metoda musí mít signaturu kompatibilní s přebitou metodou Předefinování metody method redefining Dochází ke změně kódu metody prostřednictvím nástrojů pro instrumentaci kódu Přepsání metody method rewriting Dochází ke změně kódu metody v důsledku refaktorace či oprav chybného kódu

6 1.2.1 Přetížení metody method overloading Několik metod má stejný název a liší se pouze v počtu a/nebo typu svých parametrů Nestačí, pokud se liší pouze v názvu parametrů, metody se musejí opravdu lišit v počtu svých parametrů a/nebo se musejí lišit typy alespoň v jedné dvojici vzájemně si odpovídajících parametrů Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 6 z 54

7 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 7 z Zakrytí metody method hiding Potomek definuje metodou se stejnou signaturou jako rodič, avšak rodičovská metoda zůstává nadále dostupná Zakrytí se v Javě uplatní pouze u statických metod K zakryté rodičovské metodě se dostanu vhodnou kvalifikací Statická metoda nesmí zakrýt instanční metodu

8 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 8 z Přebití metody method overriding Potomek definuje vlastní verzi zděděné virtuální metody; tato metoda musí mít signaturu kompatibilní s přebitou metodou Přebití se uplatní pouze u virtuálních metod Virtuální metoda je taková, jejíž implementace a začlenění do programu umožňuje její přebití Chování je stejné jako v kartách: metoda potomka přebije rodičovskou, takže tato se neuplatní, i když nadále existuje nezměněná Typy parametrů a návratové hodnoty mohou být stejné, ale nemusí; protože proměnná předka akceptuje odkaz na instanci potomka Typ parametrů musí akceptovat proměnné typu deklarovaného rodičem => typ parametru v přebíjející metodě může být rodičem typu odpovídajícího parametru v metodě přebité Typ návratové hodnoty být přiřaditelný do proměnné typu deklarovaného rodičem => typ návratové hodnoty přebíjející metody může být potomkem typu návratové hodnoty přebíjené metody

9 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 9 z Časná a pozdní vazba early and late binding V souvislosti s přebíjením metod se často hovoří o časné a pozdní vazbě (early and late binding) Časná vazba označuje situaci, kdy překladač již při překladu ví, která metoda bude volána a může je proto v kódu volat přímo, anebo dokonce nahradit volání metody kopií jejího těla (in-lined code) Pozdní vazba označuje stav, kdy se to, která konkrétní metoda bude volána, zjistí až za běhu, a proto je nutné použít nepřímé metody volání Pozdní vazba se většinou realizuje prostřednictvím tabulky virtuálních metod (VMT virtual method table) VMT obsahuje adresy na kódy virtuálních metod Překladač o každé metodě ví, kolikátá je ve VMT Dceřiné typy přebírají VMT svého rodiče a mohu do něj přidat další položky Přebije-li dceřiná metoda rodičovskou, překladač zařídí, aby příslušný odkaz ve VMT odkazoval na dceřinou metodu

10 1.2.5 VMT Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 10 z 54

11 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 11 z Předefinování metody method redefining Dochází ke změně kódu metody prostřednictvím nástrojů pro instrumentaci kódu Tyto nástroje mohou změnit definici třídy (a tím i jejich metod) v průběhu zavádění třídy instancí třídy ClassLoader Prostřednictvím instrumentace se může teoreticky změnit signatura metody, nicméně v zájmu konzistence s ostatním kódem se tak nečiní, protože jinak by bylo třeba upravit i další kód Někdy se tímto termínem označuje změna definice metody v důsledku nějaké refaktorace

12 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 12 z Přepsání metody method rewriting Dochází ke změně kódu metody v důsledku refaktorace či oprav chybného kódu Po přepsání metody je, a rozdíl od předchozích operací, nutný nový překlad dané třídy. Při přepsání metody se může změnit její signatura

13 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 13 z Funkční interfejsy a lambda výrazy Obsah 2.1 Návrhový vzor Příkaz (Command) 2.2 Funkční interfejs Funkční interfejsy v balíčku java.util.function Důležité funkční interfejsy z jiných balíčků 2.3 Lambda-výrazy Syntaktická pravidla Použití v programu Lambda-výraz jako parametr teorie Lambda-výraz jako parametr příklad Rozšířená verze příkladu Metody jako hodnoty lambda-výrazů Příklad Metoda volající zadanou metodu Použití metody report( ) Využití konstruktoru jako tovární metody 2.4 Další syntaktická a sémantická pravidla Použití this a super v lambda-výrazech Lambda-výrazy anonymní třídy Lambda-výrazy uzávěry

14 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 14 z Návrhový vzor Příkaz (Command) Inverzní vzor ke vzoru Služebník: Máme objekt, který něco umí, ale nezná nějakou klíčovou akci tu mu předáme prostřednictvím objektu předaného v parametru Program zabalí akci do objektu, který předá metodě v parametru /** Světlo zadaný počet krát na zabliká. */ public void blink(int times, int period) { class MyRunnable extends Runnable { public run() { switchon(); IO.pause(period/2); switchoff(); IO.pause(period/2); ; Runnable action = new MyRunnable(); //Metoda repeat očekává v prvním parametru počet opakování //a v druhém parametru parametru akci, která se má opakovat new Repeater().repeat(times, action);

15 2.2 Funkční interfejs Dosud jediná vyčleněná kategorie: značkovací interfejsy (tagged interfaces) Nedeklarují žádnou abstraktní metodu (deklarují pouze kontrakt), a proto nevyžadují implementaci nějaké metody Nová kategorie: funkční interfejsy (function interfaces) Deklarují právě jednu abstraktní metodu (tj. vyžadující implementaci právě jedné metody); Neabstraktních metod může mít kolik chce Pokud interfejs přebije kontrakt některé z metod zděděných od třídy Object, není to deklarace abstraktní metody Nepočítají se ani statické metody a metody s implicitní implementací Ve standardní knihovně byla takovýchto interfejsů řada, ale doposud byly především jednoúčelové (Comparable, Runnable,...) Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 15 z 54

16 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 16 z Rozhodneme-li se definovat funkční interfejs, je vhodné anotovat daný typ Anotace není povinná, ale poskytuje překladači informaci, že má u daného datového typu zkontrolovat, že se opravdu jedná o interfejs s jedinou abstraktní metodou Ve standardní knihovně je 231 funkčních interfejsů, přičemž pouze 57 z nich je takto anotováno Program javadoc při vytváření dokumentace nezávisle na anotaci zjistí, zda právě vytváří dokumentaci funkčního interfejsu, a pokud ano, doplní do záhlaví dokumentační stránky zprávu Functional Interface: This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

17 2.2.2 Funkční interfejsy v balíčku java.util.function Nová verze knihovny přináší speciální balíček java.util.function, definující celou řadu obecných funkčních interfejsů V balíčku je 43 interfejsů rozdělených do několika skupin: Metody interfejsů ze skupiny Consumer jsou čistí konzumenti. Zpracují své parametry, ale nic nevrací. Metody interfejsů ze skupiny Supplier jsou naopak čistí producenti. Nepotřebují žádné parametry a vracejí hodnotu zadaného typu. Metody interfejsů ze skupiny Function jsou klasické funkce: zpracují svůj parametr a vrátí funkční hodnotu. Metody interfejsů ze skupiny UnaryOperator představují unární operátory. Jsou definovány jako potomci funkcí, jejichž návratová hodnota je stejného typu jako jejich parametr. Metody interfejsů ze skupiny BinaryOperator představují binární operátory. Jsou také definovány jako potomci funkcí, tentokrát funkcí se dvěma parametry přičemž typy obou parametrů i funkční hodnoty jsou shodné. Metody interfejsů ze skupiny Predicate slouží k získání logické hodnoty odvozené z hodnoty jejich parametru. Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 17 z 54

18 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 18 z 54 //Producenti žádné parametry, jen vracejí hodnotu Supplier<T> T get() BooleanSupplier boolean getasboolean() DoubleSupplier double getasdouble() IntSupplier int getasint() LongSupplier long getaslong() //Konzumenti Zpracují parametry, nic nevracejí //Jednoparametričtí Consumer<T> void accept(t value) DoubleConsumer void accept(double value) IntConsumer void accept(int value) LongConsumer void accept(long value) //Dvouparametričtí BiConsumer<T, U> void accept(t t, U value) ObjDoubleConsumer void accept(t t, double value) ObjIntConsumer void accept(t t, int value) ObjLongConsumer void accept(t t, long value)

19 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 19 z 54 //Funkce zpracují parametr (parametry) a vrátí hodnotu //Jednoparametrikcé vracející objekt Function <T, R> R apply(t value) DoubleFunction < R> R apply(double value) IntFunction < R> R apply(int value) LongFunction < R> R apply(long value) // Jednoparametrikcé vracející hodnotu primitivního typu ToIntFunction <T> int applyasint (T value) ToDoubleFunction<T> double applyasdouble(t value) ToLongFunction <T> long applyaslong (T value) DoubleToIntFunction int applyasint (double value) DoubleToLongFunction long applyaslong (double value) IntToDoubleFunction double applyasdouble(int value) IntToLongFunction long applyaslong (int value) LongToDoubleFunction double applyasdouble(long value) LongToIntFunction int applyasint (long value) //Dvouparametrikcé BiFunction <T, U, R> R apply (T t, U u) ToDoubleBiFunction<T, U, R> double applyasdouble(t t, U u) ToIntBiFunction <T, U, R> int applyasint (T t, U u) ToLongBiFunction <T, U, R> long applyaslong (T t, U u)

20 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 20 z 54 //Unární operátory UnaryOperator<T> T apply (T operand) DoubleUnaryOperator double applyasdouble(double operand) IntUnaryOperator int applyasint (int operand) LongUnaryOperator long applyaslong (long operand) //Binární operátory BinaryOperator<T> T apply (T left, T right) DoubleBinaryOperator double applyasdouble(double left, double right) IntBinaryOperator int applyasint (int left, int right) LongBinaryOperator long applyaslong (long left, long right) //Predikáty metody vracející logickou hodnotu Predicate<T> boolean test(t value) DoublePredicate boolean test(double value) IntPredicate boolean test(int value) LongPredicate boolean test(long value) BiPredicate<T, U> boolean test(t t, U u)

21 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 21 z Důležité funkční interfejsy z jiných balíčků //Balíček: java.awt.event ActionListener void actionperformed(actionevent e) //Balíček: java.io Closeable FileFilter FilenameFilter Flushable void close() boolean accept(file pathname) boolean accept(file dir, String name) void flush() //Balíček: java.lang AutoCloseable void close() Comparable<T> int compareto(t o) Iterable<T> Iterator<T> iterator() Runnable void run() //Balíček: java.util. Comparator<T> Observer boolean equals(object obj) void update(observable o, Object arg)

22 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 22 z Lambda-výrazy Lambda-výrazy představují způsob, jak definovat jako objekt nějakou část kódu, kterou bychom v jiné části programu rádi použili Lambda-výraz můžeme uložit do proměnné funkčního typu a předávat metodám jako hodnotu parametru tohoto typu Překladač definuje lambda-výraz jako instanci funkčního interfejsu, jehož metoda má odpovídající parametry a vrací hodnotu odpovídajícího typu (příslušný převod překladač zařídí) Lambda výraz se definuje některým z následujících způsobů: (parametry) -> { příkazy //Obecný tvar parametr -> { příkazy //Jediný parametr (parametry) -> výraz //Tělo tvoří pouze vyhodnocovaný výraz parametr -> výraz //Jediný parametr + pouze výraz

23 2.3.1 Syntaktická pravidla Je-li vlevo jediný parametr, nemusí se dávat do kulatých závorek; není-li žádný nebo je-li jich více, závorky jsou potřeba Dokáže-li si překladač odvodit typ parametru, nemusí se uvádět Pokud se vpravo pouze vyhodnocuje nějaký výraz, nemusí se dávat do složených závorek. Z lokálních proměnných lze v lambda výrazu použít pouze tzv. efektivní lokální konstanty metody, v níž je výraz definován, tj.: Klasické konstanty (tj. proměnné definované s modifikátorem final) Proměnné, které by překladač jako konstanty akceptoval (jakmile je jim přiřazena nějaká hodnota, už se nemění). Pro atributy žádná omezení na konstanty neplatí Potřebujeme-li v lambda-výrazu používat lokální proměnnou hodnotu, musím ji zabalit do konstantního mutable objektu Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 23 z 54

24 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 24 z Použití v programu Světlo schopné nezávislého blikání použitelné např. pro blinkr auta použijeme návrhový vzor Služebník /*************************************************************************** * Světlo zadaný počet krát na zabliká, tj. * na zadaný počet milisekund se rozsvítí a na stejnou dobu zhasne. * Akce probíhá na pozadí, takže nijak neovlivňuje běh okolního programu. * times Kolikrát světlo blikne period Perioda blikání zadaná v milisekundách */ public void blink(int times, int period) { Runnable action = () -> { switchon(); IO.pause(period/2); switchoff(); IO.pause(period/2); ; new Repeater().repeat(times, action);

25 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 25 z Lambda-výraz jako parametr teorie Předchozí program ale není zcela funkční, protože blikající světlo neumí zjistit, jestli stále bliká, anebo již doblikalo Problém můžeme vyřešit tak, že opětovně použijeme návrhový vzor posluchač a přihlásíme se u opakovače jako čekatelé na ukončení opakování Přihlašujeme se tak, že jako další parametr metody spouštějící opakované blikání, zadáme metodu, která se má spustit po skončení opakování

26 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 26 z Lambda-výraz jako parametr příklad public void blink(int times, int period, Runnable finished) { assert isblinking() : "Blikání bylo spuštěno před ukončením předchozího"; repeater = new Repeater(); Runnable action = () -> { switchon(); IO.pause(period/2); switchoff(); IO.pause(period/2); ; Runnable blinkingfinished = () -> { repeater = null; finished.run(); ; repeater.repeat(times, action, blinkingfinished);

27 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 27 z Rozšířená verze příkladu private Repeater repeater = null; //** Zjistí, jestli dané světlo právě bliká. */ public boolean isblinking() { return repeater!= null; /** Ukončí blikání a zapomene odkaz na opakovač. */ public void stopblinking() { assert (repeater!= null) : "Pokus o ukončení neexistujícího blikání"; repeater.stop(); repeater = null; /**Požadovaný poček krát světlem blikne nezávisla na činnosti zbytku programu. * Nula krát znamená pořád, dokud nezavoláme stopblinking(). */ public void blink(int times, int period) { blink(times, period, () -> {);

28 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 28 z 54 /**Požadovaný poček krát světlem blikne nezávisla na činnosti zbytku programu, * Přičemž po ukončení blikání zavolá zadanou metodu. * Nula krát znamená pořád, dokud nezavoláme stopblinking(). */ public void blink(int times, int period, Runnable finished) { assert isblinking() : "Blikání bylo spuštěno před ukončením předchozího"; repeater = new Repeater(); Runnable action = () -> { switchon(); IO.pause(period/2); switchoff(); IO.pause(period/2); ; Runnable blinkingfinished = () -> { repeater = null; finished.run(); ; repeater.repeat(times, action, blinkingfinished);

29 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 29 z Metody jako hodnoty lambda-výrazů Jako hodnotu lambda-výrazu lze definovat i existující metodu: Cls ::mtd inst::mtd Cls ::new //printmtd = IO::inform; //printmtd = System.out::println; //factmtd = MyClass::new; Stačí název metody, protože doplnění signatury o typy parametrů vyřeší překladač podle okamžité situace Speciality: int[]::new označuje jednoparametrický konstruktor, jehož parametrem je délka zkonstruovaného pole; je to ekvivalent lambda-výrazu x > int[x]

30 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 30 z public void testbulbshape() { CM.removeAll(); lightxy = changeshape(lightxy, Rectangle::new); lightxyc = changeshape(lightxyc, Triangle::new); lightxys = changeshape(lightxys, () -> new Triangle(0, 0, 1, 1, Direction8.SOUTH_WEST)); CM.add(lightXY, lightxyc, lightxys, lightxysc);

31 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 31 z Metoda volající zadanou metodu //Kód ve třídě test\cz.pecinovsky.en_cz.uoa2_j8.aha.lambdademo /*************************************************************************** * Metoda má na starosti provedení zadané akce * spolu s oznámením jejího nastartování a ukončení. * <T> Typ parametru konzumenta description Popis druhu demonstrovaného způsobu definice metody definition Textová podoba definice metody konzumenta consumer Popsaným způsobem definovaný konzument argument Argument konzumenta */ private static <T> void report(string description, String definition, Consumer<T> consumer, T argument) { IO.inform(description + "\n\nbudeme volat metodu definovanou:\n\n" + definition); consumer.accept(argument); IO.inform("Ukončena metoda definovaná:\n\n" + definition);

32 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 32 z Použití metody report( ) //Kód ve třídě public void testconsumers() { String da; //Popis demonstrované akce String dm; //Stringová podoba definice metody Consumer<String> cs; //Konzument textových řetězců Consumer<IPaintable> cp; //Konzument zobrazitelných objektů da = "Přiřazení statické metody lambda-výrazem"; cs = (s) -> IO.inform(s); //Metoda třídy IO dm = "(s) -> IO.inform(s)"; report(da, dm, cs, dm); da = "Přímé přiřazení statické metody"; cs = IO::inform; dm = "IO::inform"; report(da, dm, cs, dm);

33 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 33 z 54 da = "Přiřazení obecné metody instance lambda-výrazem"; cs = (s) -> System.out.println(s); //Metoda instance System.out dm = "(s) -> System.out.println(s)"; report(da, dm, cs, dm); da = "Přímé přiřazení metody konkrétní instance"; cs = System.out::println; dm = "System.out::println"; report(da, dm, cs, dm); CanvasManager CM = CanvasManager.getInstance(); da = "Přiřazení metody konkrétní instance lambda-výrazem"; cp = (p) -> p.show(); dm = "(p) -> p.show()"; report(da, dm, cp, new Rectangle()); da = "Přímé přiřazení metody konkrétní instance"; cp = IPaintable::show; dm = "IPaintable::show"; report(da, dm, cp, new Ellipse());

34 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 34 z Využití konstruktoru jako tovární metody Světlo musí být schopno vytvářet své kopie máme dvě možnosti: Budeme chtít, aby tovární metoda vytvářila kopírovatelnou žárovku Využijeme toho, že máme tovární metodu, a použijeme ji při vytváření kopie Zvolíme-li druhou variantu (je jednodušší), vznikne však problém s typem ukládaného objektu (továrny) Překladač neakceptuje deklaraci private final Supplier<T extends IChangeable & IMonocolor> bulbfactory; Akceptuje však žolíkovou variantu: private Supplier<?> bulbfactory; Žolíková varianta sice zkomplikuje zadávání továrního objektu konstruktoru v těle metody copy(), ale to se dá vyřešit přetypováním na surový typ + potlačením vypisování varovných zpráv o vypnutí kontroly typových parametrů v těle této metody

35 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 35 z 54 public Light(int x, int y, int size, NamedColor color) { this(x, y, size, color, Ellipse::new); public <TC extends IChangeable & IColorable> //Kombinobaný typový parametr Light(int x, int y, int size, NamedColor color, Supplier<TC> bulbfactory) //V parametru obdržíme tovární metodu { TC bulb = bulbfactory.get(); this.color = color; this.bulbfactory = bulbfactory; this.changeablebulb = bulb; this.monocolorbulb = bulb; changeablebulb.setposition(x, y); changeablebulb.setsize(size, size); monocolorbulb.setcolor(color);

36 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 36 z 54 /** Tovární objekt na výrobu žárovek. */ private final public Light copy() { Position position = changeablebulb.getposition(); Light copy = new Light(position.x, position.y, changeablebulb.getsize().width, color, (Supplier)bulbFactory); //Je třeba přetypovat na surový typ return copy;

37 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 37 z Další syntaktická a sémantická pravidla Použití this a super v lambda-výrazech Lambda-výrazy anonymní třídy Lambda-výrazy uzávěry

38 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 38 z Použití this a super v lambda-výrazech Proměnná this použitá v lambda-výrazu se odkazuje na stejnojmenný skrytý parametr instanční metody, v níž je lambda-výraz definován Atribut super použitá v lambda-výrazu se odkazuje na stejnojmenný skrytý atribut instance, v jejíž metodě je lambda-výraz definován V lambda-výrazech definovaných ve vnitřních třídách se tak můžete odvolat na this a super příslušné vnější třídy odpovídající kvalifikací např.: EnclosingClass.this::method nebo EnclosingClass.super::method => lambda-výraz se nemůže odkázat na svůj this ani super

39 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 39 z Lambda-výrazy anonymní třídy Lambda-výrazy je vhodné použít v situacích, v nichž jsme dříve používali anonymní třídy a naopak, instance anonymních tříd lze použít místo lambda-výrazů; přesto to není totéž Na rozdíl od jiných jazyků Java nezavádí speciální typ funkcí (např.: (String, String) int)); místo toho umožňuje uložit lambda-výraz do proměnné, jejímž typem je nějaký funkční interfejs Přetypování na instanci funkčního interfejsu je také to jediné, co můžeme s lambda-výrazem udělat Lambda-výraz nelze uložit do proměnné typu Object, protože třída Object není funkční interfejs; můžeme jej ale uložit po přetypování Object o = (Object)(x -> x+1);

40 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 40 z Lambda-výrazy uzávěry Lambda-výraz má tři komponenty: Parametry Blok kódu Volné proměnné (free variables), což jsou použité lokální proměnné okolního kódu Dvojice [Blok kódu, Volné proměnné] bývá označována jako uzávěr => lambda-výrazy v Javě fungují jako uzávěry

41 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 41 z Nová koncepce konstrukce interface Obsah 3.1 Interfejs a implementace Jednoduchý diamantový problém Složitější diamantový problém Náhled přes konstanty Ukázka implicitní implementace 3.2 Speciální situace a omezení 3.3 Důsledky pro návrh architektury Použití ve standardní knihovně Ukázka použití u funkčních interfejsů 3.4 Statické metody Důsledky pro návrh architektury

42 3.1 Interfejs a implementace Java zavedla konstrukci interface jako programovou reprezentaci rozhraní Jeden z účelů byl obejití problémů při používání násobného dědění Problémy s násobnými rodiči vznikají zejména v souvislosti s násobným děděním implementace Budeme-li dědit pouze rozhraní, tj. pouze sliby, problémy v podstatě odpadají Navíc se ukázalo, že zavedením této konstrukce se otevírá celá řada nových možností v návrhu architektury Autoři některých jazyků následně ukázali, že hlavní příčinou tzv. diamantového problému je v podstatě pouze násobné dědění dat => zakážeme-li dědění dat, problémy nebudou Java proto ve verzi 8 umožňuje v definicích interfejsů uvádět i implicitní implementace metod Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 42 z 54

43 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 43 z Jednoduchý diamantový problém Při násobném dědění od společného předka dvou rodičů je třeba určit, jestli se data tohoto předka budou dědit jednou nebo dvakrát

44 3.1.2 Složitější diamantový problém Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 44 z 54

45 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 45 z Náhled přes konstanty Java umožňuje definovat v interfejsu statické konstanty Tyto konstanty nepředstavují konkrétní uložená data, jsou to především názvy, za něž se dosazují konkrétní hodnoty S nástupem lambda-výrazů lze do těchto konstant přiřazovat i kód Vzhledem k tomu, že metoda je pouze jinak zapsaný konstantní lambda-výraz, je jenom logické, že v Javě 8 lze v interfejsu definovat i metody Instanční metody s definovaným tělem se v Javě označují modifikátorem default, třídní metody se stejně jako ve třídách označují modifikátorem static Implicitní verze metod nesmí přebíjet žádnou metodu předka

46 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 46 z Ukázka implicitní implementace Definujeme metody, které by asi všichni definovali stejně public interface IMovable extends IPaintable { public Position getposition(); public void setposition(int x, int y); public default void setposition(position position) { setposition(position.x, position.y);

47 3.2 Speciální situace a omezení Objeví-li se ve stromu dědičnosti více metod se stejnou signaturou, platí následující pravidla: 1. Třída vždy vyhrává. Definuje-li rodičovská třída metodu se stejnou signaturou, jakou má implicitně definovaná metoda implementovaného interfejsu, metoda interfejsu je ignorována 2. Definují-li dva implementované interfejsy metody se shodnou signaturou, musí implementující třída vyřešit konflikt tím, že definuje vlastní verzi této metody, která přebije verze zděděné od implementovaných interfejsů, a to nezávisle na tom, jestli některá z nich (či obě) má implicitní definici. (Jinými slovy: třída se chová stejně jako před Javou 8.) Z předchozího vyplývá, že nemá smysl, aby interfejs definoval implicitní verze metod zděděných od Object, a proto tyto metody ani přebít nesmí Interfejs však může přebít implicitní metodu svého předka Interfejs nyní může obsahovat metodu main a vystupovat tak v roli hlavní třídy aplikace Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 47 z 54

48 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 48 z Důsledky pro návrh architektury Při používání klasicky navrženého interfejsu jsme museli tento interfejs velmi pečlivě navrhnout, protože jakékoliv další úpravy publikovaného interfejsu jsou zakázané Při povolení implicitních implementací deklarovaných metod můžeme dodatečně rozšiřovat funkcionalitu tříd implementujících dané interfejsy, aniž bychom museli měnit jejich kód Zavedení interfejsů s implicitní implementací nahrazuje v některých případech použití některých návrhových vzorů V řadě případů umožňuje obejít návrhový vzor Adapter (např. při návrhu posluchačů v java.awt) V dalších případech umožňuje se obejít bez použití návrhového vzoru Návštěvník (Visitor)

49 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 49 z Použití ve standardní knihovně Převážná většina interfejsů používá implicitní implementaci, v mnohých je implementovaných metod víc než těch abstraktních public interface Iterable<T> { Iterator<T> iterator(); default void foreach(consumer<? super T> action) { Objects.requireNonNull(action); for (T t : this) { action.accept(t); default Spliterator<T> spliterator() { return Spliterators.spliteratorUnknownSize(iterator(), 0);

50 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 50 z Ukázka použití u funkčních public interface BiFunction<T, U, R> { //Povinná abstraktní metoda R apply(t t, U u); //Metoda s implicitní definicí rozšiřující funkcionalitu definovaného typu //Parametrem je funkce, akceptující jako parametr návratový typ //abstraktní metody definovaného funkčního typu default <V> BiFunction<T, U, V> andthen(function<? super R,? extends V> after) { Objects.requireNonNull(after); return (T t, U u) -> after.apply(apply(t, u));

51 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 51 z Statické metody Java 8 dovoluje v interfejsu definovat statické public interface BinaryOperator<T> extends BiFunction<T,T,T> { //Vrátí operátor vracející komparátorem určenou menší ze zadaných hodnot public static <T> BinaryOperator<T> minby(comparator<? super T> comparator) { Objects.requireNonNull(comparator); return (a, b) -> comparator.compare(a, b) <= 0? a : b; //Vrátí operátor vracející komparátorem určenou větší ze zadaných hodnot public static <T> BinaryOperator<T> maxby(comparator<? super T> comparator) { Objects.requireNonNull(comparator); return (a, b) -> comparator.compare(a, b) >= 0? a : b;

52 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 52 z public interface Function<T, R> { R apply(t t); default <V> Function<V, R> compose(function<? super V,? extends T> before) { Objects.requireNonNull(before); return (V v) -> apply(before.apply(v)); default <V> Function<T, V> andthen(function<? super R,? extends V> after) { Objects.requireNonNull(after); return (T t) -> after.apply(apply(t)); static <T> Function<T, T> identity() { return t -> t;

53 3.4.1 Důsledky pro návrh architektury Možnost definovat statické metody v interfejsech osvobozuje od nutnosti definovat knihovní třídy pro skupiny tříd implementujících daný interfejs Např. řadu metod třídy Collections by bylo možno definovat jako statické metody interfejsu Collection Mnohé z knihovních metod by navíc bylo lze definovat jako instanční (např. shuffle(list), sort(list) apod.) Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 53 z 54

54 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo po :32 54 z KONEC Děkuji za pozornost Rudolf Pecinovský rudolf@pecinovsky.cz