From 3472dfcc7ee823a7a6d94c099c8d069574d6003c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Pol=C3=A1=C4=8Dek?= Date: Wed, 14 Sep 2022 11:01:11 +0200 Subject: [PATCH] Add files via upload --- pom.xml | 74 +++--- .../AUvod.java | 58 ++--- .../BGenerikaAPole.java | 56 ++--- ...omennyPocetArgumentuAParametrickeTypy.java | 54 ++--- .../DVytvoreniPoleSGenerickymiInstancemi.java | 54 ++--- .../java/cz/spsmb/ctvrtak/b_anotace/A.java | 20 +- .../cz/spsmb/ctvrtak/b_anotace/AUvod.java | 84 +++---- .../b_anotace/BMoznostiPouzitiAnotace.java | 128 +++++----- .../b_anotace/CAnotaceVeStdKnihovne.java | 42 ++-- .../spsmb/ctvrtak/b_anotace/DMetaanotace.java | 74 +++--- .../java/cz/spsmb/ctvrtak/b_anotace/Den.java | 22 +- .../b_anotace/EPrikladRuntimeAnotace.java | 228 +++++++++--------- .../spsmb/ctvrtak/b_anotace/MojeAnotace.java | 8 +- .../ctvrtak/b_anotace/SampleAnnotation.java | 28 +-- .../cz/spsmb/ctvrtak/b_anotace/Testovat.java | 22 +- .../spsmb/ctvrtak/b_anotace/package-info.java | 4 +- .../c_spring/a_config/main/java/Doc.java | 47 ++++ .../a_config/main/java/SearchEngine.java | 10 + .../c_spring/a_config/main/java/Type.java | 46 ++++ .../c_spring/a_config/main/java/Zadani.java | 71 +++--- .../a_config/test/java/Assertions.java | 18 ++ .../a_config/test/java/MyDocumentTest.java | 18 ++ .../a_config/test/java/MySearchEngine.java | 39 +++ .../AUvod.class | Bin 0 -> 1548 bytes .../BGenerikaAPole.class | Bin 0 -> 670 bytes ...mennyPocetArgumentuAParametrickeTypy.class | Bin 0 -> 1507 bytes ...DVytvoreniPoleSGenerickymiInstancemi.class | Bin 0 -> 1510 bytes .../cz/spsmb/ctvrtak/b_anotace/A.class | Bin 0 -> 310 bytes .../cz/spsmb/ctvrtak/b_anotace/AUvod.class | Bin 0 -> 751 bytes .../b_anotace/BMoznostiPouzitiAnotace.class | Bin 0 -> 963 bytes .../b_anotace/CAnotaceVeStdKnihovne.class | Bin 0 -> 342 bytes .../ctvrtak/b_anotace/DMetaanotace.class | Bin 0 -> 315 bytes .../cz/spsmb/ctvrtak/b_anotace/Den.class | Bin 0 -> 1295 bytes .../b_anotace/EPrikladRuntimeAnotace.class | Bin 0 -> 6896 bytes .../spsmb/ctvrtak/b_anotace/MojeAnotace.class | Bin 0 -> 169 bytes .../ctvrtak/b_anotace/SampleAnnotation.class | Bin 0 -> 462 bytes .../cz/spsmb/ctvrtak/b_anotace/Testovat.class | Bin 0 -> 524 bytes .../ctvrtak/b_anotace/package-info.class | Bin 0 -> 217 bytes .../c_spring/a_config/main/java/Doc.class | Bin 0 -> 1906 bytes .../a_config/main/java/SearchEngine.class | Bin 0 -> 441 bytes .../c_spring/a_config/main/java/Type.class | Bin 0 -> 1683 bytes .../c_spring/a_config/main/java/Zadani.class | Bin 0 -> 333 bytes .../a_config/test/java/Assertions.class | Bin 0 -> 1174 bytes .../a_config/test/java/MyDocumentTest.class | Bin 0 -> 966 bytes .../a_config/test/java/MySearchEngine.class | Bin 0 -> 2160 bytes 45 files changed, 693 insertions(+), 512 deletions(-) create mode 100644 src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.java create mode 100644 src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.java create mode 100644 src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.java create mode 100644 src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.java create mode 100644 src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.java create mode 100644 src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.java create mode 100644 target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.class create mode 100644 target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.class create mode 100644 target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.class create mode 100644 target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.class create mode 100644 target/classes/cz/spsmb/ctvrtak/b_anotace/A.class create mode 100644 target/classes/cz/spsmb/ctvrtak/b_anotace/AUvod.class create mode 100644 target/classes/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.class create mode 100644 target/classes/cz/spsmb/ctvrtak/b_anotace/CAnotaceVeStdKnihovne.class create mode 100644 target/classes/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.class create mode 100644 target/classes/cz/spsmb/ctvrtak/b_anotace/Den.class create mode 100644 target/classes/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.class create mode 100644 target/classes/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.class create mode 100644 target/classes/cz/spsmb/ctvrtak/b_anotace/SampleAnnotation.class create mode 100644 target/classes/cz/spsmb/ctvrtak/b_anotace/Testovat.class create mode 100644 target/classes/cz/spsmb/ctvrtak/b_anotace/package-info.class create mode 100644 target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.class create mode 100644 target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.class create mode 100644 target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.class create mode 100644 target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.class create mode 100644 target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.class create mode 100644 target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.class create mode 100644 target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.class diff --git a/pom.xml b/pom.xml index e7374e5..f7c36aa 100644 --- a/pom.xml +++ b/pom.xml @@ -1,38 +1,38 @@ - - - 4.0.0 - - org.example - PRO4 - 1.0-SNAPSHOT - - - org.junit.jupiter - junit-jupiter-api - 5.9.0 - - - org.springframework - spring-context - 5.3.22 - - - org.reflections - reflections - 0.10.2 - - - org.springframework - spring-core - 5.3.22 - - - - - 16 - 16 - - + + + 4.0.0 + + org.example + PRO4 + 1.0-SNAPSHOT + + + org.junit.jupiter + junit-jupiter-api + 5.9.0 + + + org.springframework + spring-context + 5.3.22 + + + org.reflections + reflections + 0.10.2 + + + org.springframework + spring-core + 5.3.22 + + + + + 16 + 16 + + \ No newline at end of file diff --git a/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.java b/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.java index 6ca84c4..20449cd 100644 --- a/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.java +++ b/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.java @@ -1,29 +1,29 @@ -package cz.spsmb.ctvrtak.a_promenny_pocet_argumentu_metod; - -import java.util.Arrays; - -/*** - * Java umožňuje definovat metody, které můžeme pokaždé volat s jiným počtem argumentů, přestože - * se počet jejich parametrů nezmění. - * Chceme-li definovat metodu s proměnným počtem argumentů, je potřeba definovat společný typ argumentů, - * jejichž počet předem neznáme. V seznamu parametrů tento typ uvádíme jako poslední a připíšeme za něj - * tzv. "výpustku" v podobě tří teček. - * Tento proměnný počet argumentů je reprezentován obyčejným jednorozměrným polem. - * - */ -public class AUvod { - public static void variant(String title, int... args) { - int count = args.length; - System.out.println(count + " volitelných argumentů pro " + title); - System.out.println("Argumenty: " + Arrays.toString(args)); - } - - public static void main(String[] args) { - // může být i nulový počet argumentů - variant("Nic"); - variant("pět", 1, 2, 3, 4, 5); - // mohu zadat i pole jako argumenty - int[] a = {5, 4, 3, 2, 1}; - variant("dalsi", a); - } -} +package cz.spsmb.ctvrtak.a_promenny_pocet_argumentu_metod; + +import java.util.Arrays; + +/*** + * Java umožňuje definovat metody, které můžeme pokaždé volat s jiným počtem argumentů, přestože + * se počet jejich parametrů nezmění. + * Chceme-li definovat metodu s proměnným počtem argumentů, je potřeba definovat společný typ argumentů, + * jejichž počet předem neznáme. V seznamu parametrů tento typ uvádíme jako poslední a připíšeme za něj + * tzv. "výpustku" v podobě tří teček. + * Tento proměnný počet argumentů je reprezentován obyčejným jednorozměrným polem. + * + */ +public class AUvod { + public static void variant(String title, int... args) { + int count = args.length; + System.out.println(count + " volitelných argumentů pro " + title); + System.out.println("Argumenty: " + Arrays.toString(args)); + } + + public static void main(String[] args) { + // může být i nulový počet argumentů + variant("Nic"); + variant("pět", 1, 2, 3, 4, 5); + // mohu zadat i pole jako argumenty + int[] a = {5, 4, 3, 2, 1}; + variant("dalsi", a); + } +} diff --git a/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.java b/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.java index 262c402..1498729 100644 --- a/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.java +++ b/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.java @@ -1,28 +1,28 @@ -package cz.spsmb.ctvrtak.a_promenny_pocet_argumentu_metod; - -import java.util.ArrayList; - -/*** - * Není možné vytvářet pole s prvky typového parametru ani parametrizovaného typu, i když je můžeme - * deklarovat jako typ vytvářené proměnné. Pokus o vytvoření pole generického typu vyvolá syntaktickou - * chybu, a to přesto, že pole instancí surového typu vytvořit lze. - */ -public class BGenerikaAPole { - public static void main(String[] args) { - //Diamantový operátor - nelze: - //ArrayList[] listS = new ArrayList<>[5]; - - //Explicitní uvedení typu - nelze: - //ArrayList[] listS = new ArrayList[5]; - - //Pole surových typů - lze, ale přicházíme o typovou kontrolu: - //ArrayList[] listS = new ArrayList[5]; - - // Pole je deklarováno jako generické, ale má přiřazené instance surového typu - lze, ale vypíše varování: - ArrayList[] listS2 = new ArrayList[5]; - //Důležité je, že to funguje: - listS2[0] = new ArrayList(); - //Nelze - //listS2[1] = new ArrayList(); - } -} +package cz.spsmb.ctvrtak.a_promenny_pocet_argumentu_metod; + +import java.util.ArrayList; + +/*** + * Není možné vytvářet pole s prvky typového parametru ani parametrizovaného typu, i když je můžeme + * deklarovat jako typ vytvářené proměnné. Pokus o vytvoření pole generického typu vyvolá syntaktickou + * chybu, a to přesto, že pole instancí surového typu vytvořit lze. + */ +public class BGenerikaAPole { + public static void main(String[] args) { + //Diamantový operátor - nelze: + //ArrayList[] listS = new ArrayList<>[5]; + + //Explicitní uvedení typu - nelze: + //ArrayList[] listS = new ArrayList[5]; + + //Pole surových typů - lze, ale přicházíme o typovou kontrolu: + //ArrayList[] listS = new ArrayList[5]; + + // Pole je deklarováno jako generické, ale má přiřazené instance surového typu - lze, ale vypíše varování: + ArrayList[] listS2 = new ArrayList[5]; + //Důležité je, že to funguje: + listS2[0] = new ArrayList(); + //Nelze + //listS2[1] = new ArrayList(); + } +} diff --git a/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.java b/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.java index 63cdb50..a7cc236 100644 --- a/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.java +++ b/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.java @@ -1,27 +1,27 @@ -package cz.spsmb.ctvrtak.a_promenny_pocet_argumentu_metod; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -public class CPromennyPocetArgumentuAParametrickeTypy { - /*** - * Takto obdržíme varovné hlášení. To lze potlačit anotací @SuppressWarnings("unchecked"), - * nicméně pro tento případ byla vytvořena anotace @SafeVarargs - * @param lists - */ - public static void mtd(List... lists){ - - } - @SafeVarargs - public static void m(List... stringLists){ //není bezpečné - Object[] array = stringLists; - List tmpList = Arrays.asList(42); - array[0] = tmpList; //sémanticky špatně, překlad však proběhne bez problémů - String s = stringLists[0].get(0); // Dostáváme CastClassException za běhu v silně typovaném jazyce ! - - } - public static void main(String[] args) { - m(new ArrayList(), new ArrayList()); - } -} +package cz.spsmb.ctvrtak.a_promenny_pocet_argumentu_metod; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class CPromennyPocetArgumentuAParametrickeTypy { + /*** + * Takto obdržíme varovné hlášení. To lze potlačit anotací @SuppressWarnings("unchecked"), + * nicméně pro tento případ byla vytvořena anotace @SafeVarargs + * @param lists + */ + public static void mtd(List... lists){ + + } + @SafeVarargs + public static void m(List... stringLists){ //není bezpečné + Object[] array = stringLists; + List tmpList = Arrays.asList(42); + array[0] = tmpList; //sémanticky špatně, překlad však proběhne bez problémů + String s = stringLists[0].get(0); // Dostáváme CastClassException za běhu v silně typovaném jazyce ! + + } + public static void main(String[] args) { + m(new ArrayList(), new ArrayList()); + } +} diff --git a/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.java b/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.java index 29dcfab..44194f5 100644 --- a/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.java +++ b/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.java @@ -1,27 +1,27 @@ -package cz.spsmb.ctvrtak.a_promenny_pocet_argumentu_metod; - -import java.util.ArrayList; - -/*** - * Díky anotaci @SafeVarargs nyní můžeme vytvořit doposud zakázaná pole. Stačí definovat metodu s proměnným počtem - * argumentů a pole stěmito argumenty pak vrátit jako funkční hodnotu. - */ -public class DVytvoreniPoleSGenerickymiInstancemi { - @SafeVarargs - public static E[] arrayOf(E... array){ - return array; - } - - public static void main(String[] args) { - var aint = arrayOf(1, 2, 3, 5, 7, 11); - var astr = arrayOf("raz", "dva", "tři"); - var abool = arrayOf(true, false, false); - var alist = arrayOf(new ArrayList(), new ArrayList(), new ArrayList()); - - // U takto vytvořeného pole překladač nekontroluje typ přiřazované hodnoty. tj. následující kód vede k chybě - // v runtime: - Object[] oo = aint; - oo[0] = "NULA"; - } - -} +package cz.spsmb.ctvrtak.a_promenny_pocet_argumentu_metod; + +import java.util.ArrayList; + +/*** + * Díky anotaci @SafeVarargs nyní můžeme vytvořit doposud zakázaná pole. Stačí definovat metodu s proměnným počtem + * argumentů a pole stěmito argumenty pak vrátit jako funkční hodnotu. + */ +public class DVytvoreniPoleSGenerickymiInstancemi { + @SafeVarargs + public static E[] arrayOf(E... array){ + return array; + } + + public static void main(String[] args) { + var aint = arrayOf(1, 2, 3, 5, 7, 11); + var astr = arrayOf("raz", "dva", "tři"); + var abool = arrayOf(true, false, false); + var alist = arrayOf(new ArrayList(), new ArrayList(), new ArrayList()); + + // U takto vytvořeného pole překladač nekontroluje typ přiřazované hodnoty. tj. následující kód vede k chybě + // v runtime: + Object[] oo = aint; + oo[0] = "NULA"; + } + +} diff --git a/src/main/java/cz/spsmb/ctvrtak/b_anotace/A.java b/src/main/java/cz/spsmb/ctvrtak/b_anotace/A.java index 0472793..7222ba8 100644 --- a/src/main/java/cz/spsmb/ctvrtak/b_anotace/A.java +++ b/src/main/java/cz/spsmb/ctvrtak/b_anotace/A.java @@ -1,10 +1,10 @@ -package cz.spsmb.ctvrtak.b_anotace; - -import java.lang.annotation.Target; - -import static java.lang.annotation.ElementType.PARAMETER; -import static java.lang.annotation.ElementType.TYPE_PARAMETER; - -@Target({PARAMETER, TYPE_PARAMETER}) -public @interface A { -} +package cz.spsmb.ctvrtak.b_anotace; + +import java.lang.annotation.Target; + +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE_PARAMETER; + +@Target({PARAMETER, TYPE_PARAMETER}) +public @interface A { +} diff --git a/src/main/java/cz/spsmb/ctvrtak/b_anotace/AUvod.java b/src/main/java/cz/spsmb/ctvrtak/b_anotace/AUvod.java index 8fb5a88..6cc1588 100644 --- a/src/main/java/cz/spsmb/ctvrtak/b_anotace/AUvod.java +++ b/src/main/java/cz/spsmb/ctvrtak/b_anotace/AUvod.java @@ -1,42 +1,42 @@ -package cz.spsmb.ctvrtak.b_anotace; - -/*** - * Anotace (občas používáme termín metadata) jsou značky vkládané do zdrojového kódu a - * určené pro - * - nástroje pro práci se zdrojovým kódem, např. javadoc - * - začlenění do přeloženého .class souboru a určeny pro nástroje pracující s těmito - * soubory (Např. nástroje připravující instalaci na aplikační server), před vlastním - * spuštěním programu - * - mohou být začleněny do class souboru a určeny pro zpracování za běhu programu - * s pomocí reflexe. - * - * Označení anotace provádíme znakem @. Za ním může být klidně jedna, nebo více mezer. - * - * Anotace, které nedefinují žádné parametry jsou označovány jako "značky" (markers) případně - * "značkovací anotace" (marker annotations). Jedná se o obdobu "značkovacích rozhraní" - * (marker interfaces), které neobsahují žádnou metodu (Př. Cloneable, Serializable...). - * - */ -public class AUvod { - //Příklad značkovací anotace: - @MojeAnotace - public static void test(){ - return; - } - //Anotace mohou mít parametry: - @Testovat(druh = "A") - public static void mojeMetoda(){ - - } - //Parametrem anotace může být i pole. Ve skutečnosti se však žádné pole nevytváří a výčet ve - // složených závorkách je jediným povoleným způsobem, jak anotaci předat skupinu hodnot: - @Testovat(frekvence = {Den.SO, Den.NE}) - public static void mojeMetoda2(){ - - } - // deklaraci lze označit i více anotacemi: - @Testovat - @MojeAnotace - public static void mojeMetoda3(){} - -} +package cz.spsmb.ctvrtak.b_anotace; + +/*** + * Anotace (občas používáme termín metadata) jsou značky vkládané do zdrojového kódu a + * určené pro + * - nástroje pro práci se zdrojovým kódem, např. javadoc + * - začlenění do přeloženého .class souboru a určeny pro nástroje pracující s těmito + * soubory (Např. nástroje připravující instalaci na aplikační server), před vlastním + * spuštěním programu + * - mohou být začleněny do class souboru a určeny pro zpracování za běhu programu + * s pomocí reflexe. + * + * Označení anotace provádíme znakem @. Za ním může být klidně jedna, nebo více mezer. + * + * Anotace, které nedefinují žádné parametry jsou označovány jako "značky" (markers) případně + * "značkovací anotace" (marker annotations). Jedná se o obdobu "značkovacích rozhraní" + * (marker interfaces), které neobsahují žádnou metodu (Př. Cloneable, Serializable...). + * + */ +public class AUvod { + //Příklad značkovací anotace: + @MojeAnotace + public static void test(){ + return; + } + //Anotace mohou mít parametry: + @Testovat(druh = "A") + public static void mojeMetoda(){ + + } + //Parametrem anotace může být i pole. Ve skutečnosti se však žádné pole nevytváří a výčet ve + // složených závorkách je jediným povoleným způsobem, jak anotaci předat skupinu hodnot: + @Testovat(frekvence = {Den.SO, Den.NE}) + public static void mojeMetoda2(){ + + } + // deklaraci lze označit i více anotacemi: + @Testovat + @MojeAnotace + public static void mojeMetoda3(){} + +} diff --git a/src/main/java/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.java b/src/main/java/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.java index ab2c10a..9767e67 100644 --- a/src/main/java/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.java +++ b/src/main/java/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.java @@ -1,64 +1,64 @@ -package cz.spsmb.ctvrtak.b_anotace; - -/* - * Anotovat lze atributy (proměnné), konstruktory, metody, parametry metod (vč. parametru this), - * typové argumenty parametrizovaných typů, jakoukoliv část deklarace pole, rodičovskou třídu, či - * implementované rozhraní, volání konstruktoru, Typ v operaci přetypování, či zjišťování příslušnosti - * k typu, při specifikaci vyhazované výjimky, žolík a omezení hodnoty typového parametru, odkaz - * na metodu reprezentovanou pomocí operátoru čtyřtečka - * - * Anotovat nelze literál datového typu - * @A String.class - * importovaný typ - * import Java.lang.@A String - */ - -import java.util.Comparator; - -public class BMoznostiPouzitiAnotace { - Integer o = Integer.valueOf(5); - //Anotace atributu (proměnné): - @MojeAnotace - String atribut = "Atribut"; - //Anotace metody: - @Override - public String toString() {return "";} - //Anotace parametrů metod, vč. this: - @MojeAnotace - public void metoda(/*@A BMoznostiPouzitiAnotace this,*/ @MojeAnotace int i) { - @MojeAnotace String lp = "lokální proměnná"; - } - //Anotace typových argumenty parametrizovaných typů: - //List<@MojeAnotace String> list; - //Comparator.<@MojeAnotace String> reverseOrder(); - - //Anotace deklarace pole - @MojeAnotace int[][] ai0; //anotuje položky typu int (vždy, pokud je anotace uvedena na - // začátku deklaace) - //int @MojeAnotace [][] ai2; //anotuje celé dvourozměrné pole int[][] - //int[] @MojeAnotace [] ai1; //anotuje položky typu int[] - - //Anotace rodičovské třídy a implementovaného rozhraní: - //@MojeAnotace class Child extends @MojeAnotace Parent implements @MojeAnotace Interface - - // Anotace volání konstruktoru: - // new @MojeAnotace Cls(); - - - //Anotace typu v operaci přetypování, či zjišťování příslušnosti k typu, jsou určeny pro spec. - // nástroje na vastní operace nemají vliv: - //String s = (@MojeAnotace String) o; - //boolean b = o instanceof @MojeAnotace String; - - //Anotace při specifikaci vyhazované výjimky: - //void method() throws @MojeAnotace IOException{} - - //Anotace žolíka a omezení hodnoty typového parametru: - //List<@MojeAnotace ? extends String> laem; - //List leam; - - //Anotace odkazu na metodu reprezenovaný operátorem čtyřtečka: - //@MojeAnotace AUvod::test; - - -} +package cz.spsmb.ctvrtak.b_anotace; + +/* + * Anotovat lze atributy (proměnné), konstruktory, metody, parametry metod (vč. parametru this), + * typové argumenty parametrizovaných typů, jakoukoliv část deklarace pole, rodičovskou třídu, či + * implementované rozhraní, volání konstruktoru, Typ v operaci přetypování, či zjišťování příslušnosti + * k typu, při specifikaci vyhazované výjimky, žolík a omezení hodnoty typového parametru, odkaz + * na metodu reprezentovanou pomocí operátoru čtyřtečka + * + * Anotovat nelze literál datového typu + * @A String.class + * importovaný typ + * import Java.lang.@A String + */ + +import java.util.Comparator; + +public class BMoznostiPouzitiAnotace { + Integer o = Integer.valueOf(5); + //Anotace atributu (proměnné): + @MojeAnotace + String atribut = "Atribut"; + //Anotace metody: + @Override + public String toString() {return "";} + //Anotace parametrů metod, vč. this: + @MojeAnotace + public void metoda(/*@A BMoznostiPouzitiAnotace this,*/ @MojeAnotace int i) { + @MojeAnotace String lp = "lokální proměnná"; + } + //Anotace typových argumenty parametrizovaných typů: + //List<@MojeAnotace String> list; + //Comparator.<@MojeAnotace String> reverseOrder(); + + //Anotace deklarace pole + @MojeAnotace int[][] ai0; //anotuje položky typu int (vždy, pokud je anotace uvedena na + // začátku deklaace) + //int @MojeAnotace [][] ai2; //anotuje celé dvourozměrné pole int[][] + //int[] @MojeAnotace [] ai1; //anotuje položky typu int[] + + //Anotace rodičovské třídy a implementovaného rozhraní: + //@MojeAnotace class Child extends @MojeAnotace Parent implements @MojeAnotace Interface + + // Anotace volání konstruktoru: + // new @MojeAnotace Cls(); + + + //Anotace typu v operaci přetypování, či zjišťování příslušnosti k typu, jsou určeny pro spec. + // nástroje na vastní operace nemají vliv: + //String s = (@MojeAnotace String) o; + //boolean b = o instanceof @MojeAnotace String; + + //Anotace při specifikaci vyhazované výjimky: + //void method() throws @MojeAnotace IOException{} + + //Anotace žolíka a omezení hodnoty typového parametru: + //List<@MojeAnotace ? extends String> laem; + //List leam; + + //Anotace odkazu na metodu reprezenovaný operátorem čtyřtečka: + //@MojeAnotace AUvod::test; + + +} diff --git a/src/main/java/cz/spsmb/ctvrtak/b_anotace/CAnotaceVeStdKnihovne.java b/src/main/java/cz/spsmb/ctvrtak/b_anotace/CAnotaceVeStdKnihovne.java index f19d89c..b7a4c7f 100644 --- a/src/main/java/cz/spsmb/ctvrtak/b_anotace/CAnotaceVeStdKnihovne.java +++ b/src/main/java/cz/spsmb/ctvrtak/b_anotace/CAnotaceVeStdKnihovne.java @@ -1,21 +1,21 @@ -package cz.spsmb.ctvrtak.b_anotace; - -/*** - * @Deprecated - nemá parametry, lze použít u libovolné deklarace. Oznamuje, že jí označená - * deklarace je považována za zavrženou a neměla by se používat (nejčastěji metoda, typ). - * Překladač je povinnen vydat varovná hlášení. Ty lze potlačit anotací - * @SuppressWarning("deprecation") - * @Override - bezparametrická, určena k označení metod, které mají přebít stejnojmenné metody - * v rodičovské třídě. Užitečné, neboť často dochází k nechtěnému přetěžování namísto - * překrytí. - * @SuppressWarnings - jako parametr má definován vektor stringů specifikujících varování, která - * má překladač potlačit při překladu anotované entity a všech entit, které obsahuje. - * Příklad: @SuppressWarnings({"unchecked", "rawtypes"}) - * @SafeVarargs - * @FunctionalInterface - kontrola, zda rozhraní je funkční, tedy má deklarovánu právě jednu metodu a - * může být použito pro lambda výraz. - * - */ -public class CAnotaceVeStdKnihovne { - -} +package cz.spsmb.ctvrtak.b_anotace; + +/*** + * @Deprecated - nemá parametry, lze použít u libovolné deklarace. Oznamuje, že jí označená + * deklarace je považována za zavrženou a neměla by se používat (nejčastěji metoda, typ). + * Překladač je povinnen vydat varovná hlášení. Ty lze potlačit anotací + * @SuppressWarning("deprecation") + * @Override - bezparametrická, určena k označení metod, které mají přebít stejnojmenné metody + * v rodičovské třídě. Užitečné, neboť často dochází k nechtěnému přetěžování namísto + * překrytí. + * @SuppressWarnings - jako parametr má definován vektor stringů specifikujících varování, která + * má překladač potlačit při překladu anotované entity a všech entit, které obsahuje. + * Příklad: @SuppressWarnings({"unchecked", "rawtypes"}) + * @SafeVarargs + * @FunctionalInterface - kontrola, zda rozhraní je funkční, tedy má deklarovánu právě jednu metodu a + * může být použito pro lambda výraz. + * + */ +public class CAnotaceVeStdKnihovne { + +} diff --git a/src/main/java/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.java b/src/main/java/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.java index b5dc047..0a64f73 100644 --- a/src/main/java/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.java +++ b/src/main/java/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.java @@ -1,37 +1,37 @@ -package cz.spsmb.ctvrtak.b_anotace; - -/*** - * Metaanotace jsou anotace určené k označení definic jiných anotací. - * - * @Documented - bez parametrů. Sděluje, že jí anotovaná anotace má být uvedena v dokumentaci touto - * anotací označených entit. Javadoc jí pak uvede jako součást popisu dokumentace. Příkladem - * je anotace @Deprecated. - * @Inherited - indikuje, že anotace jejíž definici s ní označíme, se stane součístí dědictví dceřinných - * tříd touto anotací označené třídy. Má smysl pouze v případě, že se na ní dotazujeme v - * runtime a jen u tříd. - * @Repeatable - označuje, že jí označená anotace může být v jedné deklaraci použita opakovaně. - * @Retention - jednoparametrická, parametr typu java.lang.annotation.RetentionPolicy, což je výčtový typ: - * SOURCE - pouze pro programy pracující se zdrojovým kódem (např. překladač). Do přeloženého - * souboru se už daná informace nedostane. - * CLASS - takto označená anotace se dostane až do .class souboru. Využít to mohou programy pro - * instalaci. Zavaděč tříd jí však nezapracuje do runtime. Výchozí hodnota. - * RUNTIME - informace o anotaci se dostane až do class-objektu třídy, kterou anotace označuje. - * pomocí reflexe je pak možné za běhu příslušnou informaci zjistit. - * @Target - jednoparametrická, specifikuje, které druhy entit je možno jí označenou anotací - * označit výčtový typ java.lang.annotation.ElementType: - * ANNOTATION_TYPE - definice jiné anotace - * CONSTRUCTOR - definice konstruktoru - * FIELD - deklarace atributu - * LOCAL_VARIABLE - deklarace lokální proměnné - * METHOD - deklarace metody - * MODULE - deklarace modulu - * PACKAGE - deklarace balíčku - * PARAMETER - deklarace parametru - * TYPE - deklarace třídy, rozhraní (vč anotací) nebo výčtu - * TYPE_PARAMETER - deklarace typového parametru - * TYPE_USE - použití datového typu. - * - * Anotace parametrů a lokálních proměnných se nikdy nedostanou dál, než je zdrojový kód. - */ -public class DMetaanotace { -} +package cz.spsmb.ctvrtak.b_anotace; + +/*** + * Metaanotace jsou anotace určené k označení definic jiných anotací. + * + * @Documented - bez parametrů. Sděluje, že jí anotovaná anotace má být uvedena v dokumentaci touto + * anotací označených entit. Javadoc jí pak uvede jako součást popisu dokumentace. Příkladem + * je anotace @Deprecated. + * @Inherited - indikuje, že anotace jejíž definici s ní označíme, se stane součístí dědictví dceřinných + * tříd touto anotací označené třídy. Má smysl pouze v případě, že se na ní dotazujeme v + * runtime a jen u tříd. + * @Repeatable - označuje, že jí označená anotace může být v jedné deklaraci použita opakovaně. + * @Retention - jednoparametrická, parametr typu java.lang.annotation.RetentionPolicy, což je výčtový typ: + * SOURCE - pouze pro programy pracující se zdrojovým kódem (např. překladač). Do přeloženého + * souboru se už daná informace nedostane. + * CLASS - takto označená anotace se dostane až do .class souboru. Využít to mohou programy pro + * instalaci. Zavaděč tříd jí však nezapracuje do runtime. Výchozí hodnota. + * RUNTIME - informace o anotaci se dostane až do class-objektu třídy, kterou anotace označuje. + * pomocí reflexe je pak možné za běhu příslušnou informaci zjistit. + * @Target - jednoparametrická, specifikuje, které druhy entit je možno jí označenou anotací + * označit výčtový typ java.lang.annotation.ElementType: + * ANNOTATION_TYPE - definice jiné anotace + * CONSTRUCTOR - definice konstruktoru + * FIELD - deklarace atributu + * LOCAL_VARIABLE - deklarace lokální proměnné + * METHOD - deklarace metody + * MODULE - deklarace modulu + * PACKAGE - deklarace balíčku + * PARAMETER - deklarace parametru + * TYPE - deklarace třídy, rozhraní (vč anotací) nebo výčtu + * TYPE_PARAMETER - deklarace typového parametru + * TYPE_USE - použití datového typu. + * + * Anotace parametrů a lokálních proměnných se nikdy nedostanou dál, než je zdrojový kód. + */ +public class DMetaanotace { +} diff --git a/src/main/java/cz/spsmb/ctvrtak/b_anotace/Den.java b/src/main/java/cz/spsmb/ctvrtak/b_anotace/Den.java index 87470e9..81d836f 100644 --- a/src/main/java/cz/spsmb/ctvrtak/b_anotace/Den.java +++ b/src/main/java/cz/spsmb/ctvrtak/b_anotace/Den.java @@ -1,11 +1,11 @@ -package cz.spsmb.ctvrtak.b_anotace; - -public enum Den { - PO, - ÚT, - ST, - ČT, - PÁ, - SO, - NE -} +package cz.spsmb.ctvrtak.b_anotace; + +public enum Den { + PO, + ÚT, + ST, + ČT, + PÁ, + SO, + NE +} diff --git a/src/main/java/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.java b/src/main/java/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.java index 5144a0f..48b63d9 100644 --- a/src/main/java/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.java +++ b/src/main/java/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.java @@ -1,114 +1,114 @@ -package cz.spsmb.ctvrtak.b_anotace; - -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.Test; -import org.reflections.Reflections; -import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition; -import org.springframework.beans.factory.config.BeanDefinition; -import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; -import org.springframework.core.annotation.AnnotationUtils; -import org.springframework.core.type.filter.AnnotationTypeFilter; -import org.springframework.util.ClassUtils; - -import java.lang.reflect.Method; -import java.util.*; -import java.util.stream.Collectors; - -/*** - * https://www.baeldung.com/java-scan-annotations-runtime - */ -@SampleAnnotation(name = "annotatedClass") -public class EPrikladRuntimeAnotace { - @SampleAnnotation(name = "annotatedMethod") - public void annotatedMethod() { - //Do something - } - - public void notAnnotatedMethod() { - //Do something - } - @Test - public void testWithJavaReflection() throws ClassNotFoundException { - Class clazz = ClassLoader.getSystemClassLoader().loadClass("cz.spsmb.ctvrtak.b_anotace.EPrikladRuntimeAnotace"); - //pomocí reflexe beru anotaci SampleAnnotation k dané třídě - SampleAnnotation classAnnotation = clazz.getAnnotation(SampleAnnotation.class); - Assertions.assertEquals("annotatedClass", classAnnotation.name()); - //Pomocí reflexe získávám seznam metod třídy EPrikladRuntimeAnotace - Method[] methods = clazz.getMethods(); - List annotatedMethods = new ArrayList<>(); - for (Method method : methods) { - SampleAnnotation annotation = method.getAnnotation(SampleAnnotation.class); - if (annotation != null) { - annotatedMethods.add(annotation.name()); - } - } - Assertions.assertEquals(1, annotatedMethods.size()); - Assertions.assertEquals("annotatedMethod", annotatedMethods.get(0)); - } - // Pomocí frameworku Spring můžeme číst třídy, bez znalosti jejich názvu. Zde zadáváme celé jméno balíku, - // kde chceme anotace projít. V tomto případě "cz.spsmb.ctvrtak.b_anotace"; - @Test - public void testWithSpringContext(){ - ClassPathScanningCandidateComponentProvider provider = - new ClassPathScanningCandidateComponentProvider(false); - provider.addIncludeFilter(new AnnotationTypeFilter(SampleAnnotation.class)); - - Set beanDefs = provider - .findCandidateComponents("cz.spsmb.ctvrtak.b_anotace"); - List annotatedBeans = new ArrayList<>(); - for (BeanDefinition bd : beanDefs) { - if (bd instanceof AnnotatedBeanDefinition) { - //výběr parametrů jméno - hodnota dané anotace - Map annotAttributeMap = ((AnnotatedBeanDefinition) bd) - .getMetadata() - .getAnnotationAttributes(SampleAnnotation.class.getCanonicalName()); - //zajímá nás parametr name - annotatedBeans.add(annotAttributeMap.get("name").toString()); - } - } - Assertions.assertEquals(1, annotatedBeans.size()); - Assertions.assertEquals("annotatedClass", annotatedBeans.get(0)); - } - // With the help of AnnotationUtils and ClassUtils, - // it's possible to find the methods and classes annotated with a specific annotation. - @Test - public void testWithSpringCore() { - Class userClass = ClassUtils.getUserClass(EPrikladRuntimeAnotace.class); - - List annotatedMethods = Arrays.stream(userClass.getMethods()) - .filter(method -> AnnotationUtils - .getAnnotation(method, SampleAnnotation.class) != null) - .map(method -> method.getAnnotation(SampleAnnotation.class) - .name()) - .collect(Collectors.toList()); - - Assertions.assertEquals(1, annotatedMethods.size()); - Assertions.assertEquals("annotatedMethod", annotatedMethods.get(0)); - } - //Reflections is a library that is said to be written in the spirit of Scannotations library. - // It scans and indexes the project's classpath metadata. - @Test - public void testWithReflection(){ - Reflections reflections = new Reflections(EPrikladRuntimeAnotace.class); - - Set methods = reflections - .getMethodsAnnotatedWith(SampleAnnotation.class); - List annotatedMethods = methods.stream() - .map(method -> method.getAnnotation(SampleAnnotation.class) - .name()) - .collect(Collectors.toList()); - - Assertions.assertEquals(1, annotatedMethods.size()); - Assertions.assertEquals("annotatedMethod", annotatedMethods.get(0)); - - Set> types = reflections - .getTypesAnnotatedWith(SampleAnnotation.class); - List annotatedClasses = types.stream() - .map(clazz -> clazz.getAnnotation(SampleAnnotation.class) - .name()) - .collect(Collectors.toList()); - - Assertions.assertEquals(1, annotatedClasses.size()); - Assertions.assertEquals("SampleAnnotatedClass", annotatedClasses.get(0)); - } -} +package cz.spsmb.ctvrtak.b_anotace; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.reflections.Reflections; +import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition; +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; +import org.springframework.core.annotation.AnnotationUtils; +import org.springframework.core.type.filter.AnnotationTypeFilter; +import org.springframework.util.ClassUtils; + +import java.lang.reflect.Method; +import java.util.*; +import java.util.stream.Collectors; + +/*** + * https://www.baeldung.com/java-scan-annotations-runtime + */ +@SampleAnnotation(name = "annotatedClass") +public class EPrikladRuntimeAnotace { + @SampleAnnotation(name = "annotatedMethod") + public void annotatedMethod() { + //Do something + } + + public void notAnnotatedMethod() { + //Do something + } + @Test + public void testWithJavaReflection() throws ClassNotFoundException { + Class clazz = ClassLoader.getSystemClassLoader().loadClass("cz.spsmb.ctvrtak.b_anotace.EPrikladRuntimeAnotace"); + //pomocí reflexe beru anotaci SampleAnnotation k dané třídě + SampleAnnotation classAnnotation = clazz.getAnnotation(SampleAnnotation.class); + Assertions.assertEquals("annotatedClass", classAnnotation.name()); + //Pomocí reflexe získávám seznam metod třídy EPrikladRuntimeAnotace + Method[] methods = clazz.getMethods(); + List annotatedMethods = new ArrayList<>(); + for (Method method : methods) { + SampleAnnotation annotation = method.getAnnotation(SampleAnnotation.class); + if (annotation != null) { + annotatedMethods.add(annotation.name()); + } + } + Assertions.assertEquals(1, annotatedMethods.size()); + Assertions.assertEquals("annotatedMethod", annotatedMethods.get(0)); + } + // Pomocí frameworku Spring můžeme číst třídy, bez znalosti jejich názvu. Zde zadáváme celé jméno balíku, + // kde chceme anotace projít. V tomto případě "cz.spsmb.ctvrtak.b_anotace"; + @Test + public void testWithSpringContext(){ + ClassPathScanningCandidateComponentProvider provider = + new ClassPathScanningCandidateComponentProvider(false); + provider.addIncludeFilter(new AnnotationTypeFilter(SampleAnnotation.class)); + + Set beanDefs = provider + .findCandidateComponents("cz.spsmb.ctvrtak.b_anotace"); + List annotatedBeans = new ArrayList<>(); + for (BeanDefinition bd : beanDefs) { + if (bd instanceof AnnotatedBeanDefinition) { + //výběr parametrů jméno - hodnota dané anotace + Map annotAttributeMap = ((AnnotatedBeanDefinition) bd) + .getMetadata() + .getAnnotationAttributes(SampleAnnotation.class.getCanonicalName()); + //zajímá nás parametr name + annotatedBeans.add(annotAttributeMap.get("name").toString()); + } + } + Assertions.assertEquals(1, annotatedBeans.size()); + Assertions.assertEquals("annotatedClass", annotatedBeans.get(0)); + } + // With the help of AnnotationUtils and ClassUtils, + // it's possible to find the methods and classes annotated with a specific annotation. + @Test + public void testWithSpringCore() { + Class userClass = ClassUtils.getUserClass(EPrikladRuntimeAnotace.class); + + List annotatedMethods = Arrays.stream(userClass.getMethods()) + .filter(method -> AnnotationUtils + .getAnnotation(method, SampleAnnotation.class) != null) + .map(method -> method.getAnnotation(SampleAnnotation.class) + .name()) + .collect(Collectors.toList()); + + Assertions.assertEquals(1, annotatedMethods.size()); + Assertions.assertEquals("annotatedMethod", annotatedMethods.get(0)); + } + //Reflections is a library that is said to be written in the spirit of Scannotations library. + // It scans and indexes the project's classpath metadata. + @Test + public void testWithReflection(){ + Reflections reflections = new Reflections(EPrikladRuntimeAnotace.class); + + Set methods = reflections + .getMethodsAnnotatedWith(SampleAnnotation.class); + List annotatedMethods = methods.stream() + .map(method -> method.getAnnotation(SampleAnnotation.class) + .name()) + .collect(Collectors.toList()); + + Assertions.assertEquals(1, annotatedMethods.size()); + Assertions.assertEquals("annotatedMethod", annotatedMethods.get(0)); + + Set> types = reflections + .getTypesAnnotatedWith(SampleAnnotation.class); + List annotatedClasses = types.stream() + .map(clazz -> clazz.getAnnotation(SampleAnnotation.class) + .name()) + .collect(Collectors.toList()); + + Assertions.assertEquals(1, annotatedClasses.size()); + Assertions.assertEquals("SampleAnnotatedClass", annotatedClasses.get(0)); + } +} diff --git a/src/main/java/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.java b/src/main/java/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.java index 9262515..3f21b3a 100644 --- a/src/main/java/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.java +++ b/src/main/java/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.java @@ -1,4 +1,4 @@ -package cz.spsmb.ctvrtak.b_anotace; -//Značkovací anotace, nic neobsahuje -public @interface MojeAnotace { -} +package cz.spsmb.ctvrtak.b_anotace; +//Značkovací anotace, nic neobsahuje +public @interface MojeAnotace { +} diff --git a/src/main/java/cz/spsmb/ctvrtak/b_anotace/SampleAnnotation.java b/src/main/java/cz/spsmb/ctvrtak/b_anotace/SampleAnnotation.java index 8d46549..ef5b469 100644 --- a/src/main/java/cz/spsmb/ctvrtak/b_anotace/SampleAnnotation.java +++ b/src/main/java/cz/spsmb/ctvrtak/b_anotace/SampleAnnotation.java @@ -1,14 +1,14 @@ -package cz.spsmb.ctvrtak.b_anotace; - -import java.lang.annotation.Retention; -import java.lang.annotation.Target; - -import static java.lang.annotation.ElementType.METHOD; -import static java.lang.annotation.ElementType.TYPE; -import static java.lang.annotation.RetentionPolicy.RUNTIME; - -@Target({ METHOD, TYPE }) -@Retention(RUNTIME) -public @interface SampleAnnotation { - String name(); -} +package cz.spsmb.ctvrtak.b_anotace; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +@Target({ METHOD, TYPE }) +@Retention(RUNTIME) +public @interface SampleAnnotation { + String name(); +} diff --git a/src/main/java/cz/spsmb/ctvrtak/b_anotace/Testovat.java b/src/main/java/cz/spsmb/ctvrtak/b_anotace/Testovat.java index aaff48c..5bcafd6 100644 --- a/src/main/java/cz/spsmb/ctvrtak/b_anotace/Testovat.java +++ b/src/main/java/cz/spsmb/ctvrtak/b_anotace/Testovat.java @@ -1,11 +1,11 @@ -package cz.spsmb.ctvrtak.b_anotace; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Target; - -//Parametrická anotace -@Target({ElementType.METHOD}) -public @interface Testovat { - public String druh() default ""; - public Den[] frekvence() default {Den.PO, Den.ÚT, Den.ST, Den.ČT, Den.PÁ}; -} +package cz.spsmb.ctvrtak.b_anotace; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; + +//Parametrická anotace +@Target({ElementType.METHOD}) +public @interface Testovat { + public String druh() default ""; + public Den[] frekvence() default {Den.PO, Den.ÚT, Den.ST, Den.ČT, Den.PÁ}; +} diff --git a/src/main/java/cz/spsmb/ctvrtak/b_anotace/package-info.java b/src/main/java/cz/spsmb/ctvrtak/b_anotace/package-info.java index dd6dc5b..52e1c9b 100644 --- a/src/main/java/cz/spsmb/ctvrtak/b_anotace/package-info.java +++ b/src/main/java/cz/spsmb/ctvrtak/b_anotace/package-info.java @@ -1,3 +1,3 @@ -// Anotace balíčku: -@MojeAnotace +// Anotace balíčku: +@MojeAnotace package cz.spsmb.ctvrtak.b_anotace; \ No newline at end of file diff --git a/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.java b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.java new file mode 100644 index 0000000..3fa0e5e --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.java @@ -0,0 +1,47 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.main.java; + +public class Doc { + + public String name; + public String location; + public Type type; + + public Doc(String name, String location, Type type) { + this.name = name; + this.location = location; + this.type = type; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getLocation() { + return location; + } + + public void setLocation(String location) { + this.location = location; + } + + public Type getType() { + return type; + } + + public void setType(Type type) { + this.type = type; + } + + @Override + public String toString() { + return "Doc{" + + "name='" + name + '\'' + + ", location='" + location + '\'' + + ", type=" + type + + '}'; + } +} diff --git a/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.java b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.java new file mode 100644 index 0000000..36459d2 --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.java @@ -0,0 +1,10 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.main.java; + +import java.util.List; + +public interface SearchEngine { + + List listAll(); + List findByType(String typeName); + +} diff --git a/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.java b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.java new file mode 100644 index 0000000..9776602 --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.java @@ -0,0 +1,46 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.main.java; + +public class Type { + public String name; + public String desc; + public String extension; + + public Type(String name, String desc, String extension) { + this.name = name; + this.desc = desc; + this.extension = extension; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDesc() { + return desc; + } + + public void setDesc(String desc) { + this.desc = desc; + } + + public String getExtension() { + return extension; + } + + public void setExtension(String extension) { + this.extension = extension; + } + + @Override + public String toString() { + return "Type{" + + "name='" + name + '\'' + + ", desc='" + desc + '\'' + + ", extension='" + extension + '\'' + + '}'; + } +} diff --git a/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.java b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.java index bcbe042..e2cc511 100644 --- a/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.java +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.java @@ -1,34 +1,37 @@ -package cz.spsmb.ctvrtak.c_spring.a_config.main.java; - -/*** - * 1. - * V balíčku cz.spsmb.ctvrtak.c_spring.a_config.main.java vytvořte následující třídy - * s konstruktorem, gettery a settery: - * Type, členské proměnné name, desc, extension - všechny typu String - * Doc, členské proměnné String name, String location, Type type - * - * Dále vytvořte ve stejném balíčku rozhraní SearchEngine, které obsahuje metody - * List listAll(); - * List findByType() - * - * 2. V nově vytvořeném balíčku cz.spsmb.ctvrtak.c_spring.a_config.test.java vytvořte třídu - * MySearchEngine, která bude implementovat rozhraní SearchEngine z bodu 1. Implementujte zde - * i privátní pomocnou metodu storage(), která vrátí vámi vygenerovaný ArrayList instancí třídy Doc. - * Vymyslete si 2 typy (třída Type) a ke každému typu si vymyslete 2 dokumenty (třída Doc) - * - * 3. v balíčku cz.spsmb.ctvrtak.c_spring.a_config.test.java vytvořte třídu MyDocumentTest, která - * obsahuje členskou proměnnou - * private SearchEngine engine = new MySearchEngine; - * - * Třída MyDocumentTest bude pomocí frameworku junit.jupiter (v projektu PRO4 již zaimplementován) - * implementovat metodu - * @Test testFindByType(), která otestuje, zda vámi zadaný typ uvnitř této metody je nalezen pomocí - * metody engine.findByType(vasDocumentType) a metodu - * @Test testListAll, která zkontroluje, zda metoda engine.listAll(vrací správný počet argumentů). - * - * V obou případech použijte třídu Assertions pro kontrolu výsledků. - * - * 4. výsledek pošlete pull-requestem zpátky na github pro oznámkování. - */ -public class Zadani { -} +package cz.spsmb.ctvrtak.c_spring.a_config.main.java; + +/*** + * 1. + * V balíčku cz.spsmb.ctvrtak.c_spring.a_config.main.java vytvořte následující třídy + * s konstruktorem, gettery a settery: + * Type, členské proměnné name, desc, extension - všechny typu String + * Doc, členské proměnné String name, String location, Type type + * + * Dále vytvořte ve stejném balíčku rozhraní SearchEngine, které obsahuje metody + * List listAll(); + * List findByType() + * + * 2. V nově vytvořeném balíčku cz.spsmb.ctvrtak.c_spring.a_config.test.java vytvořte + * třídu MySearchEngine, která bude implementovat rozhraní SearchEngine z bodu 1. + * Implementujte zde i privátní pomocnou metodu storage(), která vrátí vámi + * vygenerovaný ArrayList instancí třídy Doc. Vymyslete si 2 typy (třída Type) a ke + * každému typu si vymyslete 2 dokumenty (třída Doc) + * + * 3. v balíčku cz.spsmb.ctvrtak.c_spring.a_config.test.java vytvořte třídu + * MyDocumentTest, která obsahuje členskou proměnnou: + * - private SearchEngine engine = new MySearchEngine; + * + * Třída MyDocumentTest bude pomocí frameworku junit.jupiter (v projektu PRO4 již + * zaimplementován) implementovat metodu + * @Test testFindByType(), která otestuje, zda vámi zadaný typ uvnitř této metody + * je nalezen pomocí metody engine.findByType(vasDocumentType) a metodu + * @Test testListAll, která zkontroluje, zda metoda engine.listAll(vrací správný + * počet argumentů). + * + * V obou případech použijte třídu Assertions pro kontrolu výsledků. + * + * 4. výsledek pošlete pull-requestem zpátky na github pro oznámkování. + */ +public class Zadani { + +} diff --git a/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.java b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.java new file mode 100644 index 0000000..331d56f --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.java @@ -0,0 +1,18 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.test.java; + +import cz.spsmb.ctvrtak.c_spring.a_config.main.java.SearchEngine; +import org.junit.jupiter.api.Test; + +public class Assertions { + + private SearchEngine engine = new MySearchEngine(); + @Test + public void testFindByType() { + System.out.println(engine.findByType("Milky").toString()); + } + @Test + public void testListAll() { + System.out.println(engine.listAll().toString()); + } + +} diff --git a/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.java b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.java new file mode 100644 index 0000000..ff169d4 --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.java @@ -0,0 +1,18 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.test.java; + +import cz.spsmb.ctvrtak.c_spring.a_config.main.java.SearchEngine; +import org.junit.jupiter.api.Test; + +public class MyDocumentTest { + + private SearchEngine engine = new MySearchEngine(); + @Test + public void testFindByType() { + engine.findByType("Milky"); + } + @Test + public void testListAll() { + engine.listAll(); + } + +} diff --git a/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.java b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.java new file mode 100644 index 0000000..7cd9e24 --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.java @@ -0,0 +1,39 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.test.java; + +import cz.spsmb.ctvrtak.b_anotace.A; +import cz.spsmb.ctvrtak.c_spring.a_config.main.java.Doc; +import cz.spsmb.ctvrtak.c_spring.a_config.main.java.SearchEngine; +import cz.spsmb.ctvrtak.c_spring.a_config.main.java.Type; + +import java.util.ArrayList; +import java.util.List; + +public class MySearchEngine implements SearchEngine { + + public List docs; + + @Override + public List listAll() { + storage(); + return docs; + } + + @Override + public List findByType(String typeName) { + List list = new ArrayList<>(); + for (int i = 0; i < storage().size(); i++) { + if(storage().get(i).getType().getName() == typeName) + list.add(storage().get(i)); + } + if (!list.isEmpty()) return list; + else return null; + } + + private List storage() { + List storageList = new ArrayList<>(); + storageList.add(new Doc("MILK", "Poland", new Type("Milky", "i like milk", "no fucking way"))); + storageList.add(new Doc("TACO", "Mexico", new Type("Taco", "i don't like tacos", "i guess it depends"))); + docs = storageList; + return storageList; + } +} diff --git a/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.class b/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.class new file mode 100644 index 0000000000000000000000000000000000000000..aaf7efb7c7a496be11a0f4ec560aff24777613f7 GIT binary patch literal 1548 zcmbVMU2hvj6g}gw-7HI!IyC7=pl(T9JAp3WrFGhp7(z|mxKfId)rV-ZUL~8XcdXs9 zCG!Um{{V>}f#3nEsPqN;(jSF5>vfexws_!WX6~JP&pr3fo%`yaqZa_yuw@~Gtbv@3 zJPHDH2XY{tK!$rxbN9e=wLoFb4}E=4AX~1qW?*8*fMw$i*r&|5hq3m$v{HRKookGM zeC0fj{7`S}$dlb_kulHMn8lpHVpkq|H5Iy2f9LCco?xBB+51jQVl0(ulwMsb% zER>(trw}PZ;GHC`%L3P@MVSn2;tET(<+~Q%#j=5GHm>7_z%BQCC+@}FUB}gfNXtV< z?(`zn^}=wt(^IaecVx8Jr>y%sT~Diyv;OTsb(rWtMm`J3%1)s`-YpXqfn4wJpS6iq zfqX{>u}@7+bv%LDh97!c{qC+8J(0TsHN}QQMNdyDU~Q{@t+&| zkG-Lkj&&q^k37AvI`M1)_bq&Zbpsp8d)5S&k2(6`KplEcN;U1=P3dYC4F!HWS@W@B z3i?2XoxqEi8%iDad(}zyCp4!VpA3866!VjLreE~b-xx#GWDsoo+N+xQO0X|W0~JsV z!oU7>_e-x^=;bdZHdjfQ_*%eTA2-(UPDxO#hoKkM0vX3%Y~UM#YZIlImZ5nztIE@OTaqm<&{Lwv-0 zBI09w!YElHe2UM=Y6iFP`8e(mOdv_7RxD+oThDN{ST>(q?QE{u&gGl!e4*Jc7|pg} zHhDL?F?mDH=!O>N9!gYP-juD;~^g5!oRa3f|CFM literal 0 HcmV?d00001 diff --git a/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.class b/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.class new file mode 100644 index 0000000000000000000000000000000000000000..889efcaf8919c59cfba72706838e400d90ae80fe GIT binary patch literal 670 zcmbtRT}uK%6g}fdt7c_dX8F{c8nn=BB4to7O9h4yK{Bp`jqZnxvx5Dro`Rx&KtC$F zqee)*wGVUW-gD2nch7u$zPtmdqntquaSMqol2~EL4furH9uNBVRd*m<&9G9Jfz%C# zc%|C5kYXsznj$Sd`&21Db>vuQU>TiNh7Kb-hVp! z{)gJ1jQZ~-8l;kGg^_Z_xipp(md!gfYhxegUCkE*GcQYLmNJ_nqnNBcgFVgQH98Fp zqO8-Ioi|_uIm*)5M4l>!e2>ITG?#jV-7-3H7@c*BK#>NPh+m%R73Ulj butiuBtJtOvh8@bxta+tGH-=rR#jy7Uz^ literal 0 HcmV?d00001 diff --git a/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.class b/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.class new file mode 100644 index 0000000000000000000000000000000000000000..d83041e10936e2bdeadd33528252b34c7096e537 GIT binary patch literal 1507 zcmcIkT~8B16g|^zSt(VZlp>0sfVLH=;uPt~Y^NmkANUXa z8$O8|jnDole(Q2?29YHoMl=OM!G|BU?Oz zEyQsGqb9}@7)Nptva9T7e$De_ufveCQ?xsbJ)e0Vau6^o^nLmk8dexV3X>+%2~6Rn zzzIL(Z#9WGEc%-KlTF{5iBkg#e%2-B*>1zcjKIW!AD@_x6~}29ah$_>6BiP=h*^PW z^|$#>yW`aIb+zXy`6e%`ZLj56uG_1&TXjoSrPt_kuew#oQmx(m`gUKxt<`G-?b^2V zBoUrne`D?R+C2f`2&4v8_?=TBTNa3}w{|Uo(W32In_Z`7c{{S!q$F8v)n&6RJzMYl z!l-&>v$QXY|Br2frFPV=K&;79G1z#&dk4HZ6n~QIwFd;}4}(`itqUzvHbEGnVHPY1@>G+-1O(e6J)T728|7E^7!pdoDASWZ>5KchQJb9EFhxHIPOr?KL z`~;?-c3ovVR@v^@?9ZC(wv<$M%cbL~uw(hsViP$#9i|<1r0wc66=vKoi$4t-cPOF0 zS|DC(b-lXv$kyYr_^;Eqqz?ctaM~lhEPyCjI1F)}<1Wvy;5U~02=ReG5zKSdYVbO^ z#5EBBa2Xly-XV)wqO|dSz8dEn8X?2ckfA^hR|s0*8@SSvMedgPM#$iuK7lZNm+#3h zO8H!_82t*fVvObXIV}4){^W|WP|6w0#wScf@Ey~enr;v^&5VE~y-jdUA&p6Tobp-Z z0)M#bvxqR(H7t{MlFxPApv^3IH*t%;G{-b0j8DAg7@%%bHeh>)QeB?A{0`$D3jEi_ ycuWqu7&Ec2NL7q4I9>UOGo?y&@VAe%2L;wQHZaYL=v1gyGrY`$qOMXK!Gm8;1#6oC literal 0 HcmV?d00001 diff --git a/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.class b/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.class new file mode 100644 index 0000000000000000000000000000000000000000..fd82f8023ea981ac609e8547a7944e535b4db1e0 GIT binary patch literal 1510 zcmcIkO>Y}T7=FgP>vdd19VavmA88A;*h#5r`DlrQ+q4ZRl1Wh;JhVdt5d_ha7Yd1v6M~fxr;eyox3M;z3{F#*SU%3+O-}ZPGK04TeEZiE9b!pfZaUXE zhN;dT(eP$O64GRG2Jboz-*d{{n^tb(!N~J3mG{E(0S`;G9$4KiuRH2B-M3j>aQ$6o z&Pgdp?Uf8Jvf!<6YwLtt(Vh}GS<^;s4SFpV@5ok{JB3=*mfePowOda%efyp63*4>! zKMkx11W5;9QgPBg5;|JcX#cRV`#T$qo~i4Ok#-Q1z}dBp)mN`Twdg!cWB0}Ffw8)$ z8oIAZa^0B7N~Pzj~Q~ECt;*z@^ILF7A;?oB_umGeve#ljs zD2T!GGl*X}N#PPlX9i|y26AHue1ywfeeYf`lepmOBsjJFGgsbJWNs=lg)8`&_D}eY zbGe;Qx%!M>3RiKB=uZ5cID=JGIA?xwF)0-IDWCowVbk*u*xaTcBoL$%NM{lV^I?LS z{0WB#c}6sIXXX28FlAmUq6U?`RsGc!91ADRK6rxk`hMQ`#f3gg?j?wB%l|D03yWye1<`| R*Fhf!oG%eEE^yh==nqF2R8If^ literal 0 HcmV?d00001 diff --git a/target/classes/cz/spsmb/ctvrtak/b_anotace/AUvod.class b/target/classes/cz/spsmb/ctvrtak/b_anotace/AUvod.class new file mode 100644 index 0000000000000000000000000000000000000000..b61f9f1d7f52c7025decb43dd51759c1024b9619 GIT binary patch literal 751 zcmah{%T60H6g?gSVG_zC5DI-DKp+Jcj8vA5kRl3Fr2tZSY`UmC69W#3jb@x#@K;?S zvFHczQHbLq66z+gH1}nnbI?D7(-4ag?|`b@DEX|43tSaP>I6WDBzBmPcir!uPg{A*yG?yH|B*O?|&%XkG&TSKPC zD5ewJ<>^8$`6_*;C(7B56xbexyI^CROXo#&(!s5OXbDu`@!tf(>r~z4$|U^N^-*L$ zlp#-WenxY8^dHSWMV;G0ny6##udGts>7JhqHc;lk{F;RDBclzOMfAc~cON1CG6+zi z_1nM_sym~5 literal 0 HcmV?d00001 diff --git a/target/classes/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.class b/target/classes/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.class new file mode 100644 index 0000000000000000000000000000000000000000..eee1abb912f174280a05172a38aef19d6393ed8d GIT binary patch literal 963 zcmaJ=&rcIU6#k}LX{jqewtyliMN!)-EHU0nOsbKjNh?H5FC5IYjCIO(rrFN+(0|1f ze}IV|h{l7Ldh(AlzUeknP&mw+oiFdb?|tvR{q_6%4*)yZ&L9CNg`|sXm|~b~^FH?j zu3G+Hqb-_-VQNPzX`VAU`9eK|G^SI?xVR3NVgAg$qKs&XkRjFQK_vFxGc4sRh3Y>Z zrD@DyHibDC^Y9p+HV1yM+v_y^rs;=P}6Pl9_cAj6S>?bdw5u3NWRoZf?>8Q zm3SR>8X|nlDYY$8H+fL!p|tNYm^2?GaXq_=>ymyEZ`$ZsEJ@5yPG#HznsY}OeZ;9O z8e5%OEa^~{iJ;4{aZ&$14><*h@LVG@2RaIyVpm!ftCv)>Wmf|0G@JzOphJiDfGq5! zz;K7Yrs%#q!q$+xfI0N0WhJ{#9So}h80{6(yjA%S0 zk%fyz+$YS9!?1w|^kR63N8^;6bla4UxBQu|IECc{mM21;zoB^)h`?5}OI}t{(p#yW t(c7O4q{|^qmO2;vjN{20MLZrwGCZLkB+m6>4TM4~*x1;B0V7r_q^c4N5e!9Hk?mU4CACrFX5g=wkQn#?J_>Oz zj4a$q@9w>m?(Thly?+20V^knPFGo5+hCX4ml${i{bdTarEsYL@{@6Mjt_Z#3lPbp+ z;atCn_PJdtp+naM`6SeXbUsLJ#B}o0RAv_DH_k46=L{j8`ZiA!qL~h?CtjZZi`b4rHfq bpjQ?W6pV2U9AJlWu<0|dyUYlCj0uL{fKXFq literal 0 HcmV?d00001 diff --git a/target/classes/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.class b/target/classes/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.class new file mode 100644 index 0000000000000000000000000000000000000000..9cfc766f9aa34ca98c9537428052543ebac77f87 GIT binary patch literal 315 zcma)%!A=4(6h-eFW*8Y!&_6IC5nR|0khqbs8g-#zYhG(3#bL(G6c+xKD-srd03T(1 zB`jRpCinH+m)z#=ezxBL#^`5=&`J?^k)TcJFL=$W;POp9>V-9)&>p+e`CCG3IGUw6 zB3znJ)qFHdt&CsSp5K*z;j;2O&U$ic3p9?-I{jGgKxh3 zZsM=dk_gdgNbt!YWxO+8Lk-5ZNpH{HbI;s4dw%}<@*O}1n<@efW7eBw<8`B2PFmhU z-7{Y$%g;===9!kA+_2pU7=j!jgc$-m1%~nb{|C}yLgR>t3FY*|uD};KxKuDC?B(c_ zkAJ+A_##J4;+@mCf_{l(piM6bc$s5J!tI=ZBOF&S%Aigcv-!t4gJI%Hx21H9;hKt3 zj&V#dgse)?0wD`}7-@&lKX%Ano&02*|D;V{^xt zJOLB@z+e0fb$FYF2UwNQDKx|qCoV#vFQCrNj~*fZNj~m8?rdDeL$Ny6BqtlyMQZ#- zwh*K)$wk#~U?rsm#V7?^P>oWkMJ|@YE%X>AwS}lr(pu;@N>OSJ8t3n);SsXF?0a9< z`bwg)8_E%G9zu~|At-?=K{6zPF2Sv^1U(WgsuDycSkffum*94^%^N&M>JY=?=53=V kq0#>!dg$eh(2ZxIB1OF{S-%Y(Psy-=@4`AZh#NreH)SmTBme*a literal 0 HcmV?d00001 diff --git a/target/classes/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.class b/target/classes/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.class new file mode 100644 index 0000000000000000000000000000000000000000..51d8efb2526053257e7c568d1ac68e944a733af2 GIT binary patch literal 6896 zcmbtY33yc175?umdCBBK!h{6I5EcPV2+7DINJ3FaK!ZtG0>R*dFEcMNWHN7R?z!ju z=RfD%`yP4rG;M z5Xw=ZA*7=cxbMBW2k}%xqo1Ig=Pp8u6{8DLXM@u62f`In_F*AuLdlt^VTOj8IwH70plX~i z0#oRBL0n+D*A8V{kr_r_bF{FESj-Zb>du*tOO>d>Y#nnjS0IowMoeN{1g7g`2p3|$ zh6Oqn;v#{$R%Ul}?AW zx+9VZb!gPlghc`&dfj8%d#pGWG&D9{>sgR7hmxdG)R`ybiv?;FZliW08C{#n7zeu( zSv!Pg_(OT2pQ$K{M}J_3&Ia`jpr>(Iev^jPlF zv?Sh8hT*!&$_z(iR?0RH*ilc|6(=?u_MW~NM=9N5q~eLVVVfP+NZLx7DSLCq+Mi%n zh0uvBWtv_^>l=4A^=sHDu&VS%88d1hOqsjo+J$rCb{ zrwnl?HtE=mEvyTKwJQ}%j>g^9ireS4cVWkNiEN+11(WBw+;h8*e(VsKF_cKfC*nbl z&G(vHoZgC6eWu-Bi2>}?aIKE(a6L1#Korgjl*?o=Y>UOJE|*AZZI?Sv1-o#g21Can zVgliUf}Dtew#Uf!GNg(~5&|nrfj4Lxscdw}h|#cvk}pGv z-O+U%>@*2RLZ+;SVSz1TxCH~MD0SW_kTVnjy@mO!PG!UmaV$j~-*m)ap_<#<&f z6q7@(YL^vZpN@PxcQdes#46HFqnzr+BIi1(3@D+|t->Yk6Szmm zTk$s5b|alm9u$~U+Q1F2rOLi{=y)gI#k3xg+_}our>PK5;~@>7k>|M23M?y? zc&gSJ`M&9Cq1&BA?Dcw8d`R)0m?q|ANu}+~pAIX|BS}?vB4zfDjtrWaZN^}dBjIj~ zWwhVOB;>n07_j#wNSbBc=QzKXE<4;R;vS>>6WIh+y4cB}3$&a|V-cE^r>-zh$9eD_ z0+27V7RcyteR>+fv04RgOYh0OB#m`2~6_{Ij9mW&Si74r#;LF zM<*Sr_fmF()@s)fGwza>bCky2(NovSN`o^ATa9>#LTohlxz4Q%c!aq>L#X~?X~O;)@Ul87ZaGJn)Jlu{WfCH zO=@#7=u_v=4(Ieq9F^z!4yw9emB(%laJ6rc=jc@>j{)a#N}+=Cw0m$B*j7@_|92dg zJ4i!#GGeT~_RD(Wy+FxR4@E95cCkccJh5^cpN!Q;&pN7JUDB8HfkY|`kB>=)`CTzu z=;wI>Z_-q{>~#{fL0RA#@)m9G5tJu?I$U75B9I(v9`8$mWaAP<8oO|EX{Aw8Udq)c zjgi5)u^{JL!Sn^o#@)r$x}rOVi;nzh#1lb=8QAnir zTf=6wTLH=yhI<#_37vJV@b;+JLU)m~!BxCKCe7@EZp#`TO?x|$3ylZIqJ^@Hdd1Iw z(%JIdYrQdYHFp@vWFN0#?bTR8RLVm*EGl$7jc2OmzneKWMUG9?@h?18ji)#;O%8;0 z{8PP6mv6N?{(&c}@g&d2U8$6NGB&fCh>&~}pe==xCh7%dpIemO%7GN~aF~|>`ClcN zZ7AdK=lB-oU%|h@MaLoT=YtQQ=dYXwYVk0Cbw>bSz!&)@a5-mvYH_oA=h*m#5zj*5 zF8mUO<=&6*|2bJ|5%_Z6j7c>$l+YybC>Q#r3F3PG4N>!LC!mF=9Aiyw4%Zw*?P=8X zgzFcNp+VpT<~1L~#l5G{Ja8N>ZGo1yU?lk9iZcHStyZfoyBC*4g0~1T-?gV zZ55GJJM4}K-@U6fUKF>u3 zztYrTK4$Yn&3s&h#kd&j(TFYl2Gx&6F!?@=7VJkWZe=Va+*d*4{B(SUNL5gJF20J# z_{oqyx=2>=QusA|odDKgAHG33AGI5J98VC9#kdCF#J6b4x4EW{bB_FXDDTXj;oNsQ zHxK@^Sc!5Chc(n`sL}8}4NLhe82y%~NR#hVEWm|7fDE5x#gF(`;Kw-*h$QDVj@@+% zodf>k*wEd43S9%?n&Y_o71tl`(9%drDj5W;o5@^|vOzn+)n4Y(6ms*tRqw+6xf34Y3_ z4lKdX@N=R=uk#_f9lyXYiA)1S@+TslfmzO%jSs9Yq zG9)bss*rSQ7*O%p1w4ZdPgA-$3ct@q0VlcM&-I<*!zXZCx1{?Cy!<3y4UFOSKF+^I zKD}M?^xiSN-$%fg_5>J?9FG?lVdqygzEIJwo4fQPj7^wDV$MS!4ct!N^b?643Lohk z_ja);Bcgv$^lZTlMMYnpiq4#*qBD19f=_?U`6RaRsf>E>IEAAFfd}9l@P`lg9mhwU z6u-ZR)_+pawG$Iv>-ErLO@S7wHjFv+Q%gTJacNsH5DDgSc_0!j0n9p7)3EFK4gUsa z>MqR0jVc2h5hK-10x*P)*n=KYU@N~^-M}o5VFYPd%-u9Uo$SjKiw?TLO~V2F34bOy zGdcgbBGGa}EwkBAJuC4Sjs>_rg1>Sss9;^h5l8-S1k;h1baLeXo|ivEc@KT6L$U*L zFWCjwa-}TzRf}@PQx(1YIOOz$sVc(5%%UWw(ivH(oW4+{N)f1z?X9FbSx!r;GpKHm z>Wm_Fvf4>?Y@g3f-4?3bN_AUGs$++C)pdKEJ%LX@3@va30sm3DQt%*;hS;=FTnV>Lg_yWTu+0Wg=aY-qjMI1Q6@AIQcsma7gg?4b^fVF)QK6C4?&2T K;sP-Xk^cfckACC; literal 0 HcmV?d00001 diff --git a/target/classes/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.class b/target/classes/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.class new file mode 100644 index 0000000000000000000000000000000000000000..c3b7bbd86245a8dc80bc6699db89226dfe9b6ad9 GIT binary patch literal 169 zcmX^0Z`VEs1_m1jPId++Mh3OyD*fVu;@l+t; iW#*&;4M8$h52RI%k%5tc8Hibd&SC)4>_C!o zu=1mfcM=r}qs5$=IXU;vxo6%#US0v5U@Hqt;J|xuqH#3rIG#>IEeB5LMyipP9yu;W zdXz|=MM|L1mx*)&sd`Sc(8PWQ6SeE z#i2)Me!ws0zXv}ujs?nBvC{sKuKmdG1T?iA3GB>FHIslV!yak&l}=<3bI<+Xb@hOT zq_lfKCKhKd>h5{7b|^Rkn^&4Y%Hr&^m@}d9&5n>`VgZX^#C98LLLN&7mJJjP6b-Dv W!m4S364rPxaLqcejWz^f6Xj3$po^6N literal 0 HcmV?d00001 diff --git a/target/classes/cz/spsmb/ctvrtak/b_anotace/package-info.class b/target/classes/cz/spsmb/ctvrtak/b_anotace/package-info.class new file mode 100644 index 0000000000000000000000000000000000000000..d3f94a1d00c8253b760c8080105c9654795edbe2 GIT binary patch literal 217 zcmX^0Z`VEs1_m1jPId++Mh5ldD*fVu;@l+ti!1i_a9ADkhYO#A@BL_d(bQlYGCm-Rw|#{c2Z z&_rUw2Y-M+%6M*D*xZWAO#IOHp3`%m^PK0Ldw>4A_yJ%YPm}0DL_t(V3~`3^F+b&+ z#qC4wb>-O51w(w@v`w+e5Xt5DdXYe{f~1N*s0>T`2hFX!wTh;T(}v(xP2YFx4U@L> zeciF&n}=GBo3`e`K6iA6sLg8zL#Eu!v?Jt>qQt(TqF(|hEJx?UbZqIosUm{`+A7ZK zv~{K2Rn}eFRLoGdLn?+b!Z1?fRiotCl;Djij%eiyZVQ*8n(Jg0;^{tpz7vJv?SIR* zM_QGf1JbI$Y}&^5Nv&cuc6r6}gePUKJ>D>-9XO-n$fWw0yHl3>S!7TS4YBR@bTAiM zr{Z1)424vjC$fD6Q4ShT7R5I$2`^j7uuAaVOHTv|&qr9x{R4m`m=KOXqzuU&=cJ(< zTc#85J%2|+aJe55{u9jEXm1xz>sauylJ00RYUVp{bAhV zx^Nn244+$N3Icu57u-Iu3^!YLoa#xv*f~`#o#xcu{8Y;9oxQR0@h zV+x~~zzV}O)%;N&;*D80J3n=KP<=~Kr#9Fp2KA+F8;z31UDt3GtTD`V6dzWTg2xP# ze-EWQ$rk{3>2~O$qa6W_4OCju$Om7#GRRJlCx%gakCA0jbdh3{a6xpOFm`E#TS z3+G6GC4UcY(R-M70KF8Mq<0@~5aIw*xJ}-IzaQh6Ad8T^yv$q4%#zKZyskV>leiOP z*61svVuf!|zR^k#swesZb*KF&m~xOY3|^vP5L& z8X~eal1T1Kk#(tnw|aGJ(nwz(~KyvMAScsl&zxwUT;P7M@%t)lBDZL77}Da&oCQ zN~T76{e15-awfu|z**C_itP{crO`nkvQ&l}YX#1Smq|0P0$G`GI~M4slsOeDZv-aa z4CCZaJa@T{uX$;2LGI~xJKYw%^IsHyk>!3Q76uw7y4cDLCbh-myC zehf_{COr57{7}X-y9H{y7&XoAoH={u%y0hZOn>}5`3_(O57LMrsvxE!js!z)pC59~ z;`XlgYG>cj1w&%Rv`w+f5G_}>Qb;1DAg$sORE8z}z2A0*SFC8i4oiJ?A zbnHBl7gP*mgkiMJTSncnbuM0;Vvj6Oa9el`FUo@({EeqF7{u`Kf0J#|N$O6M&YNwR zwy}QD-Z9)wzGL|cI6AksxNFLJ*BKLgCebf9{#n@?gR*Ogbzj{=IrJQgcN#Dpa-s^+ z$`nsXda@`suvGFrJyoAUr4K#Rq;P`zF{C$~16McJOnJPNEcc=;GPTuX#}S@zdFQ1e z_ME1dO`w{_9Oe})$Wksc6wmv?v=5z@p#^D!>aKBJIPMX{r(W=GV370~x0{yX6&sGz zI_T5}>)7M@ZJ`7W34hZQA6$l7uc+M=b#7T3rZ8$r+-4}rTpwhIKPs`({Iu-iz&dMR zIsHf~KDTYdty|pl3{Sx_!|Z?nVdqkCk74r9p>$~j5paWUP=xMF6inV&vZxcgBV8++ zC&?4XD7~-J%%bQRjfLtruAP)0Pr$B#1hLOLXBF2^9vC=?57N1-TgxlIaH-Cyh($ literal 0 HcmV?d00001 diff --git a/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.class b/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.class new file mode 100644 index 0000000000000000000000000000000000000000..6f4d53f754dba759b04c8d064aba0e06d9997f8a GIT binary patch literal 333 zcmbVHJ5Iwu5Pjp=F*t!l+yK!41zR90qBKZU78IZqG|_mogbnsOT5nS1R#Zq79DqY1 z#)cCxBfXjTM)Ujn{`dqi!8k*NUW#~#1bxDI#amV-yQR7>Rz?Rxe`1{tQ$p|bY?fk= zaH)5ySvOUoblCd9uS(CGwYSp5b6vYc7&c zq?-5x{87fU+uBys3-o5b=Q;0r=gg0vU%vxb!%Gt}#0?}YOkk2Bb1Y5;cZA#Euj|Ls z)(n$t%2j%uA)YVP3?v!K_In<*f@YoD`qbCrgxmW;%U5(s?AxAus2W_$K=TN;+o?+7 z+eh1OL%Gs~f%p_sunb(VFpV_B>Ob)|f{b5116KL6_%)K@lk*h@cD38CPTy<6ZQZ&m+%ri{vD(9q=!U8TExME=uR~btG zEs4QARPMoMXRp(e49odmX9GG4Wtb?NVkxDt~HQN=u)Mmg0NFAXX}5h2BR=npLmu z+j2*R^3%hhE1{8CqKc2vk7LwQ&C@7OWBPK`a+=9L?erC(s?|_6Y3eB(q1fLZTDI89|`vfW_GTNOEGkDjo}NH|3;=TN3bDs szK?tsg=2Ug;a3OvEeaEc&h_zK6dA!+#=_I|r!ph(+*tSv!o^Vf1ykA|E&u=k literal 0 HcmV?d00001 diff --git a/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.class b/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.class new file mode 100644 index 0000000000000000000000000000000000000000..09b48004cf4b9121dfcd2073cecb05b32a4a3abc GIT binary patch literal 966 zcmbV~TW`}a6vzK=yQWLiwRGGD<36D41Ad+|CXLIUQjlm>#M9(vUgs`#qQse0z7-N^ z8c2KqJ{01(n^?qn7%0+-eSG{o7yp0!{Q4chCZ4(|q3odIVF6W!)Z$}du z8iwko(#mWxlsoG~2Q>yi{K&H;n~r#Bj#48IdAOS;siI3_H;nbZ8gnBv!{@NxtS?0x z9=z6LrKJl8!57%*nVdKA{4DPGsH`^JvTUq5x_MnybOnelD%6%V&? zo56|5vmHeY?aqZjhRVx$kFd>vrurtIj$}Fzqli51APz+|6sfZNGiSvdsEpzHWoA@- zyW*^Uh9!HpQ|M~tU9OFq%Av{>W!u&|Ho~Y_Q?k_{PRD$blYGb~%E*+9L~;9W#Hw4C z?Rws$+mG`!lsn3{u-uy!6F;+q!vj)HiB!wTl5S{KrZvfy>?-ZH=6j&kJqGK3gY)4S zi(lY=qO%h2khNk5#aB?nU0Qi`lj3m?_vz0lLzN;d%cs9RYji)uZMRO)F5&&3AQCZs s=b*+J=pkLSMLn8B*M37c$Y-H-3q8S2b`ja68e0Wq{jbQ!1S#RkFLL(jDgXcg literal 0 HcmV?d00001 diff --git a/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.class b/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.class new file mode 100644 index 0000000000000000000000000000000000000000..b45f3caf8daed833dba8d41c76c1d0c8a7caf30f GIT binary patch literal 2160 zcmbVNT~i!I6g|BknPFH6nFL6p;3gpg3$lqOCUFVMr$Kfhx#;4nLEChX2^?aW3u z&;AM@wMt)Ol|ms^mM^~e7yKty`Ehz?B1>YbAP+m+ef#$9bI!ee`}edq#%;&;Cj{a{!z&t8v?nHL>qb-V)^G~(c66ghL2n9YaZaG~ zz)!j`s%Jmu*`zfuU0+GzRrGOQwz$|mG#^1~5hJJIHGwNfAYC*Rc_NOD_F!)3g#U@(Ot3=3R6c7zbZqERJ;Gf!m?I2L`GxSZ5tB!yAD zK`o3@Noo-a->Ss$y7bGYa0OQx()MPnHNP3Cxvt_Zs#}=PFQ~ZA0=nyRXGz5kfn>q1 zY&TWh5@@&66?@xCS7}j^V}cwvz11+c2_pT4(UeSY%d%wY-D*V;;cUV5LW?Zee!M56 zObV}8(v!qHK_R}S+W;rEKL4mA~h2-$vYAf1h$M73dozB#x?=_BCYYbZv|D1dlX+g= z#YT10sxKRx6*?7ErN$C72eg!N=0DqX|ev-BVLk+ zwq-k|sb+W!2mYrfp6f*d!sd@DRDE8;@bc)-7a%o~a0Pk}E5bdIDjh|peY;@PqWS$J z9RHFu+oSFpHao58HtMD|XUl}0KHQ1NWM{+$HryBl^87K&=;C*gk3-}vp|kv+!x+wEisL(c zGK%O6z-H*HVFGJdCn!RSV9U|R_=K=k6!0l^jo~w{ONm0u5-l6FbRzK=GzHz_#-B)P zk@}x=m5*&i_}fUNLPR(}vXA~X{Z0MaJ}$56Z|gVpcXlzpi+4j-;qsI|6D-f^ck~Zh zmopsZH*P G!TcA?xEj#_ literal 0 HcmV?d00001