Java-annotatietypen

In deze zelfstudie leren we over verschillende soorten Java-annotaties met behulp van voorbeelden.

Java-annotaties zijn metadata (data over data) voor onze programmabroncode. Er zijn verschillende vooraf gedefinieerde annotaties die door de Java SE worden geleverd. Bovendien kunnen we ook aangepaste annotaties maken volgens onze behoeften.

Als je niet weet wat annotaties zijn, ga dan naar de Java-annotatiestutorial.

Deze annotaties kunnen worden gecategoriseerd als:

1. Vooraf gedefinieerde annotaties

@Deprecated
@Override
@SuppressWarnings
@SafeVarargs
@FunctionalInterface

2. Aangepaste annotaties

3. Meta-annotaties

@Retention
@Documented
@Target
@Inherited
@Repeatable

Vooraf gedefinieerde annotatietypen

1. @Verouderd

De @Deprecated annotatie is een markeringsannotatie die aangeeft dat het element (klasse, methode, veld, enz.) is verouderd en is vervangen door een nieuwer element.

De syntaxis is:

@Deprecated
accessModifier returnType deprecatedMethodName() { ... }

Wanneer een programma het element gebruikt dat gedeprecieerd is verklaard, genereert de compiler een waarschuwing.

We gebruiken Javadoc @deprecated tag voor het documenteren van het verouderde element.

/**
 * @deprecated
 * why it was deprecated
 */
@Deprecated
accessModifier returnType deprecatedMethodName() { ... }

Voorbeeld 1:@Verouderd annotatievoorbeeld

class Main {
  /**
   * @deprecated
   * This method is deprecated and has been replaced by newMethod()
   */
  @Deprecated
  public static void deprecatedMethod() { 
    System.out.println("Deprecated method"); 
  } 

  public static void main(String args[]) {
    deprecatedMethod();
  }
}

Uitvoer

Deprecated method

2. @Overschrijven

De @Override annotatie geeft aan dat een methode van een subklasse de methode van de superklasse met dezelfde methodenaam, retourtype en parameterlijst overschrijft.

Het is niet verplicht om @Override . te gebruiken bij het overschrijven van een methode. Als we het echter gebruiken, geeft de compiler een foutmelding als er iets mis is (zoals een verkeerd parametertype) terwijl de methode wordt overschreven.

Voorbeeld 2:voorbeeld van @Override annotatie

class Animal {

  // overridden method
  public void display(){
    System.out.println("I am an animal");
  }
}

class Dog extends Animal {

  // overriding method
  @Override
  public void display(){
    System.out.println("I am a dog");
  }

  public void printMessage(){
    display();
  }
}

class Main {
  public static void main(String[] args) {
    Dog dog1 = new Dog();
    dog1.printMessage();
  }
}

Uitvoer

I am a dog

In dit voorbeeld, door een object dog1 . te maken van Hond klasse, kunnen we zijn methode printMessage() . noemen die vervolgens de display() . uitvoert verklaring.

Sinds display() is gedefinieerd in beide klassen, de methode van subklasse Hond overschrijft de methode van superklasse Animal . Vandaar dat de display() van de subklasse wordt aangeroepen.

3. @SuppressWarnings

Zoals de naam al doet vermoeden, is de @SuppressWarnings annotatie instrueert de compiler om waarschuwingen te onderdrukken die worden gegenereerd terwijl het programma wordt uitgevoerd.

We kunnen het type waarschuwingen specificeren dat moet worden onderdrukt. De waarschuwingen die kunnen worden onderdrukt, zijn specifiek voor de compiler, maar er zijn twee categorieën waarschuwingen:beëindiging en niet aangevinkt .

Om een bepaalde categorie waarschuwingen te onderdrukken, gebruiken we:

@SuppressWarnings("warningCategory")

Bijvoorbeeld,

@SuppressWarnings("deprecated")

Om meerdere categorieën waarschuwingen te onderdrukken, gebruiken we:

@SuppressWarnings({"warningCategory1", "warningCategory2"})

Bijvoorbeeld,

@SuppressWarnings({"deprecated", "unchecked"})

Categorie deprecated instrueert de compiler om waarschuwingen te onderdrukken wanneer we een verouderd element gebruiken.

Categorie unchecked instrueert de compiler om waarschuwingen te onderdrukken wanneer we onbewerkte typen gebruiken.

En ongedefinieerde waarschuwingen worden genegeerd. Bijvoorbeeld,

@SuppressWarnings("someundefinedwarning")

Voorbeeld 3:@SuppressWarnings annotatievoorbeeld

class Main {
  @Deprecated
  public static void deprecatedMethod() { 
    System.out.println("Deprecated method"); 
  } 
  
  @SuppressWarnings("deprecated")
  public static void main(String args[]) {
    Main depObj = new Main();
    depObj. deprecatedMethod();
  }
}

Uitvoer

Deprecated method

Hier, deprecatedMethod() is gemarkeerd als verouderd en geeft compilerwaarschuwingen bij gebruik. Door de @SuppressWarnings("deprecated") . te gebruiken annotatie, kunnen we compilerwaarschuwingen vermijden.

4. @SafeVarargs

De @SafeVarargs annotatie stelt dat de geannoteerde methode of constructor geen onveilige bewerkingen uitvoert op zijn varargs (variabel aantal argumenten).

We kunnen deze annotatie alleen gebruiken voor methoden of constructors die niet kunnen worden overschreven. Dit komt omdat de methoden die ze overschrijven mogelijk onveilige bewerkingen uitvoeren.

Vóór Java 9 konden we deze annotatie alleen gebruiken voor definitieve of statische methoden, omdat ze niet kunnen worden overschreven. We kunnen deze annotatie nu ook voor privémethoden gebruiken.

Voorbeeld 4:@SafeVarargs annotatievoorbeeld

import java.util.*;

class Main {

  private void displayList(List<String>... lists) {
    for (List<String> list : lists) {
      System.out.println(list);
    }
  }

  public static void main(String args[]) {
    Main obj = new Main();

    List<String> universityList = Arrays.asList("Tribhuvan University", "Kathmandu University");
    obj.displayList(universityList);

    List<String> programmingLanguages = Arrays.asList("Java", "C");
    obj.displayList(universityList, programmingLanguages);
  }
}

Waarschuwingen

Type safety: Potential heap pollution via varargs parameter lists
Type safety: A generic array of List<String> is created for a varargs 
 parameter

Uitvoer

Note: Main.java uses unchecked or unsafe operations.
[Tribhuvan University, Kathmandu University]
[Tribhuvan University, Kathmandu University]
[Java, C]

Hier, List ... lists specificeert een argument met variabele lengte van het type List . Dit betekent dat de methode displayList() kan nul of meer argumenten hebben.

Het bovenstaande programma compileert zonder fouten maar geeft waarschuwingen wanneer @SafeVarargs annotatie wordt niet gebruikt.

Wanneer we @SafeVarargs . gebruiken annotatie in het bovenstaande voorbeeld,

@SafeVarargs
 private void displayList(List<String>... lists) { ... }

We krijgen dezelfde output, maar zonder enige waarschuwing. Niet-aangevinkte waarschuwingen worden ook onderdrukt wanneer we deze annotatie gebruiken.

5. @FunctionalInterface

Java 8 introduceerde voor het eerst deze @FunctionalInterface annotatie. Deze annotatie geeft aan dat de typedeclaratie waarop deze wordt gebruikt een functionele interface is. Een functionele interface kan maar één abstracte methode hebben.

Voorbeeld 5:@FunctionalInterface annotatievoorbeeld

@FunctionalInterface
public interface MyFuncInterface{
  public void firstMethod(); // this is an abstract method
}

Als we nog een abstracte methode toevoegen, laten we zeggen

@FunctionalInterface
public interface MyFuncInterface{
  public void firstMethod(); // this is an abstract method
  public void secondMethod(); // this throws compile error
}

Als we het programma nu uitvoeren, krijgen we de volgende waarschuwing:

Unexpected @FunctionalInterface annotation
@FunctionalInterface ^ MyFuncInterface is not a functional interface
multiple non-overriding abstract methods found in interface MyFuncInterface

Het is niet verplicht om @FunctionalInterface . te gebruiken annotatie. De compiler beschouwt elke interface die voldoet aan de functionele interfacedefinitie als een functionele interface.

We gebruiken deze annotatie om ervoor te zorgen dat de functionele interface slechts één abstracte methode heeft.

Het kan echter een willekeurig aantal standaard- en statische methoden hebben omdat ze een implementatie hebben.

@FunctionalInterface
public interface MyFuncInterface{
  public void firstMethod(); // this is an abstract method
  default void secondMethod() { ... } 
  default void thirdMethod() { ... } 
}

Aangepaste annotaties

Het is ook mogelijk om onze eigen aangepaste annotaties te maken.

De syntaxis is:

[Access Specifier] @interface<AnnotationName> {         
  DataType <Method Name>() [default value];
}

Dit is wat u moet weten over aangepaste annotaties:

Annotaties kunnen worden gemaakt met @interface gevolgd door de naam van de annotatie.
De annotatie kan elementen bevatten die op methoden lijken, maar ze hebben geen implementatie.
De standaardwaarde is optioneel. De parameters mogen geen null-waarde hebben.
Het retourtype van de methode kan primitief, enum, string, klassenaam of array van deze typen zijn.

Voorbeeld 6:Voorbeeld van aangepaste annotatie

@interface MyCustomAnnotation {
  String value() default "default value";
}

class Main {
  @MyCustomAnnotation(value = "programiz")
  public void method1() {
    System.out.println("Test method 1");
  }

  public static void main(String[] args) throws Exception {
    Main obj = new Main();
    obj.method1();
  }
}

Uitvoer

Test method 1

Meta-annotaties

Meta-annotaties zijn annotaties die worden toegepast op andere annotaties.

1. @Retentie

De @Retention annotatie specificeert het niveau tot waar de annotatie beschikbaar zal zijn.

De syntaxis is:

@Retention(RetentionPolicy)

Er zijn 3 soorten bewaarbeleid:

RetentionPolicy.SOURCE - De annotatie is alleen beschikbaar op bronniveau en wordt genegeerd door de compiler.
RetentionPolicy.CLASS - De annotatie is tijdens het compileren beschikbaar voor de compiler, maar wordt genegeerd door de Java Virtual Machine (JVM).
Retentiebeleid.RUNTIME - De annotatie is beschikbaar voor de JVM.

Bijvoorbeeld,

@Retention(RetentionPolicy.RUNTIME)
public @interface MyCustomAnnotation{ ... }

2. @Gedocumenteerd

Standaard zijn aangepaste annotaties niet opgenomen in de officiële Java-documentatie. Om onze annotatie in de Javadoc-documentatie op te nemen, gebruiken we de @Documented annotatie.

Bijvoorbeeld,

@Documented
public @interface MyCustomAnnotation{ ... }

3. @Doel

We kunnen een annotatie beperken die moet worden toegepast op specifieke doelen met behulp van de @Target annotatie.

De syntaxis is:

@Target(ElementType)

De ElementType kan een van de volgende typen hebben:

Elementtype	Doel
`ElementType.ANNOTATION_TYPE`	Annotatietype
`ElementType.CONSTRUCTOR`	Constructeurs
`ElementType.FIELD`	Velden
`ElementType.LOCAL_VARIABLE`	Lokale variabelen
`ElementType.METHOD`	Methoden
`ElementType.PACKAGE`	Pakket
`ElementType.PARAMETER`	Parameter
`ElementType.TYPE`	Elk klasse-element

Bijvoorbeeld,

@Target(ElementType.METHOD)
public @interface MyCustomAnnotation{ ... }

In dit voorbeeld hebben we het gebruik van deze annotatie beperkt tot alleen methoden.

Opmerking: Als het doeltype niet is gedefinieerd, kan de annotatie voor elk element worden gebruikt.

4. @Geërfd

Een annotatietype kan standaard niet worden overgenomen van een superklasse. Als we echter een annotatie van een superklasse naar een subklasse moeten erven, gebruiken we de @Inherited annotatie.

De syntaxis is:

@Inherited

Bijvoorbeeld,

@Inherited
public @interface MyCustomAnnotation { ... }

@MyCustomAnnotation
public class ParentClass{ ... }

public class ChildClass extends ParentClass { ... }

5. @Herhaalbaar

Een annotatie die is gemarkeerd met @Repeatable kan meerdere keren worden toegepast op dezelfde aangifte.

@Repeatable(Universities.class)
public @interface University {
  String name();
}

De waarde gedefinieerd in de @Repeatable annotatie is de containerannotatie. De containerannotatie heeft een variabele waarde van het matrixtype van de bovenstaande herhaalbare annotatie. Hier, Universities zijn het bevattende annotatietype.

public @interface Universities {
  University[] value();
}

Nu, de @University annotatie kan meerdere keren op dezelfde aangifte worden gebruikt.

@University(name = "TU")
@University(name = "KU")
private String uniName;

Als we de annotatiegegevens moeten ophalen, kunnen we de Reflection API gebruiken.

Om annotatiewaarden op te halen, gebruiken we getAnnotationsByType() of getAnnotations() methode gedefinieerd in de Reflection API.

Java-annotaties Java-logboekregistratie

Java