Java-anteckningar (med exempel)

I denna handledning lär vi oss vad anteckningar är, olika Java-anteckningar och hur man använder dem med hjälp av exempel.

Java-anteckningar är metadata (data om data) för vår programkällkod.

De ger ytterligare information om programmet till kompilatorn men ingår inte i själva programmet. Dessa anteckningar påverkar inte genomförandet av det kompilerade programmet.

Kommentarer börjar med @. Dess syntax är:

 @AnnotationName

Låt oss ta ett exempel på @Overrideanteckningar.

De @Overrideantecknings anger att den metod som har märkts med denna anteckning åsidosätter metoden enligt super med samma metod namn, returtyp och parameterlistan.

Det är inte obligatoriskt att använda @Overridevid åsidosättande av en metod. Men om vi använder det ger kompilatorn ett fel om något är fel (t.ex. fel parametertyp) medan metoden åsidosätts.

Exempel 1: @Override Annotation Exempel

 class Animal ( public void displayInfo() ( System.out.println("I am an animal."); ) ) class Dog extends Animal ( @Override public void displayInfo() ( System.out.println("I am a dog."); ) ) class Main ( public static void main(String() args) ( Dog d1 = new Dog(); d1.displayInfo(); ) )

Produktion

 Jag är en hund.

I detta exempel är metoden displayInfo()närvarande i både superklassen Animal och subclass Dog. När denna metod kallas kallas metoden för underklassen istället för metoden i superklassen.

Kommentarsformat

Kommentarer kan också innehålla element (medlemmar / attribut / parametrar).

1. Markörnoteringar

Marköranteckningar innehåller inte medlemmar / element. Den används endast för att markera en deklaration.

Dess syntax är:

 @Annotationsnamn ()

Eftersom dessa anteckningar inte innehåller element kan parenteser uteslutas. Till exempel,

 @Åsidosätta

2. Anmärkningar för enstaka element

En enstaka elementanteckning innehåller bara ett element.

Dess syntax är:

 @AnnotationName (elementName = "elementValue")

Om det bara finns ett element är det en konvention att namnge det elementet som värde.

 @AnnotationName (value = "elementValue")

I detta fall kan elementnamnet också uteslutas. Elementets namn kommer att vara värde som standard.

 @AnnotationName ("elementValue")

3. Kommentarer om flera element

Dessa anteckningar innehåller flera element åtskilda av kommatecken.

Dess syntax är:

 @AnnotationName (element1 = "värde1", element2 = "värde2")

Kommentarplacering

Varje deklaration kan markeras med anteckningar genom att placera den ovanför deklarationen. Från och med Java 8 kan anteckningar också placeras före en typ.

1. Ovanstående deklarationer

Som nämnts ovan kan Java-anteckningar placeras ovanför klass-, metod-, gränssnitts-, fält- och andra programelementdeklarationer.

Exempel 2: @SuppressWarnings Annotation Exempel

 import java.util.*; class Main ( @SuppressWarnings("unchecked") static void wordsList() ( ArrayList wordList = new ArrayList(); // This causes an unchecked warning wordList.add("programiz"); System.out.println("Word list => " + wordList); ) public static void main(String args()) ( wordsList(); ) )

Produktion

 Ordlista => (programiz)

Om ovanstående program kompileras utan att använda @SuppressWarnings("unchecked")anteckningen kommer kompilatorn fortfarande att kompilera programmet men det kommer att ge varningar som:

Main.java använder okontrollerade eller osäkra åtgärder. Ordlista => (programiz)

Vi får varningen

 Main.java använder okontrollerade eller osäkra åtgärder

på grund av följande uttalande.

 ArrayList wordList = new ArrayList();

This is because we haven't defined the generic type of the array list. We can fix this warning by specifying generics inside angle brackets .

 ArrayList wordList = new ArrayList();

2. Type annotations

Before Java 8, annotations could be applied to declarations only. Now, type annotations can be used as well. This means that we can place annotations wherever we use a type.

Constructor invocations

 new @Readonly ArrayList()

Type definitions

 @NonNull String str;

This declaration specifies non-null variable str of type String to avoid NullPointerException.

 @NonNull List newList;

This declaration specifies a non-null list of type String.

 List newList;

This declaration specifies a list of non-null values of type String.

Type casts 

 newStr = (@NonNull String) str;

extends and implements clause 

 class Warning extends @Localized Message

throws clause 

 public String readMethod() throws @Localized IOException

Type annotations enable Java code to be analyzed better and provide even stronger type checks.

Types of Annotations

1. Predefined annotations

  1. @Deprecated
  2. @Override
  3. @SuppressWarnings
  4. @SafeVarargs
  5. @FunctionalInterface

2. Meta-annotations

  1. @Retention
  2. @Documented
  3. @Target
  4. @Inherited
  5. @Repeatable

3. Custom annotations

These annotation types are described in detail in the Java Annotation Types tutorial.

Use of Annotations

  • Compiler instructions - Annotations can be used for giving instructions to the compiler, detect errors or suppress warnings. The built-in annotations @Deprecated, @Override, @SuppressWarnings are used for these purposes.
  • Compile-time instructions - Compile-time instructions provided by these annotations help the software build tools to generate code, XML files and many more.
  • Runtime-instruktioner - Vissa kommentarer kan definieras för att ge instruktioner till programmet vid körning. Dessa anteckningar nås med Java Reflection.

Intressanta artiklar...