From b088593c50d921889f013d0771e72b63b3b5ac8c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vojt=C4=9Bch=20V=C3=ADt?= <90755402+vojtechos@users.noreply.github.com> Date: Wed, 14 Sep 2022 11:02:00 +0200 Subject: [PATCH 1/2] 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 | 38 +++ .../a_config/main/java/SearchEngine.java | 10 + .../c_spring/a_config/main/java/Type.java | 38 +++ .../c_spring/a_config/main/java/Zadani.java | 76 +++--- .../a_config/test/java/Assertions.java | 10 + .../a_config/test/java/MyDocumentTest.java | 20 ++ .../a_config/test/java/MySearchEngine.java | 31 +++ 23 files changed, 667 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 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..5766f46 --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.java @@ -0,0 +1,38 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.main.java; + +public class Doc { + + String name; + String location; + 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; + } +} 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..01f7439 --- /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(); + +} 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..abc0a5f --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.java @@ -0,0 +1,38 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.main.java; + +public class Type { + + String name; + String desc; + 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; + } +} 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..65f7b8a 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,42 @@ -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 { + +/** + * + * Autor: Vojtěch Vít + * cs snad to bude tak na 3 + * + */ + +} 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..2b9d0f2 --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.java @@ -0,0 +1,10 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.test.java; + +import org.junit.jupiter.api.Test; + + +public class Assertions extends MyDocumentTest { + + + +} 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..e4d87a5 --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.java @@ -0,0 +1,20 @@ +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 + void testFindByType(){ + engine.findByType(); + } + + @Test + 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..82653ec --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.java @@ -0,0 +1,31 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.test.java; + +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 { + + + @Override + public List listAll() { + return storage(); + } + + @Override + public List findByType() { + return null; + } + + private List storage(){ + + List strorageList = new ArrayList<>(); + strorageList.add(new Doc("", "", new Type("", "", ""))); + strorageList.add(new Doc("", "", new Type("", "", ""))); + + return strorageList; + } +} From aa398147f13077974ef37d056367448a107ce909 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vojt=C4=9Bch=20V=C3=ADt?= <90755402+vojtechos@users.noreply.github.com> Date: Wed, 14 Sep 2022 11:03:25 +0200 Subject: [PATCH 2/2] Add files via upload