streamalism.org

1. Prehľad

V tomto článku si povieme o základnej funkcii jazyka Java - predvolených anotáciách dostupných v JDK.

2. Čo je anotácia

Jednoducho povedané, anotácie sú Pred typmi Java, pred ktorými je uvedený znak „@“.

Java má poznámky už od vydania verzie 1.5. Odvtedy ovplyvnili spôsob, akým sme navrhli naše aplikácie.

Jar a Hibernate sú skvelými príkladmi rámcov, ktoré sa vo veľkej miere spoliehajú na anotácie, aby umožnili rôzne techniky návrhu.

V podstate anotácia priradí zdrojovému kódu, na ktorý je viazaný, ďalšie metadáta. Pridaním anotácie k metóde, rozhraniu, triede alebo poľu môžeme:

1. Informujte kompilátora o varovaniach a chybách
2. Manipulovať so zdrojovým kódom v čase kompilácie
3. Upravte alebo preskúmajte správanie za behu programu

3. Vstavané anotácie Java

Teraz, keď sme si preštudovali základné informácie, poďme sa pozrieť na niekoľko anotácií, ktoré sa dodávajú s jadrom Java. Najprv existuje niekoľko, ktoré informujú o kompilácii:

1. @ Override
2. @SuppressWarnings
3. @ Zastarané
4. @SafeVarargs
5. @Funkčné rozhranie
6. @ Natívny

Tieto anotácie generujú alebo potláčajú varovania a chyby kompilátora. Dôsledným používaním je často ich dôsledné použitie, pretože ich pridávanie môže zabrániť budúcim chybám programátora.

The @ Override anotácia sa používa na označenie toho, že metóda prepíše alebo nahradí správanie zdedenej metódy.

@SuppressWarnings naznačuje, že chceme ignorovať určité varovania z časti kódu. The @SafeVarargs anotácia tiež pôsobí na typ varovania súvisiaceho s používaním varargs.

The @ Zastarané anotáciu je možné použiť na označenie API, ktoré už nie je určené na použitie. Táto anotácia bola navyše dodatočne namontovaná v prostredí Java 9, aby predstavovala viac informácií o ukončení podpory.

O tom všetkom nájdete podrobnejšie informácie v odkazovaných článkoch.

3.1. @Funkčné rozhranie

Java 8 nám umožňuje písať kód funkčnejším spôsobom.

Veľkú časť tvoria rozhrania jednej abstraktnej metódy. Ak máme v úmysle použiť rozhranie SAM lambdas, môžeme ho voliteľne označiť ako také @Funkčné rozhranie:

@FunctionalInterface verejné rozhranie Adder {int add (int a, int b); }

Páči sa mi to @ Override s metódami, @Funkčné rozhranie deklaruje naše zámery s Sčítačka.

Či už použijeme @Funkčné rozhranie alebo nie, stále môžeme použiť Sčítačka rovnakym sposobom:

Sčítačka sčítačka = (a, b) -> a + b; int výsledok = adder.add (4,5);

Ale ak k tomu pridáme druhú metódu Zmije, potom sa kompilátor sťažuje:

@FunctionalInterface verejné rozhranie Adder {// kompilátor sa sťažuje, že rozhranie nie je SAM int add (int a, int b); int div (int a, int b); }

Teraz by to bolo zostavené bez @Funkčné rozhranie anotácia. Takže, čo nám to dáva?

Páči sa mi to @ Override, táto anotácia nás chráni pred budúcou chybou programátora. Aj keď je legálne mať na rozhraní viac ako jednu metódu, nie je to tak, keď sa toto rozhranie používa ako cieľ lambda. Bez tejto anotácie by sa kompilátor prelomil na desiatkach miest, kde Sčítačka bola použitá ako lambda. Teraz, proste to nabúra Sčítačka sám.

3.2. @ Natívny

Od verzie Java 8 je v anotácii nová poznámka java.lang.annotácia balíček volal Nativní. The @ Natívny anotácia je použiteľná iba pre polia. Znamená to, že anotované pole je konštanta, na ktorú sa dá odkazovať z natívneho kódu. Tu je príklad, ako sa používa v Celé číslo trieda:

verejné posledné triedy Integer {@Native public static final int MIN_VALUE = 0x80000000; // vynechané}

Táto anotácia môže tiež slúžiť ako pomôcka pre nástroje na generovanie niektorých pomocných súborov hlavičiek.

4. Meta-anotácie

Ďalej sú metanotácie anotácie, ktoré je možné použiť na iné anotácie.

Napríklad tieto metaanotácie sa používajú na konfiguráciu anotácií:

1. @ Cieľ
2. @ Zadržanie
3. @ Zdedené
4. @Dokumentované
5. @ Opakovateľné

4.1. @ Cieľ

Rozsah anotácií sa môže líšiť v závislosti od požiadaviek. Zatiaľ čo jedna anotácia sa používa iba pri metódach, inú anotáciu je možné spotrebovať pri deklaráciách konštruktora a poľa.

Aby sme určili cieľové prvky vlastnej anotácie, musíme ju označiť a @ Cieľ anotácia.

@ Cieľ môže pracovať s ôsmimi rôznymi typmi prvkov. Ak sa pozrieme na zdrojový kód @SafeVarargs, potom vidíme, že musí byť pripojený iba k konštruktorom alebo metódam:

@Documented @Retention (RetentionPolicy.RUNTIME) @Target ({ElementType.CONSTRUCTOR, ElementType.METHOD}) public @interface SafeVarargs {}

4.2. @ Zadržanie

Niektoré anotácie majú slúžiť ako pomôcka pre kompilátor, iné sa používajú za behu programu.

Používame @ Zadržanie anotácia hovoriaca o tom, kde v životnom cykle nášho programu naša anotácia platí.

Aby sme to dosiahli, musíme sa nakonfigurovať @ Zadržanie s jednou z troch zásad uchovávania údajov:

1. RetentionPolicy.SOURCE - nie sú viditeľné ani kompilátorom, ani runtime
2. RetentionPolicy.CLASS - viditeľné kompilátorom
3. RetentionPolicy.RUNTIME - viditeľné pre kompilátor a runtime

@Zadržanie predvolené hodnoty pre RetentionPolicy.SOURCE.

Ak máme anotáciu, ktorá by mala byť prístupná za behu programu:

@Retention (RetentionPolicy.RUNTIME) @Target (TYPE) public @interface RetentionAnnotation {}

Ak potom do triedy pridáme nejaké anotácie:

@RetentionAnnotation @Deprecated verejná trieda AnnotatedClass {}

Teraz sa môžeme zamyslieť AnnotatedClass Ak chcete zistiť, koľko anotácií sa zachovalo:

@Test public void whenAnnotationRetentionPolicyRuntime_shouldAccess () {AnnotatedClass anAnnotatedClass = new AnnotatedClass (); Annotation [] annotations = anAnnotatedClass.getClass (). GetAnnotations (); assertThat (annotations.length, is (1)); }

Hodnota je 1, pretože @RetentionAnnotation má retenčnú politiku vo výške BEH PROGRAMU zatiaľ čo @ Zastarané nie.

4.3. @ Zdedené

V niektorých situáciách budeme možno potrebovať podtriedu, aby sme mali anotácie spojené s nadradenou triedou.

Môžeme použiť @ Zdedené anotácia, aby sa naša anotácia rozšírila z anotovanej triedy do jej podtried.

Ak podáme žiadosť @ Zdedené na našu vlastnú anotáciu a potom ju použiť na BaseClass:

@Inherited @Target (ElementType.TYPE) @Retention (RetentionPolicy.RUNTIME) public @interface InheritedAnnotation {} @InheritedAnnotation verejná trieda BaseClass {} verejná trieda DerivedClass rozširuje BaseClass {}

Potom, po rozšírení BaseClass, by sme sa toho mali dočkať Odvodená trieda Zdá sa, že má za behu rovnakú anotáciu:

@Test public void whenAnnotationInherited_thenShouldExist () {DerivedClass derivedClass = new DerivedClass (); InheritedAnnotation annotation = derivedClass.getClass () .getAnnotation (InheritedAnnotation.class); assertThat (anotácia, instanceOf (InheritedAnnotation.class)); }

Bez @ Zdedené anotácia, vyššie uvedený test by zlyhal.

4.4. @Dokumentované

Java predvolene dokumentuje použitie anotácie v Javadocs.

Môžeme však použiť @Dokumentované anotácia, aby sa zmenilo predvolené správanie Javy.

Ak vytvoríme vlastnú anotáciu, ktorá použije @Dokumentované:

@Documented @Target (ElementType.FIELD) @Retention (RetentionPolicy.RUNTIME) public @interface ExcelCell {int value (); }

A aplikujte ho na príslušný prvok Java:

public class Employee {@ExcelCell (0) public String name; }

Potom Zamestnanec Javadoc odhalí použitie anotácie:

4.5. @ Opakovateľné

Niekedy môže byť užitočné zadať rovnakú anotáciu viackrát pre daný prvok Java.

Pred programom Java 7 sme museli zoskupiť anotácie do jednej anotácie kontajnera:

@Schedules ({@Schedule (time = "15:05"), @Schedule (time = "23:00")}) void scheduledAlarm () {}

Java 7 však priniesla čistejší prístup. S the @ Opakovateľné anotácia, môžeme vytvoriť opakovateľnú anotáciu:

@Repeatable (Schedules.class) public @interface Schedule {String time () predvolené "09:00"; }

Použit @ Opakovateľné, musíme mať tiež anotáciu kontajnera. V takom prípade použijeme znova @ Rozvrhy:

public @interface Schedules {Schedule [] value (); }

Samozrejme to vyzerá veľmi podobne ako to, čo sme mali pred jazykom Java 7. Teraz však máme hodnotu, že obal je ten @ Rozvrhy už nie je zadané, keď potrebujeme opakovať @ Časový plán:

@Schedule @Schedule (time = "15:05") @Schedule (time = "23:00") void scheduledAlarm () {}

Pretože Java vyžaduje súhrnnú anotáciu, bolo pre nás ľahké migrovať zo zoznamov anotácií starších ako Java 7 na opakovateľné anotácie.

5. Záver

V tomto článku sme hovorili o zabudovaných anotáciách Java, s ktorými by mal byť oboznámený každý vývojár Java.

Všetky príklady článku nájdete ako vždy na GitHube.