From 4c9ba263611e3fea75272bd97fe3132c807eb97e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?CHrIsT=C3=ADK=20AbRah=C3=A1=C3=A1=C3=A1M=C5=AF?= <90842809+Chr1st1ancz@users.noreply.github.com> Date: Wed, 14 Sep 2022 11:04:09 +0200 Subject: [PATCH 1/3] gfgfgf gfgfgf --- PRO4/README.md | 1 + PRO4/pom.xml | 38 ++++++ .../AUvod.java | 29 +++++ .../BGenerikaAPole.java | 28 +++++ ...omennyPocetArgumentuAParametrickeTypy.java | 27 +++++ .../DVytvoreniPoleSGenerickymiInstancemi.java | 27 +++++ .../java/cz/spsmb/ctvrtak/b_anotace/A.java | 10 ++ .../cz/spsmb/ctvrtak/b_anotace/AUvod.java | 42 +++++++ .../b_anotace/BMoznostiPouzitiAnotace.java | 64 ++++++++++ .../b_anotace/CAnotaceVeStdKnihovne.java | 21 ++++ .../spsmb/ctvrtak/b_anotace/DMetaanotace.java | 37 ++++++ .../java/cz/spsmb/ctvrtak/b_anotace/Den.java | 11 ++ .../b_anotace/EPrikladRuntimeAnotace.java | 114 ++++++++++++++++++ .../spsmb/ctvrtak/b_anotace/MojeAnotace.java | 4 + .../ctvrtak/b_anotace/SampleAnnotation.java | 14 +++ .../cz/spsmb/ctvrtak/b_anotace/Testovat.java | 11 ++ .../spsmb/ctvrtak/b_anotace/package-info.java | 3 + .../c_spring/a_config/main/java/Doc.java | 36 ++++++ .../a_config/main/java/SearchEngine.java | 8 ++ .../c_spring/a_config/main/java/Type.java | 35 ++++++ .../c_spring/a_config/main/java/Zadani.java | 44 +++++++ .../a_config/test/java/Assertions.java | 12 ++ .../a_config/test/java/MyDocumentTest.java | 23 ++++ .../a_config/test/java/MySearchEngine.java | 35 ++++++ .../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 -> 1271 bytes .../a_config/main/java/SearchEngine.class | Bin 0 -> 441 bytes .../c_spring/a_config/main/java/Type.class | Bin 0 -> 1077 bytes .../c_spring/a_config/main/java/Zadani.class | Bin 0 -> 333 bytes .../a_config/test/java/Assertions.class | Bin 0 -> 594 bytes .../a_config/test/java/MyDocumentTest.class | Bin 0 -> 1109 bytes .../a_config/test/java/MySearchEngine.class | Bin 0 -> 2238 bytes 46 files changed, 674 insertions(+) create mode 100644 PRO4/README.md create mode 100644 PRO4/pom.xml create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/A.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/AUvod.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/CAnotaceVeStdKnihovne.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Den.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/SampleAnnotation.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Testovat.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/package-info.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.java create mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.java create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/A.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/AUvod.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/CAnotaceVeStdKnihovne.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/Den.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/SampleAnnotation.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/Testovat.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/package-info.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.class create mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.class diff --git a/PRO4/README.md b/PRO4/README.md new file mode 100644 index 0000000..6729ae8 --- /dev/null +++ b/PRO4/README.md @@ -0,0 +1 @@ +# PRO4 \ No newline at end of file diff --git a/PRO4/pom.xml b/PRO4/pom.xml new file mode 100644 index 0000000..f7c36aa --- /dev/null +++ b/PRO4/pom.xml @@ -0,0 +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 + + + \ No newline at end of file diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.java new file mode 100644 index 0000000..20449cd --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.java @@ -0,0 +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); + } +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.java new file mode 100644 index 0000000..1498729 --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.java @@ -0,0 +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(); + } +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.java new file mode 100644 index 0000000..a7cc236 --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.java @@ -0,0 +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()); + } +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.java new file mode 100644 index 0000000..44194f5 --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.java @@ -0,0 +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"; + } + +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/A.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/A.java new file mode 100644 index 0000000..7222ba8 --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/A.java @@ -0,0 +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 { +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/AUvod.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/AUvod.java new file mode 100644 index 0000000..6cc1588 --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/AUvod.java @@ -0,0 +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(){} + +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.java new file mode 100644 index 0000000..9767e67 --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.java @@ -0,0 +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; + + +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/CAnotaceVeStdKnihovne.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/CAnotaceVeStdKnihovne.java new file mode 100644 index 0000000..b7a4c7f --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/CAnotaceVeStdKnihovne.java @@ -0,0 +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 { + +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.java new file mode 100644 index 0000000..0a64f73 --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.java @@ -0,0 +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 { +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Den.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Den.java new file mode 100644 index 0000000..81d836f --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Den.java @@ -0,0 +1,11 @@ +package cz.spsmb.ctvrtak.b_anotace; + +public enum Den { + PO, + ÚT, + ST, + ČT, + PÁ, + SO, + NE +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.java new file mode 100644 index 0000000..48b63d9 --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.java @@ -0,0 +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)); + } +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.java new file mode 100644 index 0000000..3f21b3a --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.java @@ -0,0 +1,4 @@ +package cz.spsmb.ctvrtak.b_anotace; +//Značkovací anotace, nic neobsahuje +public @interface MojeAnotace { +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/SampleAnnotation.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/SampleAnnotation.java new file mode 100644 index 0000000..ef5b469 --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/SampleAnnotation.java @@ -0,0 +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(); +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Testovat.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Testovat.java new file mode 100644 index 0000000..5bcafd6 --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Testovat.java @@ -0,0 +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Á}; +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/package-info.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/package-info.java new file mode 100644 index 0000000..52e1c9b --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/package-info.java @@ -0,0 +1,3 @@ +// Anotace balíčku: +@MojeAnotace +package cz.spsmb.ctvrtak.b_anotace; \ No newline at end of file diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.java new file mode 100644 index 0000000..5baf9df --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.java @@ -0,0 +1,36 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.main.java; + +public class Doc { + Type type; + String name, location; + + public Doc(Type type, String name, String location) { + this.type = type; + this.name = name; + this.location = location; + } + + public Type getType() { + return type; + } + + public void setType(Type type) { + 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; + } +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.java new file mode 100644 index 0000000..aecdc2a --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.java @@ -0,0 +1,8 @@ +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/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.java new file mode 100644 index 0000000..92d5d04 --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.java @@ -0,0 +1,35 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.main.java; + +public class Type { + String name, desc, 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/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.java new file mode 100644 index 0000000..293dcfe --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.java @@ -0,0 +1,44 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.main.java; +/*** + * Autor: Christian + * 1. vytvořím storage() a co pak? + * 2. listAll() a findByType bude vracet null, jaký je postup předělání těchto rozhraní? + * 3. Jakou třídu Assertions? První zmínka je až u kontroly + * 4. private SearchEngine engine = new MySearchEngine; chybí závorky u MySearchEngine + */ + + + + +/*** + * 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/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.java new file mode 100644 index 0000000..c937e2b --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.java @@ -0,0 +1,12 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.test.java; + +import org.junit.jupiter.api.Test; + +public class Assertions extends MyDocumentTest { + @Test + public void assertus(){ + + testFindByType(); + testListAll(); + } +} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.java new file mode 100644 index 0000000..32dbb76 --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.java @@ -0,0 +1,23 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.test.java; + +import cz.spsmb.ctvrtak.c_spring.a_config.main.java.SearchEngine; +import cz.spsmb.ctvrtak.c_spring.a_config.main.java.Type; +import org.junit.jupiter.api.Test; + +public class MyDocumentTest { + private SearchEngine engine = new MySearchEngine(); +//není celé, vysvětlení v Zadání + @Test + public void testFindByType() { + System.out.println( + engine.findByType("ahoj") + + ); + } + + @Test + public void testListAll(){ + engine.listAll(); + } + +} \ No newline at end of file diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.java new file mode 100644 index 0000000..c9c9477 --- /dev/null +++ b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.java @@ -0,0 +1,35 @@ +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(String typeName) { + List listus = new ArrayList<>(); + for (int i = 0; i < storage().size(); i++) { + if (storage().get(i).getType().getName() == typeName) + listus.add(storage().get(i)); + } + return listus; + } + private List storage(){ + List docList = new ArrayList<>(); + Type typea = new Type("ahoj","mental breakdown", "stembus"); + Type typeb = new Type("ahoj2", "cotojeproctoje", "bambus"); + Doc doca = new Doc(typea, "ahoj","buruh"); + Doc docb = new Doc(typeb,"bruh", "idk"); + docList.add(doca); + docList.add(docb); + return docList; + } +} diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.class b/PRO4/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/PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.class b/PRO4/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/PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.class b/PRO4/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/PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.class b/PRO4/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/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/AUvod.class b/PRO4/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/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.class b/PRO4/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/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.class b/PRO4/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/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.class b/PRO4/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/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.class b/PRO4/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/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/package-info.class b/PRO4/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+tD#y5~OJYa1TM3>D zBqAghJOB@cICCAEDoGcqEZ^%po;mY*X8h;xuipT6@uY|hvIcS{7LZq1K65S{yXOR5 z`(x+Ka}$O9t{?cxoC722?-LG~$i2EJeO)jFu`E0w#@gVXU?i{;e zaN>9EzT*eBmVF<(3c2LVz*BhLnk)2>K|7MXVqyu)lnI0c z2gK^_C>UKYkzy#kX*A~(&^4q&{9obiO-dr4D-ip-{xw2Obs)`=I;=IO--|?v60OVT zl*lwb6%WGm$n`$>Qo#bh`-P;yL$*J|sm=1{^l^pEg5KF}?gkXcxW;vjryjj?+-ufP zDC_AEhV^WSvh{q3mG87?Q0H1_ghb|KvUycdMX>kiEy8(?JO-6N6{r$-RV&m} zuS>Z62u@)W_eWY+LCTXL^_d_KSmzlayKN`x+2wjetDTJ$U>NO2YA( literal 0 HcmV?d00001 diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.class b/PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.class new file mode 100644 index 0000000000000000000000000000000000000000..8cfe74f5240ba51f80d0abe44566bd3b5e2b588d GIT binary patch literal 441 zcmbV}!A=4(5QhJvu!3mBXYha*dnQXvG|Fic56i(DDYdKvrMu~NN$}A;_y9hXadt_F zi5}G3{4;-MzW#mxczpvf#%Y9>z(~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%^!;CDT`!6L)5sIuDna1lF)V>Fm?aS##bGI9GJYTG=L8G16|9Fp(B` zf~OQ=>|M%cVcQ^2LHR!i774dz6qd8Bzi{>hPGBP!q%sTA$OU*?WsczU4FW6Z^d{ZwBVU$~E?lx6n{392o zC`Wm%xty`LE&mha@M0UnRsN4%*M#h$-gs?pZM$Ibd%{I~4vvw^%dL^PJT15{Om!Sc d&fY<9B1Fgp+cI#Df#9&q6Nv}H2#10ZMn8AG9>Vzl@~gZg{9UXw_N1GPXOLG32hov1F+GO3T}1K9X@?jAoQ+_+cPs0}(41 zuaY_YsEB^<|Ff|+LrJ7qG@;#)M#{>Vi%4;| zG@?}Q!z2!5Pq|j>>&Z{uj&VfeX6UX!%G@Q9)+yq2GCK3EH?Wt~-XwK4C9y^7t==2h wrifvO+)Vm&nD8nL)IC{!7aM_3slArXqS9fW-o>AlV))64ew=*VgLXD literal 0 HcmV?d00001 diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.class b/PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.class new file mode 100644 index 0000000000000000000000000000000000000000..cf1b7980e2fd863e7efb137a43bed725904f6696 GIT binary patch literal 1109 zcmbW0TTj$L7>3{3T`Aiw2Meeu9#GU>RK~*3OZ@NTkX_x%p@^p7UmsX#|?(56Ra{=rcgRm z6ibmgthU!^n+R??xP{wvHYDs?7&5r^ztkw=r|}MXn`ly9Uu01yNVY^Lq#d^z`yy_nA#i^g_le&F;9J4qIbh+q|T*TndbCx zXspv}HD3dhiw9tf-(bBxK=m{15A?5u294&qfu2AGqgbSwLpSL>?%*zc8SW9Ql(ROD zSnfx{eS+8wE{2>+? X-W;QcMyJW}OaWOt5&3{1B|Q8ETX7C> literal 0 HcmV?d00001 diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.class b/PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.class new file mode 100644 index 0000000000000000000000000000000000000000..2db51aa1a5c0615602e7c7ac835e46eaac86942c GIT binary patch literal 2238 zcmbVNTUQfT6#h;wW*md!AW%>$P}&kef~d6`jG#!14cImjg#Gc!u!Wi7%(GUx2GZ{N4~KIe~rfB6-_45W?-q6x&3 zh~tDn=carr(-m1OrymqIEz=V?F=N+kFDnooO|9tAa54csiBm`lWXxyj`gXlqOqh1Y`$>!Q{iVbG=kZi?32|kb}bzodIiTpf8&np;b9J9PW_2+)oh zDp7LG;0}u`LZrZz_G;l@C7cgsU1ZnNADv9M=Y%&KX;rp#q34~3Yg!Ao>dvm#TYOU8 zyu1K3z9Ry6_^8DA@bJbSGB;ytcge^avuYO~?~4UE z$NS>pLP3rCP=}cqc-v|?j~-m$6E%QozI(H{$chaT#E=g;>r+w)fod$oW5VNzl7>~R oG3OCX;R~*!v>(Qo_=+UWlDx0EiZ{`qEFaSHu&C?IAcAlH2LcE Date: Wed, 14 Sep 2022 11:08:24 +0200 Subject: [PATCH 2/3] Delete PRO4 directory --- PRO4/README.md | 1 - PRO4/pom.xml | 38 ------ .../AUvod.java | 29 ----- .../BGenerikaAPole.java | 28 ----- ...omennyPocetArgumentuAParametrickeTypy.java | 27 ----- .../DVytvoreniPoleSGenerickymiInstancemi.java | 27 ----- .../java/cz/spsmb/ctvrtak/b_anotace/A.java | 10 -- .../cz/spsmb/ctvrtak/b_anotace/AUvod.java | 42 ------- .../b_anotace/BMoznostiPouzitiAnotace.java | 64 ---------- .../b_anotace/CAnotaceVeStdKnihovne.java | 21 ---- .../spsmb/ctvrtak/b_anotace/DMetaanotace.java | 37 ------ .../java/cz/spsmb/ctvrtak/b_anotace/Den.java | 11 -- .../b_anotace/EPrikladRuntimeAnotace.java | 114 ------------------ .../spsmb/ctvrtak/b_anotace/MojeAnotace.java | 4 - .../ctvrtak/b_anotace/SampleAnnotation.java | 14 --- .../cz/spsmb/ctvrtak/b_anotace/Testovat.java | 11 -- .../spsmb/ctvrtak/b_anotace/package-info.java | 3 - .../c_spring/a_config/main/java/Doc.java | 36 ------ .../a_config/main/java/SearchEngine.java | 8 -- .../c_spring/a_config/main/java/Type.java | 35 ------ .../c_spring/a_config/main/java/Zadani.java | 44 ------- .../a_config/test/java/Assertions.java | 12 -- .../a_config/test/java/MyDocumentTest.java | 23 ---- .../a_config/test/java/MySearchEngine.java | 35 ------ .../AUvod.class | Bin 1548 -> 0 bytes .../BGenerikaAPole.class | Bin 670 -> 0 bytes ...mennyPocetArgumentuAParametrickeTypy.class | Bin 1507 -> 0 bytes ...DVytvoreniPoleSGenerickymiInstancemi.class | Bin 1510 -> 0 bytes .../cz/spsmb/ctvrtak/b_anotace/A.class | Bin 310 -> 0 bytes .../cz/spsmb/ctvrtak/b_anotace/AUvod.class | Bin 751 -> 0 bytes .../b_anotace/BMoznostiPouzitiAnotace.class | Bin 963 -> 0 bytes .../b_anotace/CAnotaceVeStdKnihovne.class | Bin 342 -> 0 bytes .../ctvrtak/b_anotace/DMetaanotace.class | Bin 315 -> 0 bytes .../cz/spsmb/ctvrtak/b_anotace/Den.class | Bin 1295 -> 0 bytes .../b_anotace/EPrikladRuntimeAnotace.class | Bin 6896 -> 0 bytes .../spsmb/ctvrtak/b_anotace/MojeAnotace.class | Bin 169 -> 0 bytes .../ctvrtak/b_anotace/SampleAnnotation.class | Bin 462 -> 0 bytes .../cz/spsmb/ctvrtak/b_anotace/Testovat.class | Bin 524 -> 0 bytes .../ctvrtak/b_anotace/package-info.class | Bin 217 -> 0 bytes .../c_spring/a_config/main/java/Doc.class | Bin 1271 -> 0 bytes .../a_config/main/java/SearchEngine.class | Bin 441 -> 0 bytes .../c_spring/a_config/main/java/Type.class | Bin 1077 -> 0 bytes .../c_spring/a_config/main/java/Zadani.class | Bin 333 -> 0 bytes .../a_config/test/java/Assertions.class | Bin 594 -> 0 bytes .../a_config/test/java/MyDocumentTest.class | Bin 1109 -> 0 bytes .../a_config/test/java/MySearchEngine.class | Bin 2238 -> 0 bytes 46 files changed, 674 deletions(-) delete mode 100644 PRO4/README.md delete mode 100644 PRO4/pom.xml delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/A.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/AUvod.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/CAnotaceVeStdKnihovne.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Den.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/SampleAnnotation.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Testovat.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/package-info.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.java delete mode 100644 PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.java delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/A.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/AUvod.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/CAnotaceVeStdKnihovne.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/Den.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/SampleAnnotation.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/Testovat.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/package-info.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.class delete mode 100644 PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.class diff --git a/PRO4/README.md b/PRO4/README.md deleted file mode 100644 index 6729ae8..0000000 --- a/PRO4/README.md +++ /dev/null @@ -1 +0,0 @@ -# PRO4 \ No newline at end of file diff --git a/PRO4/pom.xml b/PRO4/pom.xml deleted file mode 100644 index f7c36aa..0000000 --- a/PRO4/pom.xml +++ /dev/null @@ -1,38 +0,0 @@ - - - 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/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.java deleted file mode 100644 index 20449cd..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.java +++ /dev/null @@ -1,29 +0,0 @@ -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/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.java deleted file mode 100644 index 1498729..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.java +++ /dev/null @@ -1,28 +0,0 @@ -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/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.java deleted file mode 100644 index a7cc236..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.java +++ /dev/null @@ -1,27 +0,0 @@ -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/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.java deleted file mode 100644 index 44194f5..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.java +++ /dev/null @@ -1,27 +0,0 @@ -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/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/A.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/A.java deleted file mode 100644 index 7222ba8..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/A.java +++ /dev/null @@ -1,10 +0,0 @@ -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/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/AUvod.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/AUvod.java deleted file mode 100644 index 6cc1588..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/AUvod.java +++ /dev/null @@ -1,42 +0,0 @@ -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/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.java deleted file mode 100644 index 9767e67..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.java +++ /dev/null @@ -1,64 +0,0 @@ -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/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/CAnotaceVeStdKnihovne.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/CAnotaceVeStdKnihovne.java deleted file mode 100644 index b7a4c7f..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/CAnotaceVeStdKnihovne.java +++ /dev/null @@ -1,21 +0,0 @@ -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/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.java deleted file mode 100644 index 0a64f73..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.java +++ /dev/null @@ -1,37 +0,0 @@ -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/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Den.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Den.java deleted file mode 100644 index 81d836f..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Den.java +++ /dev/null @@ -1,11 +0,0 @@ -package cz.spsmb.ctvrtak.b_anotace; - -public enum Den { - PO, - ÚT, - ST, - ČT, - PÁ, - SO, - NE -} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.java deleted file mode 100644 index 48b63d9..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.java +++ /dev/null @@ -1,114 +0,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/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.java deleted file mode 100644 index 3f21b3a..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.java +++ /dev/null @@ -1,4 +0,0 @@ -package cz.spsmb.ctvrtak.b_anotace; -//Značkovací anotace, nic neobsahuje -public @interface MojeAnotace { -} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/SampleAnnotation.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/SampleAnnotation.java deleted file mode 100644 index ef5b469..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/SampleAnnotation.java +++ /dev/null @@ -1,14 +0,0 @@ -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/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Testovat.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Testovat.java deleted file mode 100644 index 5bcafd6..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/Testovat.java +++ /dev/null @@ -1,11 +0,0 @@ -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/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/package-info.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/package-info.java deleted file mode 100644 index 52e1c9b..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/b_anotace/package-info.java +++ /dev/null @@ -1,3 +0,0 @@ -// Anotace balíčku: -@MojeAnotace -package cz.spsmb.ctvrtak.b_anotace; \ No newline at end of file diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.java deleted file mode 100644 index 5baf9df..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.java +++ /dev/null @@ -1,36 +0,0 @@ -package cz.spsmb.ctvrtak.c_spring.a_config.main.java; - -public class Doc { - Type type; - String name, location; - - public Doc(Type type, String name, String location) { - this.type = type; - this.name = name; - this.location = location; - } - - public Type getType() { - return type; - } - - public void setType(Type type) { - 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; - } -} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.java deleted file mode 100644 index aecdc2a..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.java +++ /dev/null @@ -1,8 +0,0 @@ -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/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.java deleted file mode 100644 index 92d5d04..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.java +++ /dev/null @@ -1,35 +0,0 @@ -package cz.spsmb.ctvrtak.c_spring.a_config.main.java; - -public class Type { - String name, desc, 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/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.java deleted file mode 100644 index 293dcfe..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Zadani.java +++ /dev/null @@ -1,44 +0,0 @@ -package cz.spsmb.ctvrtak.c_spring.a_config.main.java; -/*** - * Autor: Christian - * 1. vytvořím storage() a co pak? - * 2. listAll() a findByType bude vracet null, jaký je postup předělání těchto rozhraní? - * 3. Jakou třídu Assertions? První zmínka je až u kontroly - * 4. private SearchEngine engine = new MySearchEngine; chybí závorky u MySearchEngine - */ - - - - -/*** - * 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/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.java deleted file mode 100644 index c937e2b..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.java +++ /dev/null @@ -1,12 +0,0 @@ -package cz.spsmb.ctvrtak.c_spring.a_config.test.java; - -import org.junit.jupiter.api.Test; - -public class Assertions extends MyDocumentTest { - @Test - public void assertus(){ - - testFindByType(); - testListAll(); - } -} diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.java deleted file mode 100644 index 32dbb76..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.java +++ /dev/null @@ -1,23 +0,0 @@ -package cz.spsmb.ctvrtak.c_spring.a_config.test.java; - -import cz.spsmb.ctvrtak.c_spring.a_config.main.java.SearchEngine; -import cz.spsmb.ctvrtak.c_spring.a_config.main.java.Type; -import org.junit.jupiter.api.Test; - -public class MyDocumentTest { - private SearchEngine engine = new MySearchEngine(); -//není celé, vysvětlení v Zadání - @Test - public void testFindByType() { - System.out.println( - engine.findByType("ahoj") - - ); - } - - @Test - public void testListAll(){ - engine.listAll(); - } - -} \ No newline at end of file diff --git a/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.java b/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.java deleted file mode 100644 index c9c9477..0000000 --- a/PRO4/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.java +++ /dev/null @@ -1,35 +0,0 @@ -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(String typeName) { - List listus = new ArrayList<>(); - for (int i = 0; i < storage().size(); i++) { - if (storage().get(i).getType().getName() == typeName) - listus.add(storage().get(i)); - } - return listus; - } - private List storage(){ - List docList = new ArrayList<>(); - Type typea = new Type("ahoj","mental breakdown", "stembus"); - Type typeb = new Type("ahoj2", "cotojeproctoje", "bambus"); - Doc doca = new Doc(typea, "ahoj","buruh"); - Doc docb = new Doc(typeb,"bruh", "idk"); - docList.add(doca); - docList.add(docb); - return docList; - } -} diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.class b/PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/AUvod.class deleted file mode 100644 index aaf7efb7c7a496be11a0f4ec560aff24777613f7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.class b/PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/BGenerikaAPole.class deleted file mode 100644 index 889efcaf8919c59cfba72706838e400d90ae80fe..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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^ diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.class b/PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/CPromennyPocetArgumentuAParametrickeTypy.class deleted file mode 100644 index d83041e10936e2bdeadd33528252b34c7096e537..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.class b/PRO4/target/classes/cz/spsmb/ctvrtak/a_promenny_pocet_argumentu_metod/DVytvoreniPoleSGenerickymiInstancemi.class deleted file mode 100644 index fd82f8023ea981ac609e8547a7944e535b4db1e0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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^ diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/AUvod.class b/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/AUvod.class deleted file mode 100644 index b61f9f1d7f52c7025decb43dd51759c1024b9619..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.class b/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/BMoznostiPouzitiAnotace.class deleted file mode 100644 index eee1abb912f174280a05172a38aef19d6393ed8d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.class b/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/DMetaanotace.class deleted file mode 100644 index 9cfc766f9aa34ca98c9537428052543ebac77f87..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.class b/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/EPrikladRuntimeAnotace.class deleted file mode 100644 index 51d8efb2526053257e7c568d1ac68e944a733af2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6896 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 K;sP-Xk^cfckACC; diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.class b/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/MojeAnotace.class deleted file mode 100644 index c3b7bbd86245a8dc80bc6699db89226dfe9b6ad9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/package-info.class b/PRO4/target/classes/cz/spsmb/ctvrtak/b_anotace/package-info.class deleted file mode 100644 index d3f94a1d00c8253b760c8080105c9654795edbe2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 217 zcmX^0Z`VEs1_m1jPId++Mh5ldD*fVu;@l+tD#y5~OJYa1TM3>D zBqAghJOB@cICCAEDoGcqEZ^%po;mY*X8h;xuipT6@uY|hvIcS{7LZq1K65S{yXOR5 z`(x+Ka}$O9t{?cxoC722?-LG~$i2EJeO)jFu`E0w#@gVXU?i{;e zaN>9EzT*eBmVF<(3c2LVz*BhLnk)2>K|7MXVqyu)lnI0c z2gK^_C>UKYkzy#kX*A~(&^4q&{9obiO-dr4D-ip-{xw2Obs)`=I;=IO--|?v60OVT zl*lwb6%WGm$n`$>Qo#bh`-P;yL$*J|sm=1{^l^pEg5KF}?gkXcxW;vjryjj?+-ufP zDC_AEhV^WSvh{q3mG87?Q0H1_ghb|KvUycdMX>kiEy8(?JO-6N6{r$-RV&m} zuS>Z62u@)W_eWY+LCTXL^_d_KSmzlayKN`x+2wjetDTJ$U>NO2YA( diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.class b/PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.class deleted file mode 100644 index 8cfe74f5240ba51f80d0abe44566bd3b5e2b588d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 441 zcmbV}!A=4(5QhJvu!3mBXYha*dnQXvG|Fic56i(DDYdKvrMu~NN$}A;_y9hXadt_F zi5}G3{4;-MzW#mxczpvf#%Y9>z(~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%^!;CDT`!6L)5sIuDna1lF)V>Fm?aS##bGI9GJYTG=L8G16|9Fp(B` zf~OQ=>|M%cVcQ^2LHR!i774dz6qd8Bzi{>hPGBP!q%sTA$OU*?WsczU4FW6Z^d{ZwBVU$~E?lx6n{392o zC`Wm%xty`LE&mha@M0UnRsN4%*M#h$-gs?pZM$Ibd%{I~4vvw^%dL^PJT15{Om!Sc d&fY<9B1Fgp+cI#Df#9&q6Nv}H2#10ZMn8AG9>Vzl@~gZg{9UXw_N1GPXOLG32hov1F+GO3T}1K9X@?jAoQ+_+cPs0}(41 zuaY_YsEB^<|Ff|+LrJ7qG@;#)M#{>Vi%4;| zG@?}Q!z2!5Pq|j>>&Z{uj&VfeX6UX!%G@Q9)+yq2GCK3EH?Wt~-XwK4C9y^7t==2h wrifvO+)Vm&nD8nL)IC{!7aM_3slArXqS9fW-o>AlV))64ew=*VgLXD diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.class b/PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.class deleted file mode 100644 index cf1b7980e2fd863e7efb137a43bed725904f6696..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1109 zcmbW0TTj$L7>3{3T`Aiw2Meeu9#GU>RK~*3OZ@NTkX_x%p@^p7UmsX#|?(56Ra{=rcgRm z6ibmgthU!^n+R??xP{wvHYDs?7&5r^ztkw=r|}MXn`ly9Uu01yNVY^Lq#d^z`yy_nA#i^g_le&F;9J4qIbh+q|T*TndbCx zXspv}HD3dhiw9tf-(bBxK=m{15A?5u294&qfu2AGqgbSwLpSL>?%*zc8SW9Ql(ROD zSnfx{eS+8wE{2>+? X-W;QcMyJW}OaWOt5&3{1B|Q8ETX7C> diff --git a/PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.class b/PRO4/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.class deleted file mode 100644 index 2db51aa1a5c0615602e7c7ac835e46eaac86942c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2238 zcmbVNTUQfT6#h;wW*md!AW%>$P}&kef~d6`jG#!14cImjg#Gc!u!Wi7%(GUx2GZ{N4~KIe~rfB6-_45W?-q6x&3 zh~tDn=carr(-m1OrymqIEz=V?F=N+kFDnooO|9tAa54csiBm`lWXxyj`gXlqOqh1Y`$>!Q{iVbG=kZi?32|kb}bzodIiTpf8&np;b9J9PW_2+)oh zDp7LG;0}u`LZrZz_G;l@C7cgsU1ZnNADv9M=Y%&KX;rp#q34~3Yg!Ao>dvm#TYOU8 zyu1K3z9Ry6_^8DA@bJbSGB;ytcge^avuYO~?~4UE z$NS>pLP3rCP=}cqc-v|?j~-m$6E%QozI(H{$chaT#E=g;>r+w)fod$oW5VNzl7>~R oG3OCX;R~*!v>(Qo_=+UWlDx0EiZ{`qEFaSHu&C?IAcAlH2LcE Date: Wed, 14 Sep 2022 11:09:21 +0200 Subject: [PATCH 3/3] vcv vcvc --- 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 | 36 +++ .../a_config/main/java/SearchEngine.java | 8 + .../c_spring/a_config/main/java/Type.java | 35 +++ .../c_spring/a_config/main/java/Zadani.java | 78 +++--- .../a_config/test/java/Assertions.java | 12 + .../a_config/test/java/MyDocumentTest.java | 23 ++ .../a_config/test/java/MySearchEngine.java | 35 +++ .../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 -> 1271 bytes .../a_config/main/java/SearchEngine.class | Bin 0 -> 441 bytes .../c_spring/a_config/main/java/Type.class | Bin 0 -> 1077 bytes .../c_spring/a_config/main/java/Zadani.class | Bin 0 -> 333 bytes .../a_config/test/java/Assertions.class | Bin 0 -> 594 bytes .../a_config/test/java/MyDocumentTest.class | Bin 0 -> 1109 bytes .../a_config/test/java/MySearchEngine.class | Bin 0 -> 2238 bytes 45 files changed, 671 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..5baf9df --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Doc.java @@ -0,0 +1,36 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.main.java; + +public class Doc { + Type type; + String name, location; + + public Doc(Type type, String name, String location) { + this.type = type; + this.name = name; + this.location = location; + } + + public Type getType() { + return type; + } + + public void setType(Type type) { + 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; + } +} 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..aecdc2a --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.java @@ -0,0 +1,8 @@ +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..92d5d04 --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/main/java/Type.java @@ -0,0 +1,35 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.main.java; + +public class Type { + String name, desc, 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..293dcfe 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,44 @@ -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; +/*** + * Autor: Christian + * 1. vytvořím storage() a co pak? + * 2. listAll() a findByType bude vracet null, jaký je postup předělání těchto rozhraní? + * 3. Jakou třídu Assertions? První zmínka je až u kontroly + * 4. private SearchEngine engine = new MySearchEngine; chybí závorky u MySearchEngine + */ + + + + +/*** + * 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..c937e2b --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/Assertions.java @@ -0,0 +1,12 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.test.java; + +import org.junit.jupiter.api.Test; + +public class Assertions extends MyDocumentTest { + @Test + public void assertus(){ + + testFindByType(); + testListAll(); + } +} 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..32dbb76 --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MyDocumentTest.java @@ -0,0 +1,23 @@ +package cz.spsmb.ctvrtak.c_spring.a_config.test.java; + +import cz.spsmb.ctvrtak.c_spring.a_config.main.java.SearchEngine; +import cz.spsmb.ctvrtak.c_spring.a_config.main.java.Type; +import org.junit.jupiter.api.Test; + +public class MyDocumentTest { + private SearchEngine engine = new MySearchEngine(); +//není celé, vysvětlení v Zadání + @Test + public void testFindByType() { + System.out.println( + engine.findByType("ahoj") + + ); + } + + @Test + public void testListAll(){ + engine.listAll(); + } + +} \ No newline at end of file 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..c9c9477 --- /dev/null +++ b/src/main/java/cz/spsmb/ctvrtak/c_spring/a_config/test/java/MySearchEngine.java @@ -0,0 +1,35 @@ +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(String typeName) { + List listus = new ArrayList<>(); + for (int i = 0; i < storage().size(); i++) { + if (storage().get(i).getType().getName() == typeName) + listus.add(storage().get(i)); + } + return listus; + } + private List storage(){ + List docList = new ArrayList<>(); + Type typea = new Type("ahoj","mental breakdown", "stembus"); + Type typeb = new Type("ahoj2", "cotojeproctoje", "bambus"); + Doc doca = new Doc(typea, "ahoj","buruh"); + Doc docb = new Doc(typeb,"bruh", "idk"); + docList.add(doca); + docList.add(docb); + return docList; + } +} 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 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 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+tD#y5~OJYa1TM3>D zBqAghJOB@cICCAEDoGcqEZ^%po;mY*X8h;xuipT6@uY|hvIcS{7LZq1K65S{yXOR5 z`(x+Ka}$O9t{?cxoC722?-LG~$i2EJeO)jFu`E0w#@gVXU?i{;e zaN>9EzT*eBmVF<(3c2LVz*BhLnk)2>K|7MXVqyu)lnI0c z2gK^_C>UKYkzy#kX*A~(&^4q&{9obiO-dr4D-ip-{xw2Obs)`=I;=IO--|?v60OVT zl*lwb6%WGm$n`$>Qo#bh`-P;yL$*J|sm=1{^l^pEg5KF}?gkXcxW;vjryjj?+-ufP zDC_AEhV^WSvh{q3mG87?Q0H1_ghb|KvUycdMX>kiEy8(?JO-6N6{r$-RV&m} zuS>Z62u@)W_eWY+LCTXL^_d_KSmzlayKN`x+2wjetDTJ$U>NO2YA( literal 0 HcmV?d00001 diff --git a/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.class b/target/classes/cz/spsmb/ctvrtak/c_spring/a_config/main/java/SearchEngine.class new file mode 100644 index 0000000000000000000000000000000000000000..8cfe74f5240ba51f80d0abe44566bd3b5e2b588d GIT binary patch literal 441 zcmbV}!A=4(5QhJvu!3mBXYha*dnQXvG|Fic56i(DDYdKvrMu~NN$}A;_y9hXadt_F zi5}G3{4;-MzW#mxczpvf#%Y9>z(~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%^!;CDT`!6L)5sIuDna1lF)V>Fm?aS##bGI9GJYTG=L8G16|9Fp(B` zf~OQ=>|M%cVcQ^2LHR!i774dz6qd8Bzi{>hPGBP!q%sTA$OU*?WsczU4FW6Z^d{ZwBVU$~E?lx6n{392o zC`Wm%xty`LE&mha@M0UnRsN4%*M#h$-gs?pZM$Ibd%{I~4vvw^%dL^PJT15{Om!Sc d&fY<9B1Fgp+cI#Df#9&q6Nv}H2#10ZMn8AG9>Vzl@~gZg{9UXw_N1GPXOLG32hov1F+GO3T}1K9X@?jAoQ+_+cPs0}(41 zuaY_YsEB^<|Ff|+LrJ7qG@;#)M#{>Vi%4;| zG@?}Q!z2!5Pq|j>>&Z{uj&VfeX6UX!%G@Q9)+yq2GCK3EH?Wt~-XwK4C9y^7t==2h wrifvO+)Vm&nD8nL)IC{!7aM_3slArXqS9fW-o>AlV))64ew=*VgLXD 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..cf1b7980e2fd863e7efb137a43bed725904f6696 GIT binary patch literal 1109 zcmbW0TTj$L7>3{3T`Aiw2Meeu9#GU>RK~*3OZ@NTkX_x%p@^p7UmsX#|?(56Ra{=rcgRm z6ibmgthU!^n+R??xP{wvHYDs?7&5r^ztkw=r|}MXn`ly9Uu01yNVY^Lq#d^z`yy_nA#i^g_le&F;9J4qIbh+q|T*TndbCx zXspv}HD3dhiw9tf-(bBxK=m{15A?5u294&qfu2AGqgbSwLpSL>?%*zc8SW9Ql(ROD zSnfx{eS+8wE{2>+? X-W;QcMyJW}OaWOt5&3{1B|Q8ETX7C> 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..2db51aa1a5c0615602e7c7ac835e46eaac86942c GIT binary patch literal 2238 zcmbVNTUQfT6#h;wW*md!AW%>$P}&kef~d6`jG#!14cImjg#Gc!u!Wi7%(GUx2GZ{N4~KIe~rfB6-_45W?-q6x&3 zh~tDn=carr(-m1OrymqIEz=V?F=N+kFDnooO|9tAa54csiBm`lWXxyj`gXlqOqh1Y`$>!Q{iVbG=kZi?32|kb}bzodIiTpf8&np;b9J9PW_2+)oh zDp7LG;0}u`LZrZz_G;l@C7cgsU1ZnNADv9M=Y%&KX;rp#q34~3Yg!Ao>dvm#TYOU8 zyu1K3z9Ry6_^8DA@bJbSGB;ytcge^avuYO~?~4UE z$NS>pLP3rCP=}cqc-v|?j~-m$6E%QozI(H{$chaT#E=g;>r+w)fod$oW5VNzl7>~R oG3OCX;R~*!v>(Qo_=+UWlDx0EiZ{`qEFaSHu&C?IAcAlH2LcE