Vysoká škola ekonomická v Praze Fakulta informatiky a statistiky Katedra informačních technologií
Student
: Oleksandr Matviichuk
Vedoucí bakalářské práce Oponent bakalářské práce
: Ing. Rudolf Pecinovský, CSc. : Ing. Jarmila Pavlíčková
TÉMA BAKALÁŘSKÉ PRÁCE
GUI pro interaktivní spouštění metod ze zásuvného modulu BJ2NB pro NetBeans
ROK : 2011
Prohlášení Prohlašuji, že jsem bakalářskou práci zpracoval samostatně a že jsem uvedl všechny použité prameny a literaturu, ze kterých jsem čerpal.
V Praze dne 30.06.2011
.......................... .......................... podpis
2
Poděkování Úvodem bych rád poděkoval svému vedoucímu práce, panu Ing. Rudolfu Pecinovskému, CSc., za odborné vedení, rady a pomoc při tvorbě této práce. Také bych rád poděkoval své manželce za trpělivost a podporu jak při studiu, tak při tvorbě této práce.
3
Abstrakt Tato bakalářská práce je součástí projektu BJ2NB (BlueJ-2-NetBeans). Cílem projektu je vytvoření zásuvného modulu pro NetBeans, který umožní ve vývojovém prostředí NetBeans realizovat řadu přístupů k práci, běžně používaných v prostředí BlueJ. Tato práce se zabývá vytvořením grafického uživatelského rozhraní, které by umožňovalo interaktivní spouštění metody z daného zásuvného modulu. Práce je rozdělena na tři části. V první části je provedena analýza přístupů, používaných k realizaci interaktivního režimu na platformě Java. Analýza je zaměřena hlavně na existující vývojová prostředí, ve kterých je interaktivní režim už realizovaný. Na základě analýzy v druhé části práce byl vytvořen návrh grafického uživatelského rozhraní. Jeho implementace je dostupná jako příloha této práce. Poslední část obsahuje uživatelskou příručku. Klíčová slova: zásuvný modul, interaktivní režim práce, Java, GUI, BlueJ, NetBeans.
Abstract This bachelor thesis is a part of BJ2NB project (BlueJ-2 NetBeans). The project aims to create a plugin for NetBeans that would allow the NetBeans IDE to implement a number of approaches to work, commonly used in the BlueJ environment. The thesis deals with creating a graphical user interface that would allow an interactive mode of running the methods. The work is divided into three parts. The first part is an analysis of approaches used to implement an interactive mode on Java platform. The analysis is focused mainly on the existing development environments that have interactive mode already implemented. Based on the analysis in the second part a design of graphical user interface was created. Its implementation is available as a supplement to this work. The last part contains the user guide. Keywords: plug-in, interactive mode of operation, Java, GUI, BlueJ, NetBeans.
4
Obsah Úvod ................................................................................................................................................... 6 1 Přístupy k realizaci interaktivního režimu práce na platformě Java. .................................................. 7 1.1 Realizace interaktivního režimu práce ve vývojových prostředích ............................................. 7 1.1.1 DrJava ................................................................................................................................ 8 1.1.2 BlueJ .................................................................................................................................10 1.1.3 jGRASP ............................................................................................................................14 1.1.4 Shrnutí...............................................................................................................................18 1.2 Možnosti skriptování na platformě Java ....................................................................................19 1.2.1 Groovy ..............................................................................................................................19 1.2.2 Další skriptovací jazyky pro platformu Java.......................................................................22 2 Analýza požadavků a návrh modulu GUI ........................................................................................23 2.1 Požadavky na funkčnost ...........................................................................................................23 2.2 Případy užití .............................................................................................................................23 2.3 Balíčková struktura pluginu BJ2NB .........................................................................................28 2.3.1 Rozhraní modulu Mediator ................................................................................................28 2.3.2 Rozhraní modulu Executor ................................................................................................29 2.3.3 Rozhraní modulu Interactor...............................................................................................30 2.4 Balíčková struktura modulu Interactor ......................................................................................31 2.4.1 Balíček api.........................................................................................................................31 2.4.2 Balíček gui ........................................................................................................................32 2.4.3 Balíček tree .......................................................................................................................33 2.4.4 Balíček utils.......................................................................................................................34 2.4.5 Balíček mockmediator .......................................................................................................34 2.4.6 Balíček mockexecutor .......................................................................................................35 2.4.7 Balíček helper ....................................................................................................................36 3. Uživatelská příručka.......................................................................................................................37 3.1 Spuštění modulu .......................................................................................................................37 3.2 Zobrazení seznamu tříd ............................................................................................................37 3.3 Volání statických metod ...........................................................................................................38 3.4 Prohlížení statických atributů třídy ...........................................................................................41 3.5 Vytváření samostatných instancí ..............................................................................................41 3.6 Zobrazení seznamu vytvořených instancí..................................................................................42 3.7 Volání instančních metod .........................................................................................................42 3.8 Prohlížení instančních atributů .................................................................................................42 3.9 Odstranění instancí ...................................................................................................................43 3.10 Operace s objekty typu pole....................................................................................................43 3.11 Vyhodnocování výrazů ...........................................................................................................44 3.12 Ukončení modulu ...................................................................................................................44 Závěr .................................................................................................................................................45 Zdroje ................................................................................................................................................46 Terminologický slovník .....................................................................................................................48 Seznam příloh ....................................................................................................................................50
5
Úvod Cílem této práce je vytvořit grafické uživatelské rozhraní (GUI1) k zásuvnému modulu pro IDE2 NetBeans [4], které by umožňovalo interaktivně pracovat s třídami a objekty. Pod pojmem interaktivní práce rozumíme možnost vytvářet samostatné instance, volat metody, zkoumat vlastnosti tříd a instancí bez nutnosti spouštět celý vyvíjený program. Příkladem IDE, které podporuje interaktivní režim práce, je BlueJ [5]. Avšak jde o IDE zaměřené hlavně na výuku programování, které není vhodné pro vývoj velkých profesionálních projektů. NetBeans je populární vývojové prostředí pro Javu a řadu dalších programovacích jazyků, jejichž vývoj podporuje společnost Oracle. NetBeans je robustní nástroj, pomocí kterého programátoři mohou psát, překládat a ladit programy, ale možnost interaktivní práce v něm prozatím chybí. Proto vznikl projekt BJ2NB (BlueJ-2-NetBeans) s cílem vytvořit plugin3, který by v IDE NetBeans umožňoval používat interaktivní koncept práce s třídami a objekty. Projekt BJ2NB se skládá ze čtyř modulů 4: Mediator (napojení na platformu NetBeans), Executor (zprostředkování interaktivního režimu), Editor (kreslení diagramu tříd) a Interactor (GUI pro práci v interaktivním režimu). Tato práce se zabývá návrhem a implementací modulu Interactor.5 Práce je rozdělena na tři části. První část analyzuje přístupy k realizaci interaktivního režimu práce na platformě Java. Analýza je hlavně zaměřena na realizaci interaktivního režimu ve stávajících vývojových prostředích. Ale pokud se jedná o interaktivní práci, nelze se nezmínit o skriptovacích jazycích6. Problematika skriptovacích jazyků pro platformu Java je velmi rozsáhlá, mohla by být tématem samostatné bakalářské práce. Proto jsem se v této práci omezil na několik praktických ukázek v Groovy [6], nejpopulárnějším skriptovacím jazyce pro platformu Java. Okrajově jsou zmíněny další jazyky s uvedením zdrojů, ze kterých zájemci mohou čerpat další informace. Výsledky analýzy byly použity v druhé části práce pro návrh modulu GUI a jeho následnou implementaci. Třetí část obsahuje uživatelskou příručku vytvořeného modulu GUI. Přínosem práce je vytvoření grafického uživatelského rozhraní pro interaktivní spouštění metod objektů v NetBeans, které usnadní vývoj aplikací jak zkušeným, tak i začínajícím programátorům. Posledním navíc může usnadnit přechod z jednoduchého výukového IDE do profesionálního robustního prostředí. Práce předpokládá základní znalost programovacího jazyka Java a zásad objektově orientovaného programování.
1
GUI (Graphic User Interface) – všeobecně používaná zkratka pro pojem „grafické uživatelské rozhraní―, viz terminologický slovník. 2 IDE – integrované vývojové prostředí, viz terminologický slovník. 3 Plugin nebo plug-in – zásuvný modul, který rozšiřuje funkčnost aplikace, viz terminologický slovník. 4 Pojem modul v této práci využívám pro označení skupiny balíčků, které spolu zajišťují určitou funkcionalitu pluginu BJ2NB, například kreslení digramu tříd. 5 V této práci pojmy modul Interactor a modul GUI označují totéž. 6 Skriptovací jazyk – interpretovaný programovací jazyk, viz terminologický slovník.
6
1 Přístupy k realizaci interaktivního režimu práce na platformě Java. 1.1 Realizace interaktivního režimu práce ve vývojových prostředích V současné době nejpopulárnější profesionální vývojová prostředí pro Javu (Netbeans [4], Eclipse [7], IntelliJ IDEA [8]) neobsahují nástroje na interaktivní spouštění metod, a tak programátor, aby vyzkoušel své změny do zdrojového kódu, často musí spouštět celou aplikaci, což v případě rozsáhlé aplikace může trvat relativně dlouhou dobu. Další nevýhodou podobného přístupu je nepřehlednost složitých aplikací, kde přes chování celé aplikace je těžko zjistit chování jednotlivé metody.7 Kromě toho, aby aplikace byla spustitelná, programátor musí implementovat spouštěcí metodu (main), což v řadě případů může být zbytečné. V praxi jsem zaznamenal případ, kdy programátor musel napsat malý program jenom proto, aby ověřil jeden regulérní výraz. Znamená to, že aby vyzkoušel jenom jeden řádek kódu, programátor musel napsat minimálně spouštěcí metodu a zabalit ji do nějaké třídy, protože Java nepovoluje metody, které by nepatřily do žádné třídy. Pokud by tento programátor měl k dispozici nějaký nástroj pro interaktivní práci na platformě Java (například interaktivní konzoli v IDE), nemusel by psát zbytečný kód a ušetřil by čas. Výše zmíněné problémy obvykle nejsou kritické pro profesionální programátory, ale mohou vytvořit těžko překonatelnou překážku pro začínající programátory a jejich školitele. Proto, na rozdíl od profesionálních analogů, IDE zaměřená hlavně na výuku objektově orientovaného programování často obsahují podporu interaktivního režimu. Následující část této práce analyzuje realizaci interaktivního režimu ve třech podobných IDE: DrJava [9], BlueJ [5] a jGRASP [10] 8. Pořadí, ve kterém uvádím každé IDE, je určené mírou pokročilosti interaktivního režimu v tomto IDE: od nejjednoduššího v DrJava do nejpokročilejšího v jGRASP. Prostředí BlueJ má českou lokalizaci, avšak zbývající dvě IDE ji nemají. Proto jsem se rozhodl použít anglickou verzi BlueJ, aby rozdíl v lokalizaci neovlivnil výsledky analýzy. Analýza je zaměřena jenom na realizaci interaktivního režimu, na žádné další komponenty a vlastnosti IDE nebyl brán zřetel. Proto výsledek v žádném případě nelze interpretovat jako kompletní srovnání výše zmíněných IDE. Cílem analýzy je prozkoumat různé přístupy k realizaci interaktivního režimu v analyzovaných IDE tak, aby v druhé části práce bylo možné použít získané poznatky při navrhování GUI pro interaktivní spouštění metod ze zásuvného modulu BJ2NB pro NetBeans IDE.
7
Tento problém lze řešit například pomocí logování, ale vyhledávání v log souborech příslušného záznamu je mnohem méně přehledné než interaktivní spouštění jednotlivých metod a zkoumání jejich chování. 8 Samozřejmě existují i další podobné aplikace, například Alice nebo Greenfoot, více informací v [11]. Do analýzy nebyly zahrnuty z důvodu, že nenabízí úplné možnosti jazyka Java.
7
1.1.1 DrJava Aplikace DrJava [9] je jednoduché IDE, ve kterém je interaktivní režim realizován jenom přes textové rozhraní v podobě interaktivního panelu ve spodní části okna aplikace. Interaktivní panel umožňuje uživateli zadávat instrukce v jazyce Java a po stisknutí klávesy <Enter> pozorovat výsledky jejich vykonání (viz obr. 1).
Obr. 1: Interaktivní panel v IDE DrJava Instrukce mohou být jak jednořádkové (například vytvoření nové instance nebo volání metody), tak i víceřádkové, například cykly nebo definice třídy. U víceřádkových příkazů je DrJava schopný rozpoznat nedokončenou instrukci. V takovém případě zmáčknutí klávesy <Enter> bude interaktivní panel interpretovat jako odřádkování. V interaktivním panelu je možné přímo používat třídy ze souborů, které jsou otevřené v editoru, a třídy z balíčku java.lang. Ostatní třídy je nutné předem importovat příkazem import. Pokud tak uživatel neučiní, DrJava vypíše chybové hlášení a pokusí se uživateli pomoci. Ve speciálním dialogu zobrazí seznam možných tříd (viz obr. 2), pak na základě uživatelského výběru automaticky doplní chybějící „import― (třídu nebo celý balíček) před instrukci, která selhala, a následně se tuto instrukci opětovně pokusí zpracovat (viz obr. 3).
Obr. 2: Dialogové okno pro automatické importování tříd
8
Obr. 3: Automatické importování tříd v interaktivním panelu Z obrázků 1 a 3 je vidět, že interaktivní panel používá různé nástroje pro zlepšení přehlednosti a čitelnosti textu, například barevné zvýraznění syntaxe nebo znak „>―, který slouží ke zvýraznění řádků s uživatelskými příkazy. Pokud spouštěná instrukce vyžaduje načtení dat z konzole, oblast, do které uživatel musí zadávat data, je zvýrazněna obdélníkem (viz obr. 4). Podle oficiální uživatelské příručky by zadávání dat mělo probíhat ve speciálním dialogovém okně.9 Další zajímavé možnosti lze nalézt v místní nabídce interaktivního panelu; jsou to hlavně funkce pro práci s historií instrukcí. Aktuální historii10 lze uložit do textového souboru. Ze souboru pak lze načíst a spouštět celou historii nebo jenom vybrané instrukce. V druhém případě se v pravé části panelu objeví tlačítka pro navigaci v historii a spouštění zvolené instrukce (viz obr. 5). Další užitečnou možností v místní nabídce interaktivního panelu je přímé kopírování aktuální instrukce do editoru zdrojového kódu. Ušetří to čas programátorům, kteří nejdříve píší a testují kód v interaktivním panelu a potom ho kopírují do editoru.
Obr. 4: Načtení dat z konzole
Obr. 5: Vykonání jednotlivé instrukce ze souboru Interaktivní panel je dobře vypracovaný nástroj, ale z uživatelského hlediska rozhraní příkazového řádku je mnohem méně příjemné než grafické, proto realizaci interaktivního režimu v DrJava lze ohodnotit za nepohodlnou.
9 10
Pravděpodobně v posledních verzích došlo ke změně chování aplikace, ale dokumentace nebyla aktualizovaná. Výchozí nastavení umožňuje uložit do 500 posledních instrukcí.
9
1.1.2 BlueJ BlueJ [5] je interaktivní IDE, vyvinuté hlavně pro účely výuky objektově orientovaného programování, vhodné ale i pro vývoj malých projektů. Na rozdíl od DrJava v BlueJ je interaktivní režim realizován hlavně přes grafické rozhraní. Interaktivní panel také existuje, ale podle výchozího nastavení je schovaný. Dvě nejdůležitější komponenty interaktivního grafického rozhraní (viz obr. 6) jsou diagram tříd a zásobník odkazů.11 Diagram tříd zobrazuje strukturu projektu v podobě velmi zjednodušeného UML12 modelu. Tato komponenta zabírá největší část okna BlueJ. Ve spodní části okna se nachází druhá nejdůležitější součást interaktivního prostředí – zásobník odkazů, který zobrazuje vytvořené instance. Interakce se uskutečňují přes místní nabídku tříd a instancí (viz obr. 7). Místní nabídka třídy obsahuje seznam veřejných konstruktorů, seznam veřejných statických metod, položku „Inspect―, která umožňuje prohlížet statické atributy, a několik dalších položek. Samozřejmě u tříd, které nemají žádné veřejné konstruktory nebo statické metody, bude místní nabídka kratší. K tomu, aby byla vytvořena nová instance, musí uživatel vybrat příslušný konstruktor, pak v dialogovém okně zadat jméno pro novou instanci a parametry konstruktoru (viz obr. 8). Nová instance se zobrazí v zásobníku odkazů. Místní nabídka instance obsahuje na začátku podnabídky s metodami předků13, pak vlastní metody a položky pro prohlížení atributů a odstranění instance ze zásobníku odkazů.
11
V angličtině se tato komponenta nazývá „object bench―. Do češtiny to autoři překládají různými způsoby: zásobník odkazů, seznam objektů, seznam referencí atd. V této práci budu používat první variantu překladu. 12 UML – Unified modeling language je grafický jazyk pro navrhování softwaru. Viz terminologický slovník. 13 Každá třída v Javě je potomkem třídy Objekt, proto první položka kontextového menu jakékoliv instance je podnabídka „Inherited from Object―(v české verzi „zděděno z Object―)
10
Obr. 6: Interaktivní prostředí BlueJ
Obr. 7: Místní nabídka třídy (zleva) a instance (zprava) v BlueJ Aby mohl uživatel vyvolat metodu, musí ji vybrat v místní nabídce příslušné třídy. U parametrických metod se před spouštěním zobrazí dialogové okno pro zadání parametrů, které je podobné oknu konstruktoru, ale s jediným podstatným rozdílem: neobsahuje políčko pro zadávání jména instance. Pokud metoda vrací nějakou hodnotu (viz obr. 9), ta se zobrazí ve speciálním dialogovém okně. Návratové hodnoty odkazových datových typů lze prohlížet nebo zařadit do zásobníku odkazů.
11
Obr. 8: Vytvoření nové instance v BlueJ
Obr. 9: Výsledek volání metody v BlueJ
12
Prohlížení atributů je důležitá součást interaktivního režimu. BlueJ umožňuje prohlížet atributy instancí (viz obr. 10) a statické atributy tříd (viz obr. 11) bez ohledu na to, jestli jsou soukromé nebo veřejné. Rozdíl ale je v tom, že veřejné atributy odkazových typů lze dále prohlížet nebo zařazovat do zásobníku odkazů, kdežto u soukromých atributů to možné není.
Obr. 10: Prohlížení atributů instance v BlueJ
Obr. 11: Prohlížení atributů třídy v BlueJ BlueJ také obsahuje interaktivní panel, ale ten je považován za druhořadý nástroj a podle výchozího nastavení je schovaný. Nastavit zobrazení interaktivního panelu lze v menu „View― zaškrtnutím políčka „Show Code Pad―. Interaktivní panel se zobrazí ve spodní části okna a zabere část plochy u zásobníku odkazů. Funkcionalita interaktivního panelu v BlueJ je v porovnání s analogem v DrJava omezenější. V BlueJ nejsou podporované pokročilé funkce, jako automatické importování tříd nebo práce s historií instrukcí. Načtení dat z konzole nebo vypisování dat na konzoli se provádí ve zvláštním okně terminálu, což je podle mého názoru nepřehledné. V interaktivním panelu lze pracovat s objekty ze zásobníku odkazů. Objekty vytvořené v panelu nebo získané odkazy lze přetáhnout do zásobníku odkazů technikou drag-and-drop14 (viz obr. 12).
Obr. 12: Přetažení objektu z interaktivního panelu do zásobníku odkazů Celkovou realizaci interaktivního režimu práce v IDE BlueJ hodnotím jako výbornou. Je velmi funkcionální, ale současně je intuitivně srozumitelná.
14
Drag-and-drop – přetahování objektů v GUI pomocí myši. Viz terminologický slovník.
13
1.1.3 jGRASP jGRASP [10] je další IDE, zaměřené primárně na výuku programování, které se ale co do složitosti už blíží více k profesionálním IDE. Stejně jako v BlueJ, interaktivní režim práce je realizován hlavně přes grafické rozhraní (UML diagram, zásobník odkazů15 a nástrojová lišta). Prostředí jGRASP je zobrazeno na obr. 13:
Obr. 13: Prostředí jGRASP Vytvořit novou instanci nebo zavolat statickou metodu třídy lze více způsoby. První způsob je využít místní nabídku třídy v UML diagramu (viz obr. 14). Na rozdíl od BlueJ jGRASP nezobrazuje konstruktory a statické metody přímo v místní nabídce třídy. K tomu slouží speciální dialogové okno (viz obr. 15) pro výběr vhodného konstruktoru nebo metody a zadání příslušných parametrů.
15
V terminologii jGRASP se zásobník odkazů jmenuje Workbench
14
Obr. 14: Kontextové menu třídy v jGRASP
Obr. 15: Vytvoření nové instance
Druhý způsob, jak vytvořit instanci nebo zavolat statickou metodu, je možnost použít nástrojovou lištu aplikace (viz obr. 16). Předposlední ikona (modrý čtverec) slouží k vytváření nových instancí, poslední ikona (částečně zelený čtverec) je určena k volání statických metod.
Obr. 16: Nástrojová lišta jGRASP Třetí způsob spočívá v použití menu Build->Java Workbench (viz obr. 17). Z obrázku je vidět řadu pokročilých interaktivních funkcí, jako možnost vytvářet pole (array) objektů zadané třídy nebo možnost interaktivně pracovat s třídami ze standardní knihovny (například java.lang.Integer nebo java.lang.String).
Obr. 17: Menu Build->Java Workbench Samozřejmě jGRASP také umožňuje vytvářet nové instance v interaktivním panelu, o čemž bude zmíněno níže. Bez ohledu na použitý způsob se nová instance zařadí do zásobníku odkazů, který lze nalézt v levé části okna aplikace. K zobrazení instancí zásobník odkazů používá relativně složitou stromovou strukturu (viz obr. 18).
15
Obr. 18: Zásobník odkazů v jGRASP
Obr. 19: Místní nabídka instance
Každá instance v zásobníku odkazů je zobrazena jako kořenový uzel stromu, který pomocí myši lze rozbalit a zobrazit atributy jako další uzly. Atributy odkazových typů lze rozbalovat dál, až dokud se nedostaneme ke stavu, kde všechny další atributy jsou jenom primitivních typů nebo typu Object. Při zobrazení atributů se používají různá grafická označení. Každé má svůj význam, například hodnoty odkazových typů se zobrazují pomocí čtverců a hodnoty primitivních typů pomocí trojúhelníků. Význam barev a dalších grafických značek lze přečíst v dokumentaci na webových stránkách projektu jGRASP. Místní nabídka instance (viz obr. 19) nabízí mnohem větší funkčnost než podobná nabídka v BlueJ. Jsou tam ale položky, které by z logického hlediska k instanci neměly patřit, například volání statické metody třídy ze standardní knihovny. Místní nabídka se zobrazí nejenom u kořenového uzlu, ale u jakéhokoliv uzlu ve stromu. Umožňuje to pracovat se soukromými členy, což je porušením jedné ze zásad objektově orientovaného programování. Okno volání metod (viz obr. 20) také nabízí větší funkčnost než analogické okno v BlueJ. Podle výchozího nastavení se zobrazují veřejné a chráněné metody dané instance a všech jejích předků kromě třídy Object. Pomocí ovládacích prvků v horní části okna lze toto chování libovolně měnit. Například lze rozšířit seznam o metody třídy Object, nebo naopak omezit seznam jenom na metody jedné třídy z hierarchie. Extrémním případem je zobrazení úplně všech možných metod, včetně soukromých (což je zase porušením zásady ukrývání implementace) a statických (což je zase trochu nelogické, protože by se statické metody neměly v seznamu instančních metod vyskytovat). V levé horní části okna se nachází menší tlačítko (na ikoně je zobrazena jehlice), stisknutím kterého lze dosáhnout toho, že po spuštění metody okno nezmizí. Tím pádem lze pohodlným způsobem volat za sebou několik metod stejné instance. Podobné tlačítko má také okno pro vytváření nových instancí (viz obr. 15). V dolní části okna u parametrických metod se zobrazují políčka pro zadání příslušných parametrů. Funguje tady technika drag-and-drop, takže v řadě případů lze přetáhnout parametr ze zásobníku odkazů místo ručního zadávání. Dalším užitečným ovládacím prvkem je zaškrtávací políčko pro nezobrazení dialogového okna s návratovou hodnotou, což je užitečné, pokud voláme metodu kvůli vedlejšímu efektu. 16
Obr. 20: Okno volání metod v jGRASP Pokud se uživatel rozhodne nezaškrtávat toto políčko, objeví se okno s výsledkem volání metody, a to i v případě, že metoda nemá žádnou návratovou hodnotu. Pokud metoda vrátí nějakou hodnotu, jGRASP nabízí více způsobů, jak ji prohlížet. Základní spočívá v prohlížení pomocí stromové struktury, stejně jako v zásobníku odkazů. Ale pro určité datové typy existují i specifické možnosti prohlížení. Například numerické hodnoty lze prohlížet v různých číselných soustavách. U kolekcí (seznamy, množiny) lze prohlížet vnitřní strukturu (viz obr. 21). Návratovou hodnotu lze zařadit do zásobníku odkazů, nebo přímo v okně prohlížení zavolat její metodu pomocí tlačítka v pravém horním rohu.
17
Obr. 21: Prohlížení návratové hodnoty typu množina (Set) Interaktivní panel v jGRASP (viz obr. 22) má skoro stejnou funkčnost jako jeho analog v BlueJ. Podstatný rozdíl je pouze ve způsobu spolupráce se zásobníkem odkazů. V BlueJ uživatel musí ručně přetáhnout objekt z panelu do zásobníku, kdežto v jGRASP definované v panelu objekty se automaticky zařazují do zásobníku odkazů. Z toho vyplývá, že v jGRASP se do zásobníku mohou dostat i prázdné (null) odkazy na ještě neinicializované objekty, zatímco v BlueJ podobná situace není možná.
Obr. 22: Interaktivní panel v jGRASP IDE jGRASP obsahuje velké množství vícefunkčních nástrojů pro zajištění interaktivního režimu práce, ale tyto nástroje nejsou intuitivně srozumitelné a jejich realizace občas porušuje zákony logiky a zásady objektově orientovaného programování.
1.1.4 Shrnutí IDE DrJava realizuje interaktivní režim jenom pomocí panelu „Interakce―. Tento panel je sice vypracován nejlépe ze všech zkoumaných, ale samotný nedokáže zajistit pohodlnou práci v interaktivním režimu. IDE BlueJ realizuje interaktivní režim hlavně přes grafické uživatelské rozhraní. Používá k tomu jenom jednoduché komponenty GUI (místní nabídky, dialogová okna, zjednodušené UML diagramy). BlueJ podporuje veškeré funkce nezbytné pro práci v interaktivním režimu (vytváření instancí, volání metod, prohlížení atributů), jejíž realizace je logická, přehledná a intuitivně srozumitelná. IDE jGRASP realizuje interaktivní režim hlavně přes grafické uživatelské rozhraní, ale nabízí také mnohem širší funkčnost, kterou zajišťuje použitím složitějších komponentů GUI (stromové struktury, rozbalovací seznamy, lišta nástrojů). jGRASP nabízí větší možnosti pro interaktivní práci, ale za cenu menší přehlednosti a srozumitelnosti.
18
1.2 Možnosti skriptování na platformě Java Skriptovací jazyky jsou obvykle interpretované jazyky, určené pro rychlý vývoj jednoduchých programů. Skriptovací jazyky umožňují psát úspornější zdrojové kódy. Pokud máme dva programy, které dělají totéž (například tisknou řádek „Hello Word!―), ale jeden je implementovaný v klasickém programovacím jazyce a druhý ve skriptovacím, lze s velkou pravděpodobností tvrdit, že zdrojový kód druhého programu je kratší. Samozřejmě, skriptovací jazyky mají jak silné, tak i slabé stránky, více se lze dočíst ve specializovaných zdrojích, například [31]. Také nelze přesně určit hranici, která by jednoznačně oddělila skriptovací jazyky od klasických systémových, protože existují programovací jazyky, spadající do dvou kategorií. Jejich zdrojový kód lze jak interpretovat, tak i zkompilovat do strojového kódu. Pomocí skriptovacích jazyků lze organizovat interaktivní režim dvěma způsoby. První spočívá v tom, že spustíme interpret skriptovacího jazyka jako nezávislý program, budeme do něho psát příkazy a pozorovat výsledky jejich vykonání. Je to v podstatě skoro totéž, co nabízí interaktivní panel v DrJava, BlueJ a jGRASP, a proto tento způsob nebudu dále popisovat. Druhý způsob spočívá v integrování interpretu skriptovacího jazyka do své aplikace. Tento způsob je podle mého názoru velmi zajímavý a užitečný, protože umožňuje rychle reagovat na nové požadavky a rozšiřovat funkčnost aplikace bez nutnosti překompilovat její zdrojové kódy. V další kapitole je tento způsob znázorněn na příkladu interpretu jazyka Groovy, integrovaného do aplikace napsané v Javě.
1.2.1 Groovy Groovy je objektově orientovaný skriptovací jazyk pro platformu Java. V této kapitole si nekladu za cíl popsat vlastnosti jazyka Groovy, protože podrobný popis by přesáhl rámec této práce a stručný popis v rozsahu pár stránek by nebyl postačující pro to, aby si čtenář mohl vytvořit představu o možnostech tohoto jazyka. Zaměřím se proto na jednoduchou praktickou ukázku toho, jak programátor pomocí Groovy může organizovat interaktivní režim práce ve své aplikaci, a tak zásadně rozšířit její funkčnost. Zájemci o rozsáhlejší teoretické znalosti z Groovy je mohou najít ve zdrojích [6] a [31]. Jako ukázkovou aplikaci jsem zvolil hru „Adventura―. Je to jednoduchá hra, kterou studenti Vysoké školy ekonomické v Praze vyvíjí v rámci základních kurzů programování a softwarového inženýrství. V prvním kurzu studenti mají za úkol napsat hru, ve které je uživatelské rozhraní realizované pomocí příkazového řádku16, v navazujícím kurzu pak studenti musí vytvořit druhou verzi, tentokrát s grafickým uživatelským rozhraním17. Právě verze s GUI byla použita pro další rozšíření. Do menu „Zobrazit― byla přidána položka „Zobrazit Groovy konzoli―18. Pokud uživatel vybere tuto položku, zobrazí se dialogové okno, do kterého se zadávají příkazy. Po zmáčknutí tlačítka „OK― proběhne vykonání zadaných příkazů a zobrazí se dialogové okno s výsledkem (viz obr. 23).
16
Více informací na adrese http://java.vse.cz/4it101/ZadaniAdventury. Více informací na adrese http://java.vse.cz/4it115/ZadaniPrvniUlohy. 18 Zdrojové kódy hry „AdventuraGroovyShell― jsou v příloze 1. 17
19
Obr. 23: Groovy konzole (zleva) a výsledek zpracování Groovy skriptu (zprava) Nová funkce aplikace byla dosažena pomocí několika řádků kódu: 1. zobrazitMenu.add(new JMenuItem(new AbstractAction("Zobrazit Groovy konzoli"){ 2. public void actionPerformed(ActionEvent ae) { 3. JTextArea groovyArea = new JTextArea("", 15, 40); 4. GroovyShell shell = new GroovyShell(); 5. JOptionPane.showMessageDialog(null, new JScrollPane(groovyArea), 6. "Groovy konzole", JOptionPane.INFORMATION_MESSAGE); 7. shell.setVariable("hra", hra); 9. try{ 10. Object returnedValue = shell.evaluate(groovyArea.getText()); 11. JOptionPane.showMessageDialog(null, String.valueOf(returnedValue), 12. "Vrácena hodnota", JOptionPane.INFORMATION_MESSAGE); 13 }catch(Exception ex){ 14. JOptionPane.showMessageDialog(null, ex.getMessage(), 15. "Chyba ve skriptu", JOptionPane.ERROR_MESSAGE); 16. } 17. } 18. }));
Na tomto příkladu lze ukázat minimálně nutný postup, jak realizovat interaktivní práci v Java aplikaci pomocí Groovy: 1. Získat instanci interpretu Groovy (4. řádek) 19 2. Propojit prostředí aplikace a prostředí vykonání Groovy skriptu (7. řádek) 3. Předat interpretu skript ke zpracování (10. řádek) 4. Zpracovat výsledek vykonání skriptu (11. řádek) Pro propojení aplikací a skriptu byla použita proměnná hra, která je instancí třídy Hra. Je to třída, která implementuje hlavní logiku hry, poskytující přístup ke všem hlavním funkcím programu. Skript ke zpracování v našem jednoduchém příkladu se předává v podobě textového řetězce. V jiných aplikacích to může být například soubor nebo vstupní proud. Výsledkem skriptu je hodnota, kterou vrací poslední řádek skriptu, s výjimkou případu, kdy návratová hodnota je určena operátorem return. Teď si ukážeme příklad Groovy skriptu vhodného pro aplikaci „Adventura―:
19
Skript – program ve skriptovacím jazyce, viz terminologický slovník.
20
hra.herniPlan.aktualniMistnost.osoby.each{ if(it.jeZiva && it.jeOzbrojena){ it.jeOzbrojena = false; hra.herniPlan.pocetOzbrojenych--; } } hra.upozorniPrZmMist(); hra.upozorniPrZmInd();
Tento příklad možná nebude úplně srozumitelný pro Java programátory, protože pro práci s ko-lekcí používá místo klasického cyklu for zásadně jiný přístup. Tady ale je důležité si uvědomit, co vykonává daný skript, nikoliv jak to vykonává. Skript „odzbrojí― všechny ozbrojené osoby v aktuální místnosti, což je funkčnost, která není realizována v aplikaci, protože scénář hry nepředpokládá podobnou možnost. Dokonce, pokud prozkoumáme třídu Osoba, zjistíme, že atribut jeOzbrojena je soukromý, jeho hodnota se nastavuje pouze při vytváření nové instance a pak jej nelze změnit, protože na to neexistuje žádná metoda. Pro Groovy to ale není problém, protože dokáže samostatně doplnit takzvané „gettery― a „settery―20. První příklad ukázal, jak lze za běhu aplikace rozšířit její funkčnost pomocí Groovy. Byly k tomu použité jenom stávající třídy aplikace. Pomocí Groovy ale je možné také definovat i nové třídy a následně je použít: import logika.Prikaz; import logika.Hra; class PrikazVyhraj implements Prikaz{ private Hra hra; public PrikazVyhraj(Hra hra){ this.hra = hra; } public String getNazev(){ return "vyhraj"; } public String proved(String ...args){ hra.setKonecHry(true); return "Gratulujeme! Neuvěřitelné vítězství!"; } } hra.getPlatnePrikazy().vlozPrikaz(new PrikazVyhraj(hra));
V druhém skriptu je za běhu aplikace definována nová třída PrikazVyhraj, implementující rozhraní Prikaz. Instance této nové třídy se pak zařazují do seznamů platných příkazů. Po zpracování daného skriptu se seznam příkazů aplikace rozšíří o nový příkaz „vyhraj―. Zadáním tohoto příkazu hráč ihned ukončí hru vítězstvím. Z uvedených příkladů se může zdát, že Groovy skripty mohou sloužit jenom k vytváření cheatů21 v počítačových hrách. Ale není tomu tak. Groovy skripty se spolu se skripty v jiných jazycích používají ve skutečných informačních systémech, například aby rozšířily funkčnost pro řešení nestandardních problémů, jejichž vznik tvůrci systému nepředvídali. V situaci, kdy jde o výjimečný výskyt nějakého problému, je řešení pomocí skriptu celkem postačující. Ale pokud se jedná o často se vyskytující problém, jeho řešení by mělo být časem realizované v nové verzi systému. Řešení pomocí skriptu v podobném případě slouží jako urgentní prozatímní opatření. 20 21
Metody pro práci s vlastnostmi objektu. Viz terminologický slovník. Cheaty – speciální kódy, které mění chování hry. Viz terminologický slovník.
21
1.2.2 Další skriptovací jazyky pro platformu Java Samozřejmě že Groovy není jediný skriptovací jazyk pro platformu Java. Podobných jazyků je hodně, ale základní postup pro interaktivní práci je u všech téměř stejný: vytvořit instanci interpreta pro příslušný jazyk, navázat propojení s prostředím aplikace, spustit skript a zpracovat výsledky. Existují určité pokusy sjednotit práci se skriptovacími jazyky v rámci jediného rozhraní nebo frameworku22, například Bean Scripting Framework [12]. Veškeré skriptovací jazyky pro platformu Java lze rozdělit do dvou tříd. Do první patří jazyky, které mají s Javou podobnou syntaxi, například BeanShell [13] a už zmíněný Groovy. Do druhé skupiny patří jazyky s odlišnou syntaxí. Například JRuby [14] nebo Jython [15], z jejichž názvů je snadné pochopit, že se jedná o realizaci Ruby [16] a Pythonu [17] na platformě Java. Zvlášť je možné zmínit Rhino [18], realizaci jazyka JavaScript na platformě Java. Rhino se používá hlavně při tvorbě webových aplikací. V podobných aplikacích uživatel obvykle zadává nějaká data v prohlížeči, kontrolu správnosti dat (validaci) provádí JavaScriptový kód. Ale uživatel může v prohlížeči vypnout podporu JavaScript a odeslat nevalidní data na server. Proto je před uložením na serveru nutné data ještě jednou validovat. Rhino umožňuje spouštět skripty napsané v JavaScriptu na straně serveru. Bez Rhina by vývojáři museli psát v podstatě stejný kód dvakrát: v JavaScriptu pro klientskou stranu a v Javě pro serverovou stranu, což by bylo porušením principu DRY23.
22 23
Framework – pomocná softwarová struktura, viz terminologický slovník. DRY – Don't Repeat Yourself – jeden z principů softwarového inženýrství, viz terminologický slovník.
22
2 Analýza požadavků a návrh modulu GUI 2.1 Požadavky na funkčnost Z výsledků analýzy realizace interaktivního režimu ve stávajících Java IDE je jasné, že by navrhovaný modul měl zajistit následující funkcionalitu: 1. 2. 3. 4. 5. 6. 7. 8.
Zobrazení seznamu tříd projektu Volání statických metod tříd Prohlížení statických atributů tříd Vytváření samostatných instancí Zobrazení seznamu vytvořených instancí Volání instančních metod Prohlížení instančních atributů Odstranění instancí ze seznamu
Je nutné také zohlednit ten fakt, že se nejedná o samostatný program, ale o zásuvný modul do IDE NetBeans. Navrhovaný modul by měl maximálně využívat možnosti NetBeans, neopakovat funkčnost, která je už v IDE realizována.
2.2 Případy užití Obrázek 24 znázorňuje diagram případů užití, vycházející z požadavků na funkčnost navrhovaného modulu. Pro každý případ užití pak následuje slovní popis.
Obr. 24: Diagram případů užití
23
PU_1 – Zobrazit seznam tříd Popis: Uživatel si nechá zobrazit seznam tříd aktuálního projektu v IDE NetBeans Aktér: Uživatel modulu Vstupní podmínky: V IDE NetBeans je otevřen alespoň jeden projekt Krok 1 2
Role Aktér Systém
Akce Požádá systém o zobrazení tříd Zobrazí seznam tříd, případně prázdný seznam
PU_2 – Zavolat statickou metodu Popis: Uživatel zavolá statickou metodu vybrané třídy Aktér: Uživatel modulu Vstupní podmínky: V aktuálním projektu je alespoň jedna třída, která obsahuje alespoň jednu veřejnou statickou metodu Krok 1 2
Role Systém Aktér
3 4
Systém Aktér
5
Systém
6
Aktér
Akce Zobrazí seznam tříd, viz PU_1 – Zobrazit seznam tříd Vybere třídu a v její místní nabídce vybere příslušnou statickou metodu Zobrazí dialogové okno pro volání metod Pokud metoda vyžaduje parametry – zadá parametry do příslušných políček. Pokud chce zobrazit výsledek, nechá prázdné zaškrtávací políčko „Don't show result of invocation― Pokud nechce zobrazit výsledek, zaškrtne políčko „Don't show result of invocation―, viz PU_2 – alternativní scénář – nezobrazovat výsledek Spustí metodu a zobrazí výsledek v novém dialogovém okně. V případě nesprávných parametrů viz PU_2 – alternativní scénář – chybné parametry Pokud návratová hodnota je objektového typu, může ji zařadit do seznamu vytvořených instancí nebo hodit do okna „Watches―, aby prohlížela atributy Pokud je návratová hodnota primitivního typu, může se na ni jenom podívat a okno uzavřít
PU_2 – Zavolat statickou metodu – alternativní scénář – nezobrazovat výsledek Krok 5a
Role Systém
Akce Spustí metodu, ale žádným způsobem nezobrazí její výsledek
24
PU_2 – Zavolat statickou metodu – alternativní scénář – chybné parametry Krok 5b
Role Systém
Akce Pokusí se spustit metodu, pak zobrazí chybové hlášení
PU_3 – Prohlížet statické atributy Popis: Uživatel prohlíží statické atributy vybrané třídy Aktér: Uživatel modulu Vstupní podmínky: projekt není prázdný (existuje alespoň jedna třída) Krok 1 2
Role Systém Aktér
3
Systém
Akce Zobrazí seznam tříd, viz PU_1 – Zobrazit seznam tříd Vybere třídu a v její místní nabídce vybere „Add to watches― Zobrazí statické atributy (pokud jsou) vybrané třídy v okně „Watches―
PU_4 – Vytvořit instanci Popis: Uživatel vytvoří samostatnou instanci vybrané třídy Aktér: Uživatel modulu Vstupní podmínky: V aktuálním projektu je alespoň jedna třída, která obsahuje alespoň jeden veřejný konstruktor Krok 1 2
Role Systém Aktér
3 4
Systém Aktér
5
Systém
Akce Zobrazí seznam tříd, viz PU_1 – Zobrazit seznam tříd Vybere třídu a v její místní nabídce vybere příslušný konstruktor Zobrazí dialogové okno pro volání konstruktorů Zadá jméno pro novou instanci, v případě duplicitního jména viz PU_4 – alternativní scénář – duplicitní jméno Pokud konstruktor vyžaduje parametry – zadá parametry do příslušných políček. V případě nesprávných parametrů viz PU_4 – alternativní scénář – chybné parametry Zavolá příslušný konstruktor, vytvoří novou instanci a zařadí ji do seznamu vytvořených instancí
PU_4 – Vytvořit instanci – alternativní scénář – duplicitní jméno Krok 5a
Role Systém
Akce Zobrazí chybové hlášení, že instance s podobným jménem už existuje
25
PU_4 – Vytvořit instanci – alternativní scénář – chybné parametry Krok 5b
Role Systém
Akce Pokusí se zavolat konstruktor, pak zobrazí chybové hlášení
PU_5 – Zobrazit seznam instancí Popis: Uživatel si nechá zobrazit seznam vytvořených samostatných instancí Aktér: Uživatel modulu Vstupní podmínky: Žádné Krok 1
Role Aktér
2
Systém
Akce Požádá systém o zobrazení seznamu vytvořených instancí Zobrazí seznam vytvořených instancí, případně prázdný seznam
PU_6 – Zavolat instanční metodu Popis: Uživatel zavolá metodu vybrané instance Aktér: Uživatel modulu Vstupní podmínky: Seznam vytvořených instancí není prázdný Krok 1
Role Systém
2
Aktér
3,4,5, 6
Akce Zobrazí seznam instancí, viz PU_5 – Zobrazit seznam instancí Vybere instanci a v její místní nabídce vybere příslušnou metodu Podobně zavolání statické metody, viz PU_2 – Zavolat statickou metodu včetně alternativních scénářů
PU_7 – Prohlížet atributy instance Popis: Uživatel prohlíží atributy vybrané instance Aktér: Uživatel modulu Vstupní podmínky: Seznam vytvořených instancí není prázdný Krok 1
Role Systém
2
Aktér
3
Systém
Akce Zobrazí seznam instancí, viz PU_5 – Zobrazit seznam instancí Vybere instanci a v její místní nabídce vybere „Add to watches― Zobrazí atributy (pokud jsou) vybrané instance v okně „Watches―
26
PU_7 – Odstranit instanci Popis: Uživatel odstraní vybranou instanci Aktér: Uživatel modulu Vstupní podmínky: Seznam vytvořených instancí není prázdný Krok 1
Role Systém
2
Aktér
3
Systém
Akce Zobrazí seznam tříd, viz PU_5 – Zobrazit seznam instancí Vybere instanci a v její místní nabídce vybere „Remove instance― Odstraní vybranou instanci ze seznamu
27
2.3 Balíčková struktura pluginu BJ2NB Plugin BJ2NB se skládá ze čtyř modulů: Mediator, Executor, Interactor a Editor. Struktura pluginu je zachycena v diagramu balíčků na obr. 25:
Obr. 25: Diagram balíčků pluginu BJ2NB Modul Mediator zajišťuje napojení na platformu NetBeans. Modul Executor zprostředkovává interaktivní režim, spouští metody na druhém virtuálním stroji (standardní způsob ladění programu). Modul Interactor se zabývá tvorbou grafického uživatelského rozhraní, které umožní uživateli využít funkčnost modulu Executor. Modul Interactor lze považovat za zprostředkovatele mezi modulem Executor a koncovým uživatelem pluginu BJ2NB, předává uživatelské příkazy modulu Executor a zajišťuje zobrazení výsledků. Jinými slovy modul Interactor poskytuje grafickou podporu interaktivního režimu práce. Návrh a implementace tohoto modulu jsou v podstatě hlavním cílem této práce. Modul Editor má na starosti kreslení UML diagramu tříd. Z obrázku 25 je vidět, že moduly Interactor a Editor navzájem žádným způsobem nekomunikují. Proto se v této práci nebudu zabývat popisem jeho API24.
2.3.1 Rozhraní modulu Mediator Modul Mediator přes svoje API poskytuje modulům Editor a Interactor informace o Java projektu v NetBeans. Modul Editor využívá informací o projektu pro kreslení diagramu tříd. Modul Interactor na základě těchto informací zobrazí stromovou strukturu projektu, ve které koncový uživatel může vybrat určitou třídu projektu a interaktivně s ní pracovat: volat statické metody, vytvářet nové instance, prohlížet statické atributy. 24
API application programming interface, viz terminologický slovník.
28
Pro kreslení diagramu tříd ale modul Editor potřebuje určité informace, které modul Interactor vůbec nepoužívá. Například vztahy mezi třídami projektů, jako dědičnost nebo asociace. Jinými slovy modul Interactor používá jenom část API modulu Mediator. V době psaní této práce moduly Editor a Mediator ještě nebyly dokončeny, finální podoba API modulu Mediator zatím není úplně jasná. Proto v této práci uvádím jenom tu část API modulu Mediator, kterou od něj vyžaduje modul Interactor (viz obr. 26)25.
Obr. 26: Část rozhraní modulu Mediator vyžadovaná modulem Interactor Protože modul Mediator v době psaní této práce nebyl dokončen, vytvořil jsem sadu mock 26 objektů, které poskytují fiktivní implementaci těch funkcí Mediator API, které používám v modulu Interactor. Díky mock objektům je možné implementovat a testovat modul Interactor nezávisle na modulu Mediator a nečekat, až bude hotová jeho skutečná implementace.
2.3.2 Rozhraní modulu Executor V současné době už implementace modulu Executor byla úspěšně dokončena. Více informací o modulu Executor lze získat ve zdroji [29], v této práci uvádím jenom diagram tříd, který znázorňuje API modulu Executor (viz obr. 27). Nicméně zjistil jsem, že v současné době nelze modul Executor spustit v operačním systému Linux27, konkrétně se jedná o distribuci Ubuntu28. Proto jsem také vytvořil mock implementaci Executor API, která umožňuje spouštět modul Interactor nezávisle na modulu Executor. 25
26 27 28
Pokud balíček obsahuje více než dvě třídy, v této práci uvádím jenom hrubý diagram tříd. Podrobný diagram tříd lze nalézt v přílohách práce. Mock objekt – falešný objekt, který simuluje chování reálného objektu, viz terminologický slovník. Linux – třetí nejpopulárnější operační systém pro osobní počítače, viz terminologický slovník. Ubuntu - nejpopulárnější distribuce operačního systému Linux.
29
Obr. 27: Rozhraní modulu Executor (převzato z [29])
2.3.3 Rozhraní modulu Interactor API modulu Interactor obsahuje jenom rozhraní IInteractor a třídu Interactor(viz obr. 29). IInteractor je velmi stručné rozhraní, které obsahuje jenom dvě metody, public JPanel getInteractorPanel(IProject prj); public void finish(). Modul Mediator zavolá metodu getInteractorPanel(IProject prj) v okamžiku, kdy ho uživatel pluginu požádá o spouštění interaktivního režimu. Přes parametr IProject prj modul Mediator poskytne informace o NetBeans projektu, se kterým chce uživatel interaktivně pracovat. Modul Interactor nastartuje modul Executor (zavolá metodu IExecutor.start()) a na základě informací o projektu vytvoří grafické uživatelské rozhraní, které pak vrátí jako instance potomka třídy JPanel. Modul Mediator se pak postará o zobrazení tohoto panelu v prostředí NetBeans.
30
Modul Mediator zavolá metodu finish()v okamžik, kdy uživatel pluginu ukončí práci v interaktivním režimu. Modul Interactor na to v současné době reaguje tak, že jenom ukončí činnost modulu Executor metodou IExecutor.finish(). Je možné, že toto chování bude v budoucnu nějakým způsobem rozšířené, například modul Interactor bude v okamžiku zastavení ještě ukládat nějaká uživatelská data.
2.4 Balíčková struktura modulu Interactor Balíčkovou strukturu modulu Interactor znázorňuje obrázek 28. Je vidět, že modul Interactor se skládá ze sedmi balíčků. Balíčky api,gui,tree,utils obsahují třídy, které spolu implementují funkčnost samotného modulu Interactor. Třídy balíčků mockmediator a mockexecutor fiktivně implementují funkčnost modulů, se kterými modul Interactor komunikuje, tedy modulu Mediator a Executor. Umožňuje to spustit modul Interactor v testovacím režimu. Pojem testovací režim znamená v tomto konkrétním případě možnost vyzkoušet funkčnost modulu Interactor izolovaně od ostatních modulů pluginu. Třídy balíčku helper umožňují přepínání mezi testovacím a skutečným režimem provozu modulu Interactor bez zásahu do zdrojových kódů.
Obr. 28: Balíčková struktura modulu Interactor
2.4.1 Balíček api Podle názvu balíčku je jasné, že jeho obsah tvoří API modulu Interactor. Z diagramu tříd na obrázku 29 je vidět, že balíček obsahuje pouze jedno rozhraní a jednu třídu. Rozhraní IInteractor obsahuje jenom dvě metody (viz 2.3.3 Rozhraní modulu Interactor). Třída Interactor implementuje rozhraní IInteractor. Tato třída nemá žádný veřejný konstruktor. Získat instanci třídy je možné jenom pomocí tovární metody getInteractor(), která vrací odkaz na jedinou instanci této třídy. Jedná se o použití návrhového vzoru Jedinaček [32].
31
Obr. 29: Diagram tříd balíčku api
2.4.2 Balíček gui Třídy balíčku gui mají na starosti tvorbu grafického uživatelského rozhraní. Je to v podstatě nejdůležitější a podle počtu tříd největší balíček modulu Interactor. Strukturu balíčku znázorňuje diagram tříd na obrázku 30. K tomu je ještě nutné doplnit drobnou poznámku: při tvorbě GUI se hojně používají vnitřní a vnořené třídy, které v diagramu tříd nejsou zobrazeny Hlavní třídou GUI je InteractorPanel. Právě instanci této třídy vrací modul Interactor modulu Mediator, aby ten následně zajistil její správné zobrazení v prostředí NetBeans. V době psaní této práce nebyl modul Mediator dokončen, proto byla jako prozatímní řešení vytvořena třída InteractorStart. Instance této třídy dočasně nahrazuje chybějící funkcionalitu modulu Mediator. V okamžiku, kdy uživatel požádá o spouštění interaktivního režimu, instance třídy InteractorStart zavolá metodu getInteractorPanel(), jednu ze dvou metod API modulu Interactor. Vrácená instance třídy InteractorPanel je pak zobrazena v jednoduchém dialogovém okně. V okamžiku, kdy uživatel pluginu uzavře toto okno, instance třídy InteractorStart zavolá druhou metodu Interactor API – metodu finish().
32
Obr. 30: Diagram tříd balíčku gui
2.4.3 Balíček tree Balíček tree obsahuje sadu tříd, které podporují zobrazení stromové struktury projektu NetBeans. Diagram tříd balíčku tree je uveden na obrázku 31.
33
Obr. 31: Diagram tříd balíčku tree
2.4.4 Balíček utils V balíčku utils je pouze jedna třída Tools, která obsahuje řadu statických metod (viz obr. 32) často používaných v různých třídách pluginu BJ2NB.
Obr. 32: Diagram tříd balíčku utils
2.4.5 Balíček mockmediator Účelem tříd balíčku mockmediator je poskytnout instanci třídy, která implementuje rozhraní IProject a představuje fiktivní projekt v prostředí NetBeans. Díky tomu bylo možné implementovat a testovat modul Interactor dřív, než bude dokončen modul Mediator. Získat mock objekt reprezentující fiktivní projekt lze pomocí metody MockMediator.getMockProject(). Ve fiktivním projektu se vyskytuje několik jednoduchých tříd, vytvořených autorem modulu Executor pro testovací účely. Tyto třídy byly zařazeny do balíčku mockmediator.testclasses. 34
Obr. 33: Diagram tříd balíčku mockmediator
2.4.6 Balíček mockexecutor Třídy balíčku mockexecutor jsou určené pro vytvoření fiktivní implementace Executor API. Získat mock objekt, reprezentující modul Executor pro testovací účely, lze pomocí metody MockExecutor.getExecutor().
Obr. 34: Diagram tříd balíčku mockexecutor 35
2.4.7 Balíček helper Balíček helper obsahuje jenom dvě třídy, ExecutorHelper a MediatorHelper, mající na starosti rozhodování, která implementace příslušného API bude použita: skutečná, nebo fiktivní. Rozhodování se uskutečňuje na základě souboru mock.properties, který obsahuje dvě vlastnosti: useMockExecutor a useMockMediator. Nastavení vlastnosti na hodnotu true způsobí to, že místo skutečného modulu bude použit příslušný mock objekt. Například, pokud má vlastnost useMockExecutor hodnotu false, metoda ExecutorHelper.getExecutor() vrátí skutečnou implementaci Executor API, tj. zavolá metodu ExecutorLauncher.getExecutor(). Ale pokud má hodnotu true, metoda ExecutorHelper.getExecutor() vrátí mock objekt, tj. zavolá MockExecutor.getExecutor(). Třídy modulu Interactor nikdy nezískávají instanci IExecutor přímo metodou ExecutorLauncher.getExecutor(). Vždy k tomu používají metodu ExecutorHelper.getExecutor(). Podobný návrh umožňuje změnit používanou implementaci Executor API jednoduchou změnou hodnoty vlastnosti useMockExecutor z true na false nebo naopak. Tato změna se tyká jenom souboru mock.properties. Není nutné zasahovat do všech zdrojových souborů, ve kterých se používá Executor API. Třída MediatorHelper funguje stejným způsobem, ale hodnota useMockMediator zatím může být nastavená pouze na true. Pokus změnit ji na false způsobí výjimku NotImplementedException.
Obr. 35: Diagram tříd balíčku helper
36
3. Uživatelská příručka 3.1 Spuštění modulu V současné době lze modul Interactor spustit přes položku Start Interactor v menu File hlavního okna prostředí NetBeans. V budoucnu v plně funkční verzi pluginu BJ2NB předpokládáme jiný způsob spouštění modulu: přes místní nabídku projektu v záložce „Projects― v pravé časti okna NetBeans. Po startu aktuální verze modulu se objeví dialogové okno (viz obr. 36), které zobrazí panel modulu Interactor. Panel se skládá ze tří částí. Levá část je určena pro zobrazení balíčkové struktury projektu. Pravá část slouží k zobrazení seznamu vytvořených instancí. Dolní část je určena pro zadávání a následné vyhodnocování uživatelských výrazů. Výchozí rozdělení prostoru mezi levou a pravou částí lze změnit pomocí myši: stačí přetáhnout hranici, která jej rozděluje, vpravo nebo vlevo.
Obr. 36: Dialogové okno s panelem Interactor
3.2 Zobrazení seznamu tříd Zobrazení seznamu tříd zajišťuje panel „Project―. V tomto panelu se obsah projektu v NetBeans zobrazuje pomocí stromu (viz obr. 37). Kořen stromu tvoří uzel s názvem projektu. Pod kořenem jsou uzly s názvy balíčků nejvyšší úrovně. Pomocí myší lze uzel, který zastupuje balíček, otevřít a zobrazit jeho obsah. Obsahem balíčku mohou být třídy nebo balíčky nižší úrovně. Uzel, zastupující třídu, už dál nelze otevřít. Ale je možné zobrazit jeho místní nabídku, která obsahuje tři položky: Podnabídku „Create new instance― se seznamem konstruktorů Podnabídku „Invoke static metod― se seznamem statických metod Položku menu „Add to watches― U abstraktních tříd a u rozhraní bude podnabídka „Create new instance― znepřístupněná. U rozhraní navíc bude znepřístupněná podnabídka „Invoke static method―.
37
Obr. 37: Strom projektu a místní nabídka třídy
3.3 Volání statických metod Aby zavolal statickou metodu, musí ji uživatel nejdříve vybrat v podnabídce „Invoke static method―. Pak se objeví dialogové okno (viz obr. 38), které obsahuje minimálně následující komponenty: Popisek s názvem metody a typem její návratové hodnoty Zaškrtávací políčko „Don’t show result of invocation― Zaškrtávací políčko „Don’t close this window after invocation― Tlačítka OK a Cancel Dále zde mohou být určité nepovinné komponenty. Pokud metoda má dokumentační komentář, zobrazí se v horní části okna. Pokud metoda je parametrická, pro každý z parametrů se zobrazí popisek s jeho názvem a datovým typem a textové políčko pro zadání hodnoty parametru. Do tohoto políčka lze zadat nejen samotnou hodnotu, ale jakýkoliv platný výraz, který vrátí hodnotu požadovaného datového typu.
38
Obr. 38: Dialogové okno volání statické metody Po správném vyplnění všech parametrů a stisknutí tlačítka OK bude toto dialogové okno automaticky uzavřeno a objeví se okno s výsledkem spuštění metody. Výchozí chování uživatel může výrazně ovlivnit pomocí zaškrtávacích políček. Zaškrtnutí políčka „Don’t show result of invocation― znemožní zobrazení okna s výsledkem. Zaškrtnutí políčka „Don’t close this window after invocation― umožní volat stejnou metodu nesčetněkrát za sebou, protože dialogové políčko se po stisknutí tlačítka OK nebude zavírat. Pokud zaškrtávací políčko „Don’t show result of invocation― zůstane prázdné, po stisknutí tlačítka OK se objeví okno s výsledkem spuštění metody. Toto okno má dvě podoby: jednoduchou (jenom tlačítko OK) a trochu pokročilejší (tři různá tlačítka). Jednoduché dialogové okno se používá pro zobrazení návratových hodnot primitivních datových typů (viz obr. 39 horní část), žádné návratové hodnoty neboli void (viz obr. 39 dolní levá část) a prázdného odkazu neboli null (viz obr. 39 dolní pravá část). Jednoduché dialogové okno umožňuje jenom zobrazit výsledek. Žádná manipulace s výsledkem není možná.
Obr. 39: Jednoduché dialogové okno pro zobrazení návratových hodnot
39
Pokročilejší dialogové okno slouží k zobrazení návratových hodnot odkazových typů. Obsahuje tři tlačítka: „Add to instances―, „Add to instances and watches“, „Close―. První tlačítko slouží k zařazení odkazu do seznamu instancí, druhé dělá totéž a navíc ještě přidává odkaz do okna watches29.Třetí tlačítko zahodí odkaz a uzavře okno.
Obr. 40: Dialogové okno pro zobrazení návratových hodnot odkazových typů Pokud uživatel zmáčkne první nebo druhé tlačítko, zobrazí se malé dialogové okno pro zadání jména, pod kterým instance bude zařazena do seznamu (viz obr. 41, levá horní čast). Jméno musí splňovat dvě podmínky: 1. Musí být platným Java identifikátorem, jinak se zobrazí chybová hláška – viz obr. 41, pravá horní část 2. Nesmí být stejné jako jméno už existující instance, jinak se zobrazí chybová hláška – viz obr. 41, dolní část
Obr. 41: Zadání jména pro vrácenou instanci Pokud byly splněny obě podmínky, instance se zobrazí v seznamu instancí, případně také v okně watches.
29
Druhé tlačítko by podle mého návrhu mělo jenom vytvářet watch na instanci a ne zařazovat odkaz do seznamu. Ale Executor API vyžaduje, aby instance, na kterou chceme vytvořit watch, byla před tím přidána do seznamu vytvořených instancí, viz uživatelská dokumentace modulu Executor [29].
40
3.4 Prohlížení statických atributů třídy Modul GUI zatím nemůže samostatně zobrazit statické atributy tříd. Používá k tomu okno watches, které je součástí vývojového prostředí NetBeans. Vytvořit watch na třídu lze třemi způsoby. První způsob je využít položku „Add to watches― místní nabídky třídy ve stromu projektu (viz obr. 37). Druhý způsob je použít dvojité stisknutí (double click) levého tlačítka myši na příslušném uzlu v projektovém stromu. Třetí způsob vyžaduje, aby v seznamu instancí byla alespoň jedna instance zadané třídy. Pokud je tato podmínka splněna, stačí v místní nabídce příslušné instance zvolit položku „Add class to watches―. Bez ohledu na použitý způsob dojde k vytvoření watch na příslušnou třídu (viz obr. 42).
Obr. 42: Watch na třídu
3.5 Vytváření samostatných instancí Pro vytvoření nové instance je nutné vybrat jeden z konstruktorů v podnabídce „Create new instance― příslušné třídy v projektovém stromu. Zobrazí se dialogové okno (viz obr. 43) velmi podobné oknu volání metody (viz obr. 38). Jediným podstatným rozdílem je, že místo zaškrtávacího políčka „Don’t show result of invocation― obsahuje textové pole pro zadání jména nové instance. Samozřejmě jméno musí být platným Java identifikátorem a nesmí být stejné jako jméno už existující instance. Po správném zadání všech parametrů (pokud jsou), zadání jména pro novou instanci a stisknutí tlačítka OK se nová instance objeví v seznamu instancí.
Obr. 43: Vytvoření nové instance 41
3.6 Zobrazení seznamu vytvořených instancí V seznamu instancí se každá instance zobrazuje ve velmi jednoduchém formátu jmeno:třída. Místní nabídka instance obsahuje čtyři položky: 1. „Invoke metod― – volání metod 2. „Add instance to watches― – vytvoření watch na instanci 3. „Add class to watches― – vytvoření watch na třídu 4. „Remove instance‖ – vyřazení instance ze seznamu První položka „Invoke metod― je podnabídka, která zobrazuje hierarchii tříd od vlastní třídy instance až do třídy Object, společného předka všech tříd v Javě. Každá třída v této hierarchii má přiřazenou další podnabídku, do které spadají metody, deklarované v této třídě.
Obr. 44: Seznam vytvořených instancí a místní nabídka jedné instance
3.7 Volání instančních metod Volání metod instance probíhá v podstatě stejným způsobem jako volání statických metod (viz 3.3 Volání statických metod). Drobný rozdíl bude jenom v situaci, kdy zavoláme metodu instance, jejíž třída není v projektovém stromu. V tomto případě modul GUI nedokáže zobrazit dokumentační komentář a názvy parametrů. Místo skutečných názvů se používají fiktivní ve tvaru p0,p1,p2 atd.
3.8 Prohlížení instančních atributů Pro prohlížení atributů instance modul GUI používá okno watches. Vytvořit watch na instanci lze přes položku „Add instance to watches― v její místní nabídce. Alternativní způsob vyžaduje dvojité stisknutí (double click) levého tlačítka myši na příslušné instanci v seznamu. Existuje také třetí způsob, kterým se instance může dostat do okna watches: použít tlačítko „Add to instances and watches― v dialogovém okně pro zobrazení návratových hodnot (viz obr. 40). Bez ohledu na použitý způsob dojde k vytvoření watch na příslušnou instanci (viz obr. 45).
42
Obr. 45: Watch na instanci
3.9 Odstranění instancí Pro odstranění instancí stačí vybrat položku „Remove instance― v její místní nabídce. Jméno odstraněné instance lze přiřadit nové instanci.
3.10 Operace s objekty typu pole Místní nabídka u objektu typu pole vypadá trochu zvláštně (viz obr. 46). Je znepřístupněná položka „Add class to watches― a místo podnabídky „Invoke metod― se používá podnabídka „Array operations―. Podnabídka obsahuje jenom dvě možnosti: získat délku pole (viz obr. 47, levá horní část) nebo získat hodnotu podle indexu. V druhém případě se zobrazí dialog pro zadání indexu (viz obr. 47, pravá horní část). Index musí být celé číslo, jinak bude zobrazena chybová hláška „Invalid number format― (viz obr. 47, levá dolní část). Hodnota indexu musí být menší než délka pole, ale ne menší než nula, jinak bude zobrazena chybová hláška „Index out of bounds― (viz obr. 47, pravá dolní část). Pro správně zadaný index bude vrácena příslušná hodnota, vyzvednutá z pole. Tato hodnota může být jak odkazového, tak i primitivního datového typu. Pro zobrazení bude použito příslušné dialogové okno (viz obr. 39 nebo obr. 40).
Obr. 46: Místní nabídka objektu typu pole
43
Obr. 47: Operace s objektem typu pole
3.11 Vyhodnocování výrazů Výrazy se zadávají do textového pole v dolní části panelu Interactor. Vyhodnocení konkrétního výrazu se spouští zmačknutím tlačítka „Evaluate―. Výsledkem vyhodnocování jakéhokoliv výrazu je vždy hodnota odkazového typu. Hodnoty primitivních datových typů se zapouzdřují do příslušných obalových typů (viz obr. 48).
Obr. 48: Výsledek vyhodnocování výrazů typu boolean zapouzdřený do Boolean
3.12 Ukončení modulu Činnost modulu je zastavena uzavřením dialogového okna, zobrazeného na obr. 36.
44
Závěr Cílem této práce bylo vytvořit GUI pro plugin BJ2NB, které by umožňovalo práci v interaktivním režimu ve vývojovém prostředí NetBeans. Doufám, že tento cíl byl splněn. Vytvořený modul GUI podporuje veškeré případy užití, popsané v kapitole 2.2. Navíc byla realizována možnost vyhodnocování uživatelských výrazů, kterou jsem původně nepředpokládal implementovat v první verzi modulu GUI. Při návrhu modulu jsem použil vývojová prostředí BlueJ a jGRASP jako vzory pro inspiraci. Snažil jsem se převzít podle mého názoru nejlepší myšlenky z každého IDE. Například z BlueJ bylo převzato zobrazení metod objektu v jeho místní nabídce, která je rozdělená na podnabídky podle hierarchie tříd. Z jGRASP jsem převzal možnost nezobrazovat výsledek volání metody a možnost volat metodu několikrát za sebou ze stejného dialogového okna. Samozřejmě kvalitu realizace interaktivního režimu v pluginu BJ2NB zatím není možné porovnat s analogem v BlueJ nebo jGRASP. Ale nevidím v tom žádný důvod pro zoufalství, ale naopak to považuji za podnět, který bude motivovat k dalšímu vývoji a zlepšení modulu GUI. Vidím před sebou několik cest ke zlepšení tohoto modulu. První cesta je rozšíření funkčnosti modulu GUI. Například, implementace možnosti získat odkaz na veřejný atribut objektu a zařadit ho do zásobníku odkazů. Executor API pro to nabízí veškeré nezbytné metody, ale současná verze modulu GUI tuto možnost nevyužívá. Realizaci této nové funkce považuji za prioritní úlohu, která musí být řešena jako první v nové verzi modulu GUI. Druhá cesta je zlepšení GUI z estetického pohledu. Například použití různých barev, obrázků, fontů. Může se zdát, že pro programátorské nástroje estetická stránka nemá velký význam. Skutečně velké množství nástrojů, určených pro IT odborníky, vůbec nemá GUI, pracují jenom z příkazového řádku. Ale plugin BJ2NB je určen primárně pro začátečníky, proto je velmi důležité, aby plugin měl přívětivé uživatelské rozhraní. Třetí cesta je zlepšení kvality zdrojových kódů. Modul se vyvíjel v podmínkách časové tísně autora, proto kvalita zdrojových kódů není optimální. Ale plugin BJ2NB není obvyklým školním projektem, jejichž vývoj často končí hned po úspěšném absolvování příslušného kurzu. Plánujeme vyvíjet tento projekt dál, počítáme také se zapojením nových vývojářů. Proto je velmi důležité, aby se ve zdrojovém kódu každého modulu pluginu mohl vyznat nejen jeho autor, ale jakýkoliv jiný programátor. Nehledě na to, že současná verze modulu GUI není dokonalá, považuji její implementaci za velmi důležitý mezník ve vývoji pluginu BJ2NB. Plugin už začal dělat něco, co vidí konečný uživatel. Věřím, že tento fakt bude motivovat náš tým, abychom společným úsilím dotáhli plugin do plně funkčního stavu co nejdřív Případně bude motivovat jiné programátory, aby se zapojili do vývoje pluginu. Také doufám, že finální verze pluginu BJ2NB najde svoje uplatnění jak mezi začínajícími, tak možná i mezi zkušenými programátory.
45
Zdroje ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●
● ● ●
[1] BATELKA, Martin. Analýza open-source verze programu BlueJ. Praha, 2009. 42 s. Bakalářská práce. Vysoká škola ekonomická v Praze. [2] Dejan Bosanac: Scripting in Java. Pearson Education 2008. ISBN 0-321-32193-6. [3] Forman I. R., Forman N.: Java Reflection in Action. Manning Publications 2004. ISBN 1932394-18-4. [4] Oracle Corporation. Netbeans.org [on-line]. 2011 [cit. 2011-04-22]. Dostupné z www:
. [5] University of Kent, LA TROBE University. Bluej.org [on-line]. 2011 [cit. 2011-04-22]. Dostupné z www:
. [6] Codehaus Foundation. Groovy Home [on-line]. 2011 [cit. 2011-04-22]. Dostupné z www:
. [7] The Eclipse Foundation. The Eclipse Foundation open source community website [on-line]. 2011 [cit. 2011-04-22]. Dostupné z www:
. [8] JetBrains s.r.o. Jetbrains.com [on-line]. 2011 [cit. 2011-04-22]. IntelliJ IDEA — The Most Intelligent Java IDE. Dostupné z www:
. [9] JavaPLT group at Rice University. Drjava.org [on-line]. 2011 [cit. 2011-04-22]. Dostupné z www:
. [10] Aubum University. Jgrasp.org [on-line]. 2011 [cit. 2011-04-22]. Dostupné z www:
. [11] BAUER, Tomáš. Programy pro podporu výuky programování v OOP. Praha, 2009. 57 s. Bakalářská práce. Vysoká škola ekonomická v Praze. [12] Apache Software Foundation. Bean Scripting Framework [on-line]. 2011 [cit. 2011-0422]. Dostupné z www:
. [13] Beanshell.org [on-line]. 2011 [cit. 2011-04-22]. Dostupné z www:
. [14] Jruby.org [on-line]. 2011 [cit. 2011-04-22]. Dostupné z www:
. [15] The Jython Project [on-line]. 2011 [cit. 2011-04-22]. Dostupné z www:
. [16] Ruby-lang.org [on-line]. 2011 [cit. 2011-04-22]. Dostupné z www:
. [17] Python Software Foundation. Python.org [on-line]. 2011 [cit. 2011-04-22]. Dostupné z www:
. [18] Mozilla Foundation. Rhino: JavaScript for Java [on-line]. 2011 [cit. 2011-04-22]. Dostupné z www:
. [19] DOHNAL, Tomáš. Návrh grafického uživatelského rozhraní. Praha, 2008. 59 s. Bakalářská práce. Vysoká škola ekonomická v Praze. [20] Wikimedia Fondation. Wikipedia.org [on-line]. 2011 [cit. 2011-04-23]. Vývojové prostředí. Dostupné z www:
. [21] Wikimedia Fondation. Wikipedia.org [on-line]. 2011 [cit. 2011-04-23]. Cheat. Dostupné z www: . [22] Wikimedia Fondation. Wikipedia.org [on-line]. 2011 [cit. 2011-04-23]. Framework. Dostupné z www: . [23] Wikimedia Fondation. Wikipedia.org [on-line]. 2011 [cit. 2011-04-23]. Grafické uživatelské rozhraní. Dostupné z www:
46
● ● ● ●
● ●
● ● ●
. [24] Wikimedia Fondation. Wikipedia.org [on-line]. 2011 [cit. 2011-04-23]. Plugin. Dostupné z www: . [25] Wikimedia Fondation. Wikipedia.org [on-line]. 2011 [cit. 2011-04-23]. Skriptovací jazyk. Dostupné z www: . [26] Wikimedia Fondation. Wikipedia.org [on-line]. 2011 [cit. 2011-04-23]. Unified Modeling Language. Dostupné z www: . [27] Wikimedia Foundation. Wikipedia.org [on-line]. 2011 [cit. 2011-06-23]. Mock-объект. Dostupné z www: . [28] Wikimedia Foundation. Wikipedia.org [on-line]. 2011 [cit. 2011-06-23]. API. Dostupné z www: . [29] VERNER, Jan. Modul zprostředkující práci v interaktivním režimu pro zásuvný modul (plug-in) BJ2NB do prostředí NetBeans. Praha, 2011. 40 s. Bakalářská práce. Vysoká škola ekonomická v Praze. [30] Wikimedia Foundation. Wikipedia.org [on-line]. 2011 [cit. 2011-06-23]. Linux. Dostupné z www: . [31] BARCLAY, Kenneth; SAVAGE, John. Groovy programming – An introduction for Java developers. San Francisco: Morgan Kaufmann Publishers, 2007. 978-0-12-372507-3. [32] PECINOVSKÝ, Rudolf. Návrhové vzory. Brno : Computer Press, 2007. Jediná instance (Jedináček - Singleton), s. 107-120. ISBN 978-80251-1582-4.
47
Terminologický slovník Termín Application Programming Interface
Zkratka API
Integrated Development Environment
IDE
cheaty
Drag-and-drop
drag&drop
Don't Repeat Yourself
DRY
framework
getter
Graphic User Interface
GUI
Význam[zdroj] API (zkratka pro Application Programming Interface) označuje v informatice rozhraní pro programování aplikací. Tento termín používá softwarové inženýrství. Jde o sbírku procedur, funkcí či tříd nějaké knihovny (ale třeba i jiného programu nebo jádra operačního systému), které může programátor využívat. API určuje, jakým způsobem se funkce knihovny volají ze zdrojového kódu programu.[28] Integrované vývojové prostředí je software usnadňující práci programátorů, většinou zaměřený na jeden konkrétní programovací jazyk. Obsahuje editor zdrojového kódu, kompilátor, případně interpret a většinou také debugger.[20] Cheaty /tʃiːtɪ/, anglické slovo cheat znamená podvod, podvádět. Označují se tak speciální kódy, které může při hraní některých počítačových her či videoher hráč zadat a které posléze nějak mění chování hry, typicky hráči udělí nesmrtelnost, přidají peníze či užitečné předměty apod.[21] Specifická technika práce s objekty v grafickém uživatelském rozhraní. Spočívá v přetahování objektů pomocí myši mezi různá místa v GUI, používá se hlavně pro kopírování a přesun objektu. [autor] Princip softwarového inženýrství, podle kterého by se v aplikaci neměl vyskytovat opakující se kód. [autor] Framework je softwarová struktura, která slouží jako podpora při programování a vývoji a organizaci jiných softwarových projektů. [22] Metoda pro získání vlastnosti třídy, obvyklý formát getXxx(), kde xxxx – název vlastnosti. [autor] Grafické uživatelské rozhraní je uživatelské rozhraní, které umožňuje 48
Linux
Mock objekt
mock
plugin
setter
skriptovací jazyk
Ubuntu
Unified Modeling Language
watch
UML
ovládat počítač pomocí interaktivních grafických ovládacích prvků. [23] Linux je v informatice označení pro unixový operační systém (původně pouze jeho jádro). Linux je šířen v podobě distribucí, které je snadné nainstalovat nebo přímo používat (tzv. Live CD). Zároveň se díky použitým licencím jedná o volně šiřitelný software, takže je možné ho nejen volně používat, ale i dále upravovat a distribuovat (kopírovat, sdílet). [30] Konkrétní fiktivní realizace určitého rozhraní, určená jenom pro testovací účely. [27] Zásuvný modul neboli plugin, také plug-in (neologismus vytvořený z anglického slovesa to plug in – zasunout), je software, který nepracuje samostatně, ale jako doplňkový modul jiné aplikace a rozšiřuje tak její funkčnost. [24] Metoda pro nastavení vlastnosti třídy, obvyklý formát setXxx(arg), kde xxxx – název vlastnosti, arg – nová hodnota pro danou vlastnost.[autor] Skriptovací jazyk je interpretovaný programovací jazyk, který je navržen s ohledem na snadné ovládnutí jazyka a rychlý a pohodlný vývoj programů. [25] Ubuntu je linuxová distribuce pro pracovní stanice, servery, domácí počítače a notebooky, založená na Debian GNU/Linux. Název distribuce je odvozen z jihoafrického pojmu Ubuntu znamenajícího přibližně „lidskost ostatním―. [31] Unified Modeling Language je v softwarovém inženýrství grafický jazyk pro vizualizaci, specifikaci, navrhování a dokumentaci programových systémů. [26] konstrukce prostředí NetBeans, která umožňuje zkoumat hodnotu proměnné. [29]
49
Seznam příloh Na přiloženém CD se nachází: 1. 2. 3. 4.
Zdrojové kódy projektu AdventuraGroovyShell – jednoduchá hra s Groovy konzolí. UML diagramy navrhovaného modulu GUI Zdrojové kódy implementovaného pluginu BJ2NB. Dokumentace Javadoc.
50
