Fragen zum Interview mit Java Annotations (+ Antworten)

Dieser Artikel ist Teil einer Reihe: • Fragen zum Interview mit Java Collections

• Fragen zum Java Type System-Interview

• Fragen zum Java Concurrency-Interview (+ Antworten)

• Fragen zum Java-Klassenstruktur- und Initialisierungsinterview

• Fragen zum Java 8-Interview (+ Antworten)

• Speicherverwaltung in Java Interview Fragen (+ Antworten)

• Fragen zum Java Generics-Interview (+ Antworten)

• Fragen zum Java Flow Control-Interview (+ Antworten)

• Fragen zum Interview mit Java-Ausnahmen (+ Antworten)

• Fragen zum Java Annotations-Interview (+ Antworten) (aktueller Artikel) • Fragen zum Top Spring Framework-Interview

1. Einleitung

Anmerkungen gibt es seit Java 5, und heutzutage sind sie allgegenwärtige Programmierkonstrukte, mit denen der Code angereichert werden kann.

In diesem Artikel werden einige Fragen zu Anmerkungen behandelt. die oft in technischen Interviews gefragt werden und gegebenenfalls; Wir werden Beispiele implementieren, um ihre Antworten besser zu verstehen.

2. Fragen

Q1. Was sind Anmerkungen? Was sind ihre typischen Anwendungsfälle?

Anmerkungen sind Metadaten, die an Elemente des Quellcodes eines Programms gebunden sind und keinen Einfluss auf den Betrieb des von ihnen betriebenen Codes haben.

Ihre typischen Anwendungsfälle sind:

  • Informationen für den Compiler - Mit Anmerkungen kann der Compiler Fehler erkennen oder Warnungen unterdrücken
  • Verarbeitung zur Kompilierungs- und Bereitstellungszeit - Software-Tools können Anmerkungen verarbeiten und Code, Konfigurationsdateien usw. generieren.
  • Laufzeitverarbeitung - Anmerkungen können zur Laufzeit überprüft werden, um das Verhalten eines Programms anzupassen

Q2. Beschreiben einiger nützlicher Anmerkungen aus der Standardbibliothek.

Die Pakete java.lang und java.lang.annotation enthalten mehrere Anmerkungen. Zu den gebräuchlichsten gehören unter anderem:

  • @Override - Markiert, dass eine Methode ein in einer Oberklasse deklariertes Element überschreiben soll. Wenn die Methode nicht korrekt überschrieben wird, gibt der Compiler einen Fehler aus
  • @Deprecated - Gibt an, dass das Element veraltet ist und nicht verwendet werden sollte. Der Compiler gibt eine Warnung aus, wenn das Programm eine Methode, Klasse oder ein Feld verwendet, die mit dieser Anmerkung gekennzeichnet sind
  • @SuppressWarnings - Weist den Compiler an, bestimmte Warnungen zu unterdrücken. Am häufigsten verwendet, wenn eine Schnittstelle zu Legacy-Code besteht, der vor dem Erscheinen von Generika geschrieben wurde
  • @FunctionalInterface - eingeführt in Java 8, gibt an, dass die Typdeklaration eine funktionale Schnittstelle ist und deren Implementierung mithilfe eines Lambda-Ausdrucks bereitgestellt werden kann

Q3. Wie können Sie eine Anmerkung erstellen?

Anmerkungen sind eine Form einer Schnittstelle , wo die Schlüsselwort - Schnittstelle vorangeht @, und dessen Körper enthält Element Annotationstyp Erklärungen , die sich auf Verfahren sehr ähnlich aussehen:

public @interface SimpleAnnotation { String value(); int[] types(); }

Nachdem die Anmerkung definiert wurde, können Sie sie über Ihren Code verwenden:

@SimpleAnnotation(value = "an element", types = 1) public class Element { @SimpleAnnotation(value = "an attribute", types = { 1, 2 }) public Element nextElement; }

Beachten Sie, dass Sie beim Bereitstellen mehrerer Werte für Array-Elemente diese in Klammern setzen müssen.

Optional können Standardwerte angegeben werden, sofern sie für den Compiler konstante Ausdrücke sind:

public @interface SimpleAnnotation { String value() default "This is an element"; int[] types() default { 1, 2, 3 }; }

Jetzt können Sie die Anmerkung ohne diese Elemente verwenden:

@SimpleAnnotation public class Element { // ... }

Oder nur einige von ihnen:

@SimpleAnnotation(value = "an attribute") public Element nextElement;

Q4. Welche Objekttypen können aus einer Annotation Method Declaration zurückgegeben werden?

Der Rückgabetyp muss ein Grundelement, ein String , eine Klasse , eine Aufzählung oder ein Array eines der vorherigen Typen sein. Andernfalls gibt der Compiler einen Fehler aus.

Hier ist ein Beispielcode, der diesem Prinzip erfolgreich folgt:

enum Complexity { LOW, HIGH } public @interface ComplexAnnotation { Class value(); int[] types(); Complexity complexity(); }

Das nächste Beispiel kann nicht kompiliert werden, da Object kein gültiger Rückgabetyp ist:

public @interface FailingAnnotation { Object complexity(); }

Q5. Welche Programmelemente können kommentiert werden?

Anmerkungen können an mehreren Stellen im gesamten Quellcode angewendet werden. Sie können auf Deklarationen von Klassen, Konstruktoren und Feldern angewendet werden:

@SimpleAnnotation public class Apply { @SimpleAnnotation private String aField; @SimpleAnnotation public Apply() { // ... } }

Methoden und ihre Parameter:

@SimpleAnnotation public void aMethod(@SimpleAnnotation String param) { // ... }

Lokale Variablen, einschließlich einer Schleife und Ressourcenvariablen:

@SimpleAnnotation int i = 10; for (@SimpleAnnotation int j = 0; j < i; j++) { // ... } try (@SimpleAnnotation FileWriter writer = getWriter()) { // ... } catch (Exception ex) { // ... }

Andere Anmerkungsarten:

@SimpleAnnotation public @interface ComplexAnnotation { // ... }

And even packages, through the package-info.java file:

@PackageAnnotation package com.baeldung.interview.annotations;

As of Java 8, they can also be applied to the use of types. For this to work, the annotation must specify an @Target annotation with a value of ElementType.USE:

@Target(ElementType.TYPE_USE) public @interface SimpleAnnotation { // ... }

Now, the annotation can be applied to class instance creation:

new @SimpleAnnotation Apply();

Type casts:

aString = (@SimpleAnnotation String) something;

Implements clause:

public class SimpleList implements @SimpleAnnotation List { // ... }

And throws clause:

void aMethod() throws @SimpleAnnotation Exception { // ... }

Q6. Is There a Way to Limit the Elements in Which an Annotation Can Be Applied?

Yes, the @Target annotation can be used for this purpose. If we try to use an annotation in a context where it is not applicable, the compiler will issue an error.

Here's an example to limit the usage of the @SimpleAnnotation annotation to field declarations only:

@Target(ElementType.FIELD) public @interface SimpleAnnotation { // ... }

We can pass multiple constants if we want to make it applicable in more contexts:

@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PACKAGE })

We can even make an annotation so it cannot be used to annotate anything. This may come in handy when the declared types are intended solely for use as a member type in complex annotations:

@Target({}) public @interface NoTargetAnnotation { // ... }

Q7. What Are Meta-Annotations?

Are annotations that apply to other annotations.

All annotations that aren't marked with @Target, or are marked with it but include ANNOTATION_TYPE constant are also meta-annotations:

@Target(ElementType.ANNOTATION_TYPE) public @interface SimpleAnnotation { // ... }

Q8. What Are Repeating Annotations?

These are annotations that can be applied more than once to the same element declaration.

For compatibility reasons, since this feature was introduced in Java 8, repeating annotations are stored in a container annotation that is automatically generated by the Java compiler. For the compiler to do this, there are two steps to declared them.

First, we need to declare a repeatable annotation:

@Repeatable(Schedules.class) public @interface Schedule { String time() default "morning"; }

Then, we define the containing annotation with a mandatory value element, and whose type must be an array of the repeatable annotation type:

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

Now, we can use @Schedule multiple times:

@Schedule @Schedule(time = "afternoon") @Schedule(time = "night") void scheduledMethod() { // ... }

Q9. How Can You Retrieve Annotations? How Does This Relate to Its Retention Policy?

You can use the Reflection API or an annotation processor to retrieve annotations.

The @Retention annotation and its RetentionPolicy parameter affect how you can retrieve them. There are three constants in RetentionPolicy enum:

  • RetentionPolicy.SOURCE – makes the annotation to be discarded by the compiler but annotation processors can read them
  • RetentionPolicy.CLASS – indicates that the annotation is added to the class file but not accessible through reflection
  • RetentionPolicy.RUNTIME –Annotations are recorded in the class file by the compiler and retained by the JVM at runtime so that they can be read reflectively

Here's an example code to create an annotation that can be read at runtime:

@Retention(RetentionPolicy.RUNTIME) public @interface Description { String value(); }

Now, annotations can be retrieved through reflection:

Description description = AnnotatedClass.class.getAnnotation(Description.class); System.out.println(description.value());

An annotation processor can work with RetentionPolicy.SOURCE, this is described in the article Java Annotation Processing and Creating a Builder.

RetentionPolicy.CLASS is usable when you're writing a Java bytecode parser.

Q10. Will the Following Code Compile?

@Target({ ElementType.FIELD, ElementType.TYPE, ElementType.FIELD }) public @interface TestAnnotation { int[] value() default {}; }

No. It's a compile-time error if the same enum constant appears more than once in an @Target annotation.

Removing the duplicate constant will make the code to compile successfully:

@Target({ ElementType.FIELD, ElementType.TYPE})

Q11. Is It Possible to Extend Annotations?

No. Annotations always extend java.lang.annotation.Annotation, as stated in the Java Language Specification.

If we try to use the extends clause in an annotation declaration, we'll get a compilation error:

public @interface AnAnnotation extends OtherAnnotation { // Compilation error }

Conclusion

In diesem Artikel haben wir einige der häufig gestellten Fragen behandelt, die in technischen Interviews für Java-Entwickler zu Anmerkungen gestellt wurden. Dies ist keineswegs eine vollständige Liste und sollte nur als Beginn weiterer Forschungen betrachtet werden.

Wir von Baeldung wünschen Ihnen viel Erfolg bei den kommenden Interviews.

Weiter » Top Spring Framework Interview Fragen « Vorherige Java Exceptions Interview Fragen (+ Antworten)