Dynamické programovací jazyky Groovy

Transkript

1 Groovy.doc, verze , uloženo po :45 1 z 133 Dynamické programovací jazyky Groovy Mnohé příklady jsou převzaty z knihy Groovy in Action a nebo jsou touto knihou silně inspirovány

2 Groovy.doc, verze , uloženo po :45 2 z 133 Obsah 1. Předehra: Java Groovy 2. Groovy rychlý úvod do jazyka 3. Hlubší pohled na práci s daty 4. Uzávěry 5. Dynamická podstata jazyka 6. KONEC Je potřeba prověřit: V programu nefunguje V programu zlobí příkaz def (small, big) = list.split { it < 2 }

3 Groovy.doc, verze , uloženo po :45 3 z Předehra: Java Groovy Obsah 1.1 Proč nový jazyk 1.2 Dynamické jazyky charakteristika 1.3 Skriptovací jazyky 1.4 Koncepce jazyka Groovy 1.5 Dva způsoby zavedení třídy 1.6 Přehled vlastnosti jazyka Groovy 1.7 Jak Groovy získat 1.8 Co Groovy od Javy přebírá 1.9 Základní zjednodušení Skripty Podmínky Sjednocení způsobů zjištění počtu prvků v kontejneru 1.10 Co dalšího je jinak 1.11 Co Java má a Groovy (zatím) ne

4 Groovy.doc, verze , uloženo po :45 4 z Proč nový jazyk Hodně se hovoří o tzv. dynamických jazycích, které jsou populární zejména mezi začínajícími programátory Jejich zastánci si občas nepřipouštějí jejich nevýhody Nemožnost automatické refaktorace Omezená hlídání překladače, které programátoři zapomínají vyvažovat testy Dynamicky charakter jazyka vyžaduje jistou režii, která výsledný program výrazně zpomaluje (v závislosti na aktuálních operacích 4 až 20 ) Velké tlaky na úpravu (= zdynamičtění) Javy Takovéto úpravy však jazyk zbytečně nafukují a přitom zeslabují jeho robustnost Při zařazování nových funkcí se často objevují závažné problémy se zpětnou kompatibilitou Pro programování však není důležitý jazyk, ale platforma => bylo by vhodné vybudovat na danou platformou jazyk, který by: Podporoval nově se prosazující programovací techniky Bezproblémově spolupracoval s doposud vyvinutými programy Existuje řada nejrůznějších jazyků postavených nad platformou Java stačí navrhnout syntaxi a překladač i knihovnu poskytne platforma Ceylon, Closure, Groovy, JRuby, Jython, Scala,

5 Groovy.doc, verze , uloženo po :45 5 z Dynamické jazyky charakteristika Dynamické jazyky nabízejí možnost provádět za běhu operace, které statické jazyky umožňují pouze v době překladu Měnit strukturu objektů Upravovat definice datových typů, např. přidávat atributy a metody Modifikovat chování objektů změnou definice těla metody Spouštět části programu definované až za běhu Definice dynamických jazyků není jednoznačná, protože se snaží rozlišovat mezi kódem a daty a mezi dobou překladu programu a dobou jeho běhu Virtuální stroje, just-in-time překlad a schopnosti některých jazyků modifikovat kód programu za běhu činí toto dělením poněkud abstraktním Míra dynamičnosti jazyka se proto většinou odvozuje od snadnosti, s jakou je možno realizovat výše zmíněné operace Řada lidí zaměňuje dynamické jazyky s dynamicky typovanými jazyky Podrobnosti o dynamickém typování viz pasáž Dynamické typování Podrobnosti o dynamické podstatě Groovy viz pasáž 5. Dynamická podstata jazyka

6 Groovy.doc, verze , uloženo po :45 6 z Skriptovací jazyky Jako skriptovací jazyk označíme (většinou) interpretovaný programovací jazyk sloužící k ovládání jiných aplikací Skriptovací jazyky dělíme do dvou skupin Jazyky se zabudovanou podporou v operačním systému, která umožňuje v tomto jazyce přímo zadávat příkazy operačnímu systému (např. VBScript, JScript) Jazyky ovládající vyhrazenou aplikaci či skupinu aplikací (např. JavaScript) Podpora skriptovacích jazyků v operačním systému může být několika druhů Je definována speciální aplikace, která po spuštění umožní zapisovat příkazy jazyka přímo z konzoly Operační systém akceptuje zdrojový kód v daném jazyku jako spustitelný program (= skript), přičemž po spuštění tohoto programu spustí OS příslušný interpret, který zadaný program přímo interpretuje Některé jazyky se současně používají jako skriptovací a univerzální jedny (např. Perl) vznikly původně jako skriptovací a časem se rozšířily na univerzální, jiné (např. Lisp) vznikly původně jako univerzální a časem vznikly jejich dialekty používané jako skriptovací (AutoLisp, ECMALisp), další (např. Groovy) byly od samého začátku navrženy pro obě použití

7 Groovy.doc, verze , uloženo po :45 7 z Koncepce jazyka Groovy Jazyk běží nad virtuálním strojem Javy a používá knihovnu Javy, virtuální stroj nerozpozná, jestli byla třída napsaná v Javě nebo v Groovy Program může sestávat mixu z tříd napsaných v Javě a v Groovy Syntaxe Groovy je maximálně shodná s Javou, takže v optimálním případě je možno změnit jazyk pouhou změnou přípony zdrojového souboru To výrazně usnadňuje přijetí jazyka programátory pracujícími v Javě Groovy je plnohodnotný dynamický jazyk s vlastnostmi inspirovanými jazyky Smalltalk, Python, Dylan, Ruby, Perl Groovy se snaží maximalizovat své vyjadřovací schopnosti a současně podobnost své syntaxe s Javou Autoři chtěli navíc vytvořit jazyk, který by mohl být současně skriptovací V Groovy je možno velice efektivně psát dávkové soubory a různé skripty ovlivňující chování celého systému Převzato z Groovy in Action, str. 3, Fig. 1.1

8 Groovy.doc, verze , uloženo po :45 8 z 133 Groovy se nesnaží Javu nahradit, ale pouze doplnit => je zcela na vás, které části programu napíšete v Javě a které v Groovy Groovy-třídy mohou dědit z Java-tříd a naopak Programy v Groovy se překládají do standardních class-souborů; Groovy-kód lze zpětně přeložit dekompilátory Javy (nebude se ale originálu podobat a dost možná se v něm ani nevyznáte) Nástroje pro instrumentaci kódu akceptují i kód napsaný původně v Groovy Groovy je součástí ekosystému Javy byl pro něj definován Java Specification Request JSR JSR-223: Scripting for the Java Platform JSR-241: The Groovy Programming Language Groovy je druhým standardním jazykem pro platformu Java Domovská stránka Groovy: Stránka s dalšími informacemi:

9 Groovy.doc, verze , uloženo po :45 9 z Dva způsoby zavedení třídy Převzato z Groovy in Action, str. 48, Fig. 2.7

10 Groovy.doc, verze , uloženo po :45 10 z Přehled vlastnosti jazyka Groovy Bezešvá spolupráce s Javou: Převzato z Groovy in Action, str 6, Fig. 1.2, str. 10, Fig 1.4

11 Groovy.doc, verze , uloženo po :45 11 z Jak Groovy získat Groovy je součástí plné verze NetBeans; Eclipse a IDEA jej nabízí jako plug-in Instalace samostatné verze 1. Stáhnout poslední build z adresy 2. Ve Windows stačí spustit instalační soubor, v ostatních prostředích je třeba: a) Rozbalit stažený ZIP do vybrané složky/adresáře b) Definovat systémovou proměnnou GROOVY_HOME a zadat do ní cestu k této složce c) Přidat do systémové proměnné PATH cestu ke složce %GROOVY_HOME%\bin (Windows), resp. $GROOVY_HOME/bin (Unix + Linux) d) Otestovat správnost instalace zadáním příkazu groovy v Instaluje se několik programů: groovy spouští skript zadaný v parametru či souboru groovysh spouští shell umožňující komunikovat prostřednictvím konzoly groovyconsole spouští "operativní" prostředí pro jednoduché programy a testy groovyc překladač do class-souborů groovydoc vytváří dokumentaci, ekvivalent programu javadoc a některé další v závislosti na stažené verzi

12 Groovy.doc, verze , uloženo po :45 12 z Co Groovy od Javy přebírá Mechanismus balíčků a příkazy pro jejich definici (package) a import (import) Podobu příkazů a řídících struktur (podmíněné příkazy, cykly, ) s výjimkou příkazu do { } while() Definice tříd, výčtových typů, včetně interních tříd, avšak s výjimkou lokálních tříd Definice rozhraní včetně anotací Definice metod, operátory, výrazy, přiřazení Zpracování výjimek S drobnými úpravami deklarace literálů Největší rozdíl je v inicializaci polí, kde syntaxe Javy koliduje s jinými částmi Groovy a pole je proto třeba inicializovat prostřednictvím seznamů Na druhou stranu se doporučuje pole v programu nepoužívat, a dávat přednost seznamům Vytváření instancí, komunikace s objekty prostřednictvím odkazů, volání metod Syntaxi komentářů

13 Groovy.doc, verze , uloženo po :45 13 z Základní zjednodušení Groovy implicitně deklaruje importy: groovy.lang.* java.util.* groovy.util.* java.net.* java.lang.* java.io.* java.math.biginteger java.math.bigdecimal V souboru může být několik veřejných tříd a soubor se proto nemusí jmenovat podle obsažené veřejné třídy Na konci posledního příkazu na řádku není nutno psát středník Parametry volaných metod není nutno uzavírat do závorek Při zřetězeném volání metod není v řadě případů nutno používat tečky, např. paint wall with red, green and yellow je ekvivalentní klasickému zápisu paint(wall).with(red, green).and(yellow) V metodách se nemusí psát závěrečný return, automaticky se vrátí hodnota posledního výrazu/příkazu Všechny výjimky jsou převedeny na nekontrolované, je-li zachytávaná výjimka typu Exception, nemusí se v catch uvádět její typ

14 Groovy.doc, verze , uloženo po :45 14 z 133 Deklarované atributy mají automaticky definované přístupové metody, v Groovy je explicitně definujeme pouze tehdy, mají-li mít složitější tělo Zavádí literály i pro další datové typy seznamy, mapy, intervaly Všechna data jsou objektových typů, takže i čísla mají metody Zavádí nové užitečné datové typy a programové konstrukce (zejména cykly) Nechceme-li v program deklarovat typ proměnné a nechat jeho odvození na překladači, uvedeme deklaraci dané proměnné klíčovým slovem def Potřebujeme-li class-objekt, stačí napsat jméno třídy; není potřeba doplňovat.class V návěštích case příkazu switch lze použít téměř cokoliv Ve statických metodách zastupuje this odkaz na třídu, takže příkaz: println("my classobject: " + this) vytiskne zadaný text následovaný podpisem class-objektu dané třídy Cokoliv lze testovat na pravdivostní hodnotu (viz Podmínky)

15 Groovy.doc, verze , uloženo po :45 15 z Skripty Ve skriptech nemusí být příkazy uzavřeny do metody, a tím pádem ani do třídy překladač vše doplní sám current = 1; next = 1 //10.times { for (int i=0; i < 10; i++) { print current + ' ' newcurrent = next next = next + current current = newcurrent } println '' Ve skriptech nemusíme deklarovat použité proměnné stanou se automaticky lokálními proměnnými metody, kterou překladač definuje a uloží do ní veškerý kód nedefinovaný v nějaké metodě Podrobnosti o skriptech budou probrány v pasáži Specifika skriptů

16 Groovy.doc, verze , uloženo po :45 16 z Podmínky V podmínkách jsou za pravdivé jsou považovány výrazy, jejichž výsledkem je Booloean true Character char!= '\0' Collection size() > 0 Enumeration hasmoreelements() Iterator hasnext() Map size() > 0 Matcher Alespoň jeden vyhovující řetězec Number hodnota!= 0 Object[] length > 0 Jiný objekt Odkaz!= null

17 Groovy.doc, verze , uloženo po :45 17 z Sjednocení způsobů zjištění počtu prvků v kontejneru Type Zjištění velikosti v JDK a v Groovy Array atribut length size() method Array metoda size() method java.lang.reflect.array.getlength(array) String metoda length() size() method StringBuffer metoda length() size() method Collection metoda size() size() method Map metoda size() size() method File metoda length() size() method Matcher metoda groupcount() size() method

18 Groovy.doc, verze , uloženo po :45 18 z Co dalšího je jinak Operátor == vždy volá metodu equals(object). Chceme-li porovnat shodnost odkazů, musíme použít metodu is(object) Hodnoty s plovoucí čárkou jsou implicitně typy BigDecimal. Chceme-li pracovat s double, musíme u literálu uvést příponu d nebo D Implicitní přístup ke třídám, metodám a vlastnostem je nyní public ruší se implicitní přístup označovaný jako package private => zůstává pouze svatá trojice public protected private Příkaz získání hodnoty atributu, resp. přiřazení hodnoty vlastnosti (atributu) je ve skutečnosti voláním příslušné přístupové metody Groovy rozeznává více druhů textových řetězců stringů; ty mohou být uvozeny: 'apostrofy' "uvozovkami" /lomítky/ $/Dolarovými lomítky/$ '''trojicí apostrovů''' """trojicí uvozovek""" Podrobnosti v pasáži Textové literály stringy

19 Groovy.doc, verze , uloženo po :45 19 z Co Java má a Groovy (zatím) ne Cyklus do {... } while(?) Přístupová práva package private Novinky syntaxe Javy 7 (v Groovy 2.0 již jsou0 již jsou0 již jsou metoda metoda) _ Diamantový operátor: List<string> list = new ArrayList<>() Kumulované catch definující reakci na několik výjimek současně Automatizované zavírání zdrojů

20 Groovy.doc, verze , uloženo po :45 20 z Groovy rychlý úvod do jazyka Obsah 2.1 Aserce 2.2 Groovy Beans 2.3 Textové literály stringy Řetězce ohraničené apostrofy Řetězce ohraničené uvozovkami GStringy Řetězce ohraničené lomítky Řetězce ohraničené dolarovými lomítky Možnosti změny hodnoty instancí typu GString 2.4 Žádný datový typ není primitivní 2.5 Seznam List 2.6 Mapa Map 2.7 Rozsah Range Definice 2.8 Uzávěr Closure 2.9 Řídící algoritmické konstrukce Rozšíření iterovatelných objektů Interní iterátory zděděné od třídy Object Metody aplikovatelné na čísla Metoda with 2.10 Práce s čísly 2.11 Pojmenované parametry a jejich implicitní hodnoty

21 Groovy.doc, verze , uloženo po :45 21 z Aserce Programy v dynamických jazycích se musí mnohem podrobněji testovat V Groovy se hojně využívá konstrukce assert, přičemž se využívá obecněji pojaté podmínky assert true assert (x = 1) //Přiřazení výsledek je přiřazovaná hodnota assert (x == 1) //Logický výraz assert x //Aritmetická hodnota assert "Kuk" //Odkaz na objekt V Javě je assert klíčové slovo definující příkaz, pro nějž můžeme v parametrech virtuálního stroje nastavit, jestli se pro danou část programu má či nemá spouštět V Groovy není assert klíčové slov, ale metoda, která se volá pokaždé Groovy podporuje dvouparametrický assert, v němž druhý parametr specifikuje chybu; na rozdíl od Javy však není druhý parametr oddělen dvojtečkou, ale čárkou assert false, "Zde je uměle vytvořená chyba"

22 Groovy.doc, verze , uloženo po :45 22 z 133 Výrazy vyhazující výjimku //assert false //Logická hodnota //assert 0 //Číslo 0 //assert "" //Prázdný řetězce //assert null //Prázdný odkaz Výše uvedené hodnoty lze otestovat prostřednictvím jejich negace assert! null; assert! 0; assert! "" Vznikne-li při vyhodnocování argumentu funkce assert chyba, program se nám pokusí nejen vysvětlit, kde při vyhodnocování výrazu našel chybu, ale poskytne nám i informace k následnému odhalení její příčiny Exception in thread "main" Assertion failed: assert b == (a+a) false

23 Groovy.doc, verze , uloženo po :45 23 z Groovy Beans Koncept JavaBeans zavedl jisté konvence umožňující komponentový přístup k objektům Groovy používá stejné konvence jako Java, avšak zodpovědnost za definici přístupových metod bere na svá bedra překladač class Book { String title } def groovybook = new Book() Předchozí program Groovy přeloží tak, že: Definuje soukromý atribut title Definuje veřejnou metodu gettitle(), která vrátí jeho hodnotu Definuje veřejnou metodu settitle(string), která nastaví jeho hodnotu K atributu pak můžeme přistupovat zdánlivě přímo, nicméně toto přímé oslovení překladač nahradí odpovídajícím voláním přístupové metody

24 Groovy.doc, verze , uloženo po :45 24 z 133 Přímé volání metod def Book book = new Book() book.settitle("groovy conquers the world") assert book.gettitle() == "Groovy conquers the world" Nepřímé volání metod přístup prostřednictvím metod zabezpečí překladač (jinými slovy: výsledný kód je stejný jako v předchozí ukázce) book.title = "Groovy in Action" assert book.title == "Groovy in Action" book.title += '!' //Překlad: book.settitle(book.gettitle() + '!') assert book.gettitle() == "Groovy in Action!"

25 Groovy.doc, verze , uloženo po :45 25 z Textové literály stringy Řetězec ohraničený jedním apostrofem 'řetězec' Řetězec ohraničený třemi apostrofy '''řetězec''' Řetězec ohraničený jedněmi uvozovkami "řetězec" Řetězec ohraničený třemi uvozovkami """řetězec""" Řetězec ohraničený lomítky /řetězec/ Řetězec ohraničený dvojící lomítko + znak $ $/řetězec/$ Každý z těchto řetězců má vlastní sémantiku

26 Groovy.doc, verze , uloženo po :45 26 z Řetězce ohraničené apostrofy Klasický řetězec Javy pouze vyměnil ohraničující uvozovky za apostrofy a1 = 'Klasický řetězec' Řetězec uvozený třemi apostrofy je klasický řetězec, který však může zabírat několik řádků, přičemž konce řádků zadané v kódu se respektují Při používání víceřádkových řetězců se případné odsazení dalšího řádku, stane součástí výsledného řetězce => proto musí další řádek začínat zkraje a3 = '''Řetězec uvozený třemi apostrofy může zabírat několik řádků, přičemž konce řádků zadané v kódu se respektují''' Stačí-li nám rozdělit řetězec na řádky pouze ve zdrojovém kódu, můžeme jako poslední znak na řádku použít zpětné lomítko; toto odřádkování se však v zadávaném řetězci neobjeví ab = 'Zpětné lomítko na konci řádku \ nevloží odřádkování do výsledného textu' assert ab == 'Zpětné lomítko na konci řádku nevloží odřádkování do výsledného textu'

27 Groovy.doc, verze , uloženo po :45 27 z Řetězce ohraničené uvozovkami GStringy Řetězec ohraničený uvozovkami je tzv. GString ten může obsahovat výrazy, které se píší za znak $ a vyhodnocují se v době použití řetězce Je-li výraz složitější než pouhý název proměnné, vkládá se do složených závorek { } Výraz v závorkách může obsahovat i volání metod pr = 'proměnnou'; slo='složitý'; vý='výraz' u1 = "GString může vyhodnocovat $pr či celý ${slo + " " + vý.tolowercase()}" I uvozovkami ohraničené řetězce mají svojí trojitou verzi umožňující zapsat řetězec obsahující několik řádků u3 = """Odvoláváme li se pouze na $pr, nemusíme její název psát do závorek, Ty využijeme až když chceme vyhodnotit ${slo + " " + vý.tolowercase()}""" Zpětné lomítko na konci řádku máme k dispozici i v řetězcích ohraničených uvozovkami; ani zde se v zadávaném řetězci odřádkování neobjeví ub = " Zpětné lomítko na konci řádku, \ se ve výsledku neprojeví" assert ub == "Zpětné lomítko na konci řádku, se ve výsledku neprojeví"

28 Groovy.doc, verze , uloženo po :45 28 z Řetězce ohraničené lomítky Zpětné lomítko se v nich nemusí zadávat jako dvojice zpětných lomítek (je to zde běžný znak), a proto se používají především k zadávání regulárních výrazů Lomítko se v nich zadá pomocí escape sekvence \/ Kromě lomítka znají ještě escape sekvence \uhhhh Mohou obsahovat dolarové výrazy Od verze 1.8 jsou více řádkové, tj. ve vztahu ke konci řádku ve zdrojovém kódu se chovají jako trojité verze předchozích řetězců lo = /Zpětná lomítka (\) zde nemusíme zdvojovat. Tyto řetězce považují zpětné lomítko za prefix pouze tehdy, je li následované dopřeným lomítkem (\/ pak je dvojice chápána jako lomítko), anebo znakem 'u' např. znak \u00a9 je vyhodnocen jako./ l$ = /I zde lze použít výraz s $pr či celý ${slo + " " + vý}/

29 Groovy.doc, verze , uloženo po :45 29 z Řetězce ohraničené dolarovými lomítky Tyto řetězcové literály zavedlo Groovy 1.8 Ohraničíme-li lomítkový řetězec navíc znaky $ (dolar), změníme tím standardní escapovací znak \ na znak $ Znak $ bude uvozovat lomítko či sám sebe Znak \ bude nyní uvozovat pouze sekvenci \uhhhh $l = $/Znak dolar nyní píšme $$ a lomítko $/ avšak znak \u00a9 je nadále vyhodnocován jako /$

30 Groovy.doc, verze , uloženo po :45 30 z Možnosti změny hodnoty instancí typu GString Apostrofové řetězce jsou instancemi třídy java.lang.string Uvozovkové řetězce obsahující dolarové výrazy jsou instancemi třídy org.codehaus.groovy.runtime.gstringimpl, po vyhodnocení výrazů se vytvářejí instance třídy String Při používání GString-ů je třeba mít na paměti, že parametry se předávají hodnotou, takže má-li se hodnota parametru měnit v průběhu výpočtu, musí být parametr instancí nějakého proměnného typu Druhou možností je předat bezparametrický uzávěr např. ${ > string} Podrobnosti o uzávěrech viz pasáž 2.8 Uzávěr Closure Příklad k předchozímu tvrzení uvedený na další stránce demonstruje: Objekty typu String jsou neměnné, takže jakákoliv změna vede k vytvoření nového objektu Objekty typu StringBuilder jsou proměnné, takže GStringy, které je používají, mohou v průběhu času měnit svoji hodnotu Objekty typu String se dají použít jako proměnně, jsou-li správně uzavřené v dolarových závorkách

31 Groovy.doc, verze , uloženo po :45 31 z 133 str = 'oves' ;assert str instanceof String buf = new StringBuffer('oves') ;assert buf instanceof StringBuffer us = "Skákal pes přes $str" ub = "Skákal pes přes $buf" uc = "Skákal pes přes ${ >str}" assert us == 'Skákal pes přes oves' assert ub == 'Skákal pes přes oves' assert uc == 'Skákal pes přes oves' str = 'zelenou louku' buf.replace(0, 5, 'zelenou louku') assert us == 'Skákal pes přes oves' assert ub == 'Skákal pes přes zelenou louku' assert uc == 'Skákal pes přes zelenou louku'

32 Groovy.doc, verze , uloženo po :45 32 z 133 Při volání metody se situace zjednodušuje, protože při každém volání se řetězec vyhodnocuje znovu, takže není třeba zabezpečovat změnu def method(param) { return "Parametr: $param" } assert method(1) == 'Parametr: 1' assert method('groovy') == 'Parametr: Groovy'

33 Groovy.doc, verze , uloženo po :45 33 z Žádný datový typ není primitivní Všechny hodnoty primitivních typů se chovají jako objekty, takže jim lze posílat zprávy = volat jejich metody def s = '' 3.times { s += 'bu' } assert s == 'bububu' def x = 1 assert x instanceof Integer Operátory jsou ve skutečnosti definovány jako metody => použití operátoru nebo zavolání odpovídající metody má proto stejný efekt def x = 1 def y = 2 assert x + y == 3 assert x.plus(y) == 3 assert (x y) * y == 2 assert x.minus(y).multiply(y) == 1

34 Groovy.doc, verze , uloženo po :45 34 z Seznam List Skupina čárkami oddělených hodnot v hranatých závorkách je chápána jako literál seznamu => seznam tak můžeme inicializovat přímo v deklaraci K prvkům seznamů můžeme přistupovat prostřednictvím indexů obdobně, jako přistupujeme k prvkům pole def roman = ['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII'] assert roman[4] == 'IV' //Přístup k prvku seznamu roman[8] = 'VIII' //Přidání prvku do seznamu assert roman.size() == 9 Seznam se automaticky konvertuje na objekt libovolného typu tak, že překladač zavolá konstruktor, jemuž se prvky seznamu předají jako parametry (třída samozřejmě musí daný konstruktor mít) java.awt.point point = [10, 20] // Ekvivalentní new Point(10, 20) assert point.tostring() == 'java.awt.point[x=10,y=20]' list = [100, 200] point = list assert point.tostring() == 'java.awt.point[x=100,y=200]'

35 Groovy.doc, verze , uloženo po :45 35 z 133 Hodnoty seznamu lze přiřadit členům skupiny proměnných uzavřených v závorkách list = [10, 'xxx', true] (a, b, c) = list assert (a==10) && (b=='xxx') && c (c, b, a) = ['third', 'second', 'first'] assert (a=='first') && (b=='second') && (c=='third') Přebytečné prvky v seznamu se zahodí, chybějící se přiřadí jako null (k, l, m) = [1,2,3,4] assert (k==1) && (l==2) && (m==3) (x, y, z) = [10,20] assert (x==10) && (y==20) && (z==null)

36 Groovy.doc, verze , uloženo po :45 36 z Mapa Map Skupina čárkami oddělených dvojic hodnot, které jsou vzájemně odděleny dvojtečkou, je chápána jako literál mapy => i mapy lze inicializovat přímo v deklaraci V této definici je objekt vlevo od dvojtečky chápán jako klíč a objekt vpravo od dvojtečky jako hodnota Mapu můžeme inicializovat přímo v deklaraci jako seznam dvojic klíč : hodnota def http = [ //Deklarace inicializované mapy 100 : 'CONTINUE', 200 : 'OK', 400 : 'BAD REQUEST' ] assert http[200] == 'OK' //Prvek indexujeme hodnotou klíče http[200] = 'YES' //Změna hodnoty existujícího prvku http[500] = 'INTERNAL SERVER ERROR' //Přidání prvku do mapy assert http.size() == 4

37 Groovy.doc, verze , uloženo po :45 37 z 133 Mapa se automaticky převede na jiný typ tak, že překladač zavolá jeho bezparametrický konstruktor a poté přiřadí hodnoty prvků mapy stejně pojmenovaným atributům Cílový typ musí mít bezparametrický konstruktor, nastavované atributy mohou být soukromé, ale nesmějí být konstantní, java.awt.point point = [y:20, x:10] // Ekvivalentní new Point(10, 20) assert point.tostring() == 'java.awt.point[x=10,y=20]' map = [x:100, y:200] point = map assert point.tostring() == 'java.awt.point[x=100,y=200]' class MappedClass { private int x, y, z; } String tostring() { return "MappedClass[x=$x, y=$y, z=$z]" } MappedClass mc = [y:200, z:300] //Hodnota x se nezmění assert mc.tostring() == 'MappedClass[x=0, y=200, z=300]'

38 Groovy.doc, verze , uloženo po :45 38 z Rozsah Range Rozsahy nejsou ve standardní knihovně Javy, Groovy je přidává Literálem rozsahu je dvojice porovnatelných hodnot oddělených dvěma tečkami; tyto hodnoty budeme označovat jako dolní a horní mez Je-li před druhou hodnotou menšítko, nepočítá se horní mez do rozsahu def x = 1..10; def y = 1..<10 assert x.contains(10); assert y.contains(9) assert x.contains(15) == false; assert y.contains(10) == false assert x.size() == 10; assert y.size() == 9 assert x.from == 1; assert y.from == 1 assert x.to == 10; assert y.to == 9 assert x.reverse() == 10..1; assert y.reverse() == 9..1 Rozsahy lze s jistou rezervou považovat za seznamy s posloupností hodnot def numberlist = [1,2,3,4,5,6,7,8,9,10] def numberrange = assert numberlist == numberrange //Jsou ekvivalentní, ale každý jiného typu assert (numberlist.class == ArrayList) && (numberrange instanceof Range)

39 Groovy.doc, verze , uloženo po :45 39 z Definice Rozsahy mohou být definovány nad libovolným uspořádaným typem, tj. typem, který: Definuje metody next() and previous(), resp. operátory ++ a vracející následníka, resp. předchůdce dané instance Implementuje java.lang.comparable, takže definuje metodu compareto, resp. ekvivalentní operátor <=> (spaceship operator) Přítomnost prvku v rozsahu zjišťujeme operátorem in: if (objekt in rozsah) Tentýž operátor lze použít v cyklu for místo dvojtečky enum DAY { Sun, Mon, Tue, Wed, Thu, Fri, Sat } working = DAY.Mon..DAY.Fri report = '' for (day in working) { report += day.tostring() + ' ' } assert report == 'Mon Tue Wed Thu Fri '

40 Groovy.doc, verze , uloženo po :45 40 z Uzávěr Closure Myšlenka, že funkce (a obecně část kódu) je běžným objektem jazyka stejně jako např. číslo, byla implementována již v roce 1958 v jazyce LISP Teoretickým základem je tzv. λ-kalkulus zavedený Churchem v roce 1936 V klasických procedurálních jazycích (Fortran Algol Pascal ) jsou procedury a funkce definovány jako zvláštní entity, které není možné uložit do proměnných Moderní programovací jazyky se snaží znovu začít pracovat s částmi kódu jako s entitami postavenými na roveň datům Termín uzávěr (closure) označuje skutečnost, že takováto část kódu musí nějakým způsobem uzavřít proměnné, s nimiž bude pracovat, aby nebyly v nevhodnou chvíli systémem odstraněny V OO jazycích nepoužívajících uzávěry se funkčnost uzávěrů nahrazuje použitím návrhového vzoru Příkaz (Command), který zabalí do objektu příslušnou část kódu jako metodu daného objektu Příklad: java.io.file.list(filenamefilter) Nevýhodou tohoto přístupu je zbytečný nárůst počtu explicitně definovaných datových typů (třída + rozhraní) a výrazně zašuměný zdrojový kód

41 Groovy.doc, verze , uloženo po :45 41 z 133 V příkladu na obrázku je volána metoda each(groovy.lang.closure) seznamu, což je metoda, o níž Groovy rozšiřuje portfolio metod třídy Object. Tato metoda vyžaduje jako svůj parametr uzávěr, který definuje, co se má udělat s každým z prvků daného iterovaného objektu Zobrazené volání využívá pravidla, že má-li metoda jako svůj poslední parametr uzávěr, nemusí jej uvádět v seznamu parametrů, ale může jej uvést až za ním V tomto případě byl uzávěr jediným parametrem, takže seznam klasických parametrů zcela chybí Převzato z Groovy in Action, str 44, Fig. 1.2

42 Groovy.doc, verze , uloženo po :45 42 z 133 Uzávěry mají své parametry vyjmenované za otevírací složenou závorkou a oddělené od vykonávaného kódu šipkou > Je-li parametr jen jeden, nemusí se uvádět a použije se pro něj implicitní název it list1 = [1, 3, 5, 7] list2 = list1.collect{ it *= 2 } //Vyrobí ze zpracovaných hodnot seznam assert list2 == [2, 6, 10, 14] Není-li parametr žádný, napíše se samotná šipka: { > kóduzávěru } Takovýto uzávěr byl použit např. v ukázce vyhodnocování GString-ů Podrobněji se k uzávěrům vrátíme v samostatné kapitole Uzávěry

43 Groovy.doc, verze , uloženo po :45 43 z Řídící algoritmické konstrukce Konstrukce if, while, switch a klasický cyklus for(inicializace, podmínka, modifikace) fungují jako v Javě def list = [] for (int j=0; j < 5; j++) { list += j } assert list == [0, 1, 2, 3, 4] Cyklus do { } while( ) nelze použít, Groovy nezná klíčové slovo do Dvojtečkový cyklus for (cyklus for each) nahrazuje dvojtečku slovem in string = '' for (num in 0..9) { string += num } assert string == ' '

44 Groovy.doc, verze , uloženo po :45 44 z Rozšíření iterovatelných objektů Groovy výrazně rozšiřuje paletu iterovatelných objektů; iteruje se podle následujících pravidel (a priorit): 1. java.util.iterator... Použije jej 2. org.w3c.dom.nodelist... Iterace přes uzly 3. java.util.enumeration... Převede jej na Iterator 4. java.util.regex.matcher... Iterace přes výskyty 5. Metoda iterator... Zavolat 6. Collections... Collection.iterator 7. java.util.map... Iterace přes objekty Map.Entry 8. Array... Iterace přes prvky 9. MethodClosure... Iterace přes volání 10. java.lang.string... Iterace přes znaky 11. java.io.file... Iterace přes řádky 12. null... Prázdný iterátor 13. Ostatní... Použije se pouze daný objekt