A Java beépített kommentárjainak áttekintése

1. Áttekintés

Ebben a cikkben a Java nyelv alapvető jellemzőiről - a JDK-ban elérhető alapértelmezett kommentárokról - fogunk beszélni.

2. Mi a kommentár

Egyszerűen fogalmazva: a kommentárok Java típusok, amelyeket „@” szimbólum előz meg.

A Java-nak az 1.5-ös kiadás óta vannak megjegyzései. Azóta úgy alakították, ahogy mi megterveztük alkalmazásainkat.

A Spring és a Hibernate nagyszerű példa azokra a keretrendszerekre, amelyek nagyban az annotációkra támaszkodnak a különböző tervezési technikák lehetővé tételéhez.

Alapvetően, egy kommentár extra metaadatokat rendel hozzá a hozzá tartozó forráskódhoz. Annotáció hozzáadásával egy módszerhez, felülethez, osztályhoz vagy mezőhöz a következőket tehetjük:

  1. Tájékoztassa a fordítót a figyelmeztetésekről és a hibákról
  2. A forráskód manipulálása a fordítás idején
  3. Futtatás közbeni viselkedés módosítása vagy vizsgálata

3. Java beépített kommentárok

Most, hogy áttekintettük az alapokat, vessünk egy pillantást néhány feljegyzésre, amelyek a Java alapmotorral érkeznek. Először is, sokan tájékoztatják az összeállítást:

  1. @ Felülírás
  2. @SuppressWarnings
  3. @Elavult
  4. @SafeVarargs
  5. @FunctionalInterface
  6. @Anyanyelvi

Ezek a megjegyzések generálják vagy elnyomják a fordító figyelmeztetéseit és hibáit. A következetes alkalmazás gyakran jó gyakorlat, mivel ezek hozzáadása megakadályozhatja a jövőbeni programozói hibákat.

A @ Felülírás annotációval jelzik, hogy egy módszer felülírja vagy felváltja az öröklött módszer viselkedését.

@SuppressWarnings azt jelzi, hogy figyelmen kívül akarjuk hagyni a kód egy részének bizonyos figyelmeztetéseit. A @SafeVarargs az annotáció a varargs használatával kapcsolatos figyelmeztetés típusára is hat.

A @Elavult annotációval meg lehet jelölni egy API-t, amely már nem használható. Sőt, ezt a feljegyzést utólag beépítették a Java 9-be, hogy több információt jelenítsen meg az elavulással kapcsolatban.

Mindezekről részletesebb információkat talál a linkelt cikkekben.

3.1. @FunctionalInterface

A Java 8 lehetővé teszi számunkra, hogy funkcionálisabban írjunk kódot.

Ennek nagy része az Single Abstract Method interfészek. Ha egy SAM interfészt kívánunk használni a lambdas számára, akkor opcionálisan jelölhetjük is azzal @FunctionalInterface:

@FunctionalInterface nyilvános felület Adder {int add (int a, int b); }

Mint @ Felülírás módszerekkel, @FunctionalInterface kinyilvánítja szándékainkat azzal Vipera.

Most, hogy használjuk-e @FunctionalInterface vagy sem, akkor is használhatjuk Vipera ugyanúgy:

Összeadó összeadó = (a, b) -> a + b; int eredmény = összeadó.add (4,5);

De ha hozzáadunk egy második módszert Vipera, akkor a fordító panaszkodni fog:

@FunctionalInterface nyilvános felület Adder {// fordító azt panaszolja, hogy az interfész nem SAM int add (int a, int b); int div (int a, int b); }

Most ez összeállt volna a @FunctionalInterface annotáció. Szóval, mit ad nekünk?

Mint @ Felülírás, ez a megjegyzés megvéd minket a jövőbeli programozói hibáktól. Annak ellenére, hogy legális egynél több módszer használata az interfészen, ez nem akkor történik, amikor ezt a felületet használják lambda célként. E jegyzet nélkül a fordító a tucatnyi helyen megtörne Vipera lambdaként használták. Most, csak betör Vipera maga.

3.2. @Anyanyelvi

A Java 8-tól kezdve új megjegyzés található a java.lang.jegyzet nevű csomagot Anyanyelvi. A @Anyanyelvi az annotáció csak mezőkre vonatkozik. Azt jelzi, hogy a kommentált mező állandó, amelyre a natív kódból lehet hivatkozni. Például, itt van, hogyan használják a Egész szám osztály:

public final class Integer {@Natív nyilvános statikus final int MIN_VALUE = 0x80000000; // kihagyva}

Ez a megjegyzés tippként szolgálhat néhány segédfejlécfájl létrehozására szolgáló eszközök számára is.

4. Meta-kommentárok

Ezután a meta-annotációk olyan kommentárok, amelyek más annotációkra is alkalmazhatók.

Például ezeket a meta-annotációkat használják a kommentárok konfigurálásához:

  1. @Cél
  2. @Visszatartás
  3. @Örökölt
  4. @Dokumentált
  5. @Megismételhető

4.1. @Cél

A kommentárok köre a követelményektől függően változhat. Míg az egyik annotációt csak metódusoknál használják, egy másik annotáció felhasználható konstruktor és terepi deklarációkkal.

Az egyéni kommentárok célelemeinek meghatározásához a-val kell ellátnunk @Cél annotáció.

@Cél nyolc különböző elemtípusral tud dolgozni. Ha megnézzük a @ forráskódjátSafeVarargs, akkor láthatjuk, hogy csak konstruktorokhoz vagy módszerekhez kell csatolni:

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

4.2. @Visszatartás

Egyes kommentárok a fordító számára használható tippek, míg mások futás közben.

Használjuk a @Visszatartás annotáció annak megadására, hogy a program életciklusában hol található az annotációnk.

Ehhez konfigurálnunk kell @Visszatartás a három megőrzési politika egyikével:

  1. RetentionPolicy.SOURCE - sem a fordító, sem a futás nem látható
  2. RetentionPolicy.CLASS - a fordító látható
  3. RetentionPolicy.RUNTIME - a fordító és a futásidő által látható

@Visszatartás alapértelmezett RetentionPolicy.SOURCE.

Ha van olyan jegyzetünk, amelynek futás közben elérhetőnek kell lennie:

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

Ezután, ha néhány jegyzetet adunk egy osztályhoz:

@RetentionAnnotation @Deprecated public class AnnotatedClass {}

Most elmélkedhetünk ezen AnnotatedClass hogy megnézze, hány megjegyzés marad meg:

@Test public void whenAnnotationRetentionPolicyRuntime_shouldAccess () {AnnotatedClass anAnnotatedClass = new AnnotatedClass (); Annotation [] annotations = anAnnotatedClass.getClass (). GetAnnotations (); assertThat (kommentárok.hossz: (1)); }

Az érték 1, mert @RetentionAnnotation megőrzési politikája RUNTIME míg @Elavult nem.

4.3. @Örökölt

Bizonyos helyzetekben szükségünk lehet egy alosztályra, hogy a feljegyzések szülőosztályhoz legyenek kötve.

Használhatjuk a @Örökölt annotáció, hogy az annotációnk egy annotált osztályból az alosztályaiba terjedjen.

Ha alkalmazzuk @Örökölt egyéni feljegyzésünkre, majd alkalmazza BaseClass:

@Inherited @Target (ElementType.TYPE) @Retention (RetentionPolicy.RUNTIME) public @interface InheritedAnnotation {} @InheritedAnnotation public class BaseClass {} public class DerivedClass extends BaseClass {}

Aztán a BaseClass kiterjesztése után ezt látnunk kell DerivedClass úgy tűnik, hogy futás közben ugyanaz az annotáció van:

@Test public void whenAnnotationInherited_thenShouldExist () {DerivedClasseredClass = new DerivedClass (); InheritedAnnotation annotation =eredClass.getClass () .getAnnotation (InheritedAnnotation.class); assertThat (annotáció, instanceOf (InheritedAnnotation.class)); }

A @Örökölt annotációval, a fenti teszt sikertelen lesz.

4.4. @Dokumentált

Alapértelmezés szerint a Java nem dokumentálja a Javadocs jegyzetek használatát.

De használhatjuk a @Dokumentált annotáció a Java alapértelmezett viselkedésének megváltoztatásához.

Ha létrehozunk egy egyedi feljegyzést, amely felhasználja @Dokumentált:

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

És alkalmazza a megfelelő Java elemre:

public class Employee {@ExcelCell (0) public String név; }

Aztán a Munkavállaló A javadoc felfedi az annotáció használatát:

4.5. @Megismételhető

Néha hasznos lehet ugyanazt a kommentárt többször megadni egy adott Java elemen.

A Java 7 előtt a kommentárokat egyetlen tároló kommentárba kellett csoportosítanunk:

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

A Java 7 azonban tisztább megközelítést hozott. Val vel a @Megismételhető kommentár, megismételhetővé tehetjük a kommentárokat:

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

Használni @Megismételhető, rendelkeznünk kell egy konténer feljegyzéssel is. Ebben az esetben újra felhasználjuk @ Ütemezések:

public @interface Schedules {Schedule [] érték (); }

Természetesen ez nagyon hasonlít arra, ami a Java 7 előtt volt. De most az az érték, hogy a burkoló @ Ütemezések már nincs megadva, amikor meg kell ismételnünk @Menetrend:

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

Mivel a Java megköveteli a burkoló feliratozását, könnyű volt áttérnünk a Java 7 előtti feljegyzések listájáról megismételhető feljegyzésekre.

5. Következtetés

Ebben a cikkben a Java beépített kommentárjairól beszéltünk, amelyeket minden Java-fejlesztőnek ismernie kell.

Mint mindig, a cikk összes példája megtalálható a GitHubon.