TOC

Java Annotations Interview-Fragen (+ Antworten)

Fragen im Vorstellungsgespräch zu Java Annotations (+ Antworten)

1. Einführung

Anmerkungen gibt es seit Java 5 und heutzutage sind sie allgegenwärtige Programmierkonstrukte, mit denen sich der Code anreichern lässt.

In diesem Artikel werden einige der Fragen zu Anmerkungen besprochen. 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 die Funktionsweise des Codes haben, den sie ausführen.

Ihre typischen Anwendungsfälle sind:

  • Information for the compiler - Mit Anmerkungen kann der Compiler Fehler erkennen oder Warnungen unterdrücken

  • Compile-time and deployment-time processing - Software-Tools können Anmerkungen verarbeiten und Code, Konfigurationsdateien usw. generieren.

  • Runtime processing - Annotationen können zur Laufzeit überprüft werden, um das Verhalten eines Programms anzupassen

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

Es gibt mehrere Anmerkungen in den Paketenjava.lang undjava.lang.annotation. Die häufigsten umfassen, ohne darauf beschränkt zu sein:

  • @Override – markiert, dass eine Methode ein in einer Oberklasse deklariertes Element überschreiben soll. Wenn die Methode nicht ordnungsgemäß überschrieben wird, gibt der Compiler einen Fehler aus

  • @Deprecated - zeigt an, dass das Element veraltet ist und nicht verwendet werden sollte. Der Compiler gibt eine Warnung aus, wenn das Programm eine mit dieser Anmerkung gekennzeichnete Methode, Klasse oder ein Feld verwendet

  • @SuppressWarnings - Weist den Compiler an, bestimmte Warnungen zu unterdrücken. Am häufigsten verwendet, wenn eine Schnittstelle mit älterem Code erstellt wurde, der vor dem Erscheinen von Generika geschrieben wurde

  • @FunctionalInterface - in Java 8 eingeführt, 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, bei der dem Schlüsselwortinterface@, vorangestellt ist und deren Hauptteilannotation type element-Deklarationen enthält, die Methoden sehr ähnlich sehen: 

public @interface SimpleAnnotation {
    String value();

    int[] types();
}

Nachdem Sie die Annotation definiert haben, 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 bei der Angabe mehrerer Werte für Array-Elemente diese in eckige 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 Annotation 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,String,Class,Enum 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, daObject kein gültiger Rückgabetyp ist: 

public @interface FailingAnnotation {
    Object complexity();
}

Q5. Welche Programmelemente können kommentiert werden?

Anmerkungen können im gesamten Quellcode an mehreren Stellen angebracht 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 Anmerkungstypen: 

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

Und sogar Pakete über diepackage-info.java-Datei: 

@PackageAnnotation
package com.example.interview.annotations;

Ab Java 8 können sie auch auf dieuse von Typen angewendet werden. Damit dies funktioniert, muss die Annotation eine@Target-Annotation mit einem Wert vonElementType.USE angeben: 

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

Jetzt kann die Annotation auf die Erstellung von Klasseninstanzen angewendet werden: 

new @SimpleAnnotation Apply();

Geben Sie casts ein: 

aString = (@SimpleAnnotation String) something;

Implements-Klausel: 

public class SimpleList
  implements @SimpleAnnotation List<@SimpleAnnotation T> {
    // ...
}

Undthrows Klausel: 

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

Q6. Gibt es eine Möglichkeit, die Elemente zu begrenzen, in denen eine Anmerkung angewendet werden kann?

Ja, die Annotation@Targetkann für diesen Zweck verwendet werden. Wenn wir versuchen, eine Anmerkung in einem Kontext zu verwenden, in dem sie nicht anwendbar ist, gibt der Compiler einen Fehler aus.

Hier ist ein Beispiel, um die Verwendung der Annotation@SimpleAnnotationnur auf Felddeklarationen zu beschränken: 

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

Wir können mehrere Konstanten übergeben, wenn wir dies in weiteren Kontexten anwenden möchten: 

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

Wir können sogar eine Anmerkung machen, so dass es nicht verwendet werden kann, um irgendetwas zu kommentieren. Dies kann nützlich sein, wenn die deklarierten Typen ausschließlich als Elementtyp in komplexen Annotationen verwendet werden sollen: 

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

Q7. Was sind Meta-Annotationen?

Sind Anmerkungen, die für andere Anmerkungen gelten.

Alle Annotationen, die nicht mit@Target, markiert sind oder damit markiert sind, aber die KonstanteANNOTATION_TYPE enthalten, sind ebenfalls Meta-Annotationen: 

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

Q8. Was sind wiederholte Anmerkungen?

Hierbei handelt es sich um Anmerkungen, die mehrmals auf dieselbe Elementdeklaration angewendet werden können.

Aus Kompatibilitätsgründen werden seit der Einführung dieser Funktion in Java 8 wiederholte Anmerkungen incontainer annotation gespeichert, die vom Java-Compiler automatisch generiert werden. Dazu müssen Sie vom Compiler in zwei Schritten deklariert werden.

Zuerst müssen wir eine wiederholbare Anmerkung deklarieren: 

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

Anschließend definieren wir die enthaltende Annotation mit einem obligatorischenvalue-Element, dessen Typ ein Array des wiederholbaren Annotationstyps sein muss: 

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

Jetzt können wir @Schedule mehrmals verwenden: 

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

Q9. Wie können Sie Anmerkungen abrufen? Wie hängt dies mit der Aufbewahrungsrichtlinie zusammen?

Sie können die Reflection-API oder einen Anmerkungsprozessor verwenden, um Anmerkungen abzurufen.

Die Annotation@Retention und der ParameterRetentionPolicy beeinflussen, wie Sie sie abrufen können. Es gibt drei Konstanten inRetentionPolicy Aufzählung:

  • RetentionPolicy.SOURCE - Lässt die Annotation vom Compiler verwerfen, aber Annotationsprozessoren können sie lesen

  • RetentionPolicy.CLASS - gibt an, dass die Anmerkung zur Klassendatei hinzugefügt wurde, aber nicht durch Reflektion zugänglich ist

  • RetentionPolicy.RUNTIME –Anmerkungen werden vom Compiler in der Klassendatei aufgezeichnet und zur Laufzeit von der JVM beibehalten, damit sie reflektierend gelesen werden können

Hier ist ein Beispielcode zum Erstellen einer Anmerkung, die zur Laufzeit gelesen werden kann: 

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

Jetzt können Anmerkungen durch Reflektion abgerufen werden: 

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

Ein Annotationsprozessor kann mitRetentionPolicy.SOURCE arbeiten, dies wird im ArtikelJava Annotation Processing and Creating a Builder beschrieben.

RetentionPolicy.CLASS kann verwendet werden, wenn Sie einen Java-Bytecode-Parser schreiben.

Q10. Wird der folgende Code kompiliert? 

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

No. Es ist ein Fehler bei der Kompilierung, wenn dieselbe Aufzählungskonstante mehr als einmal in der Annotation von@Targetvorkommt.

Wenn Sie die doppelte Konstante entfernen, wird der Code erfolgreich kompiliert: 

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

Q11. Ist es möglich, Anmerkungen zu erweitern?

No. Anmerkungen verlängern immerjava.lang.annotation.Annotation,, wie inJava Language Specification angegeben.

Wenn wir versuchen, dieextends-Klausel in einer Anmerkungsdeklaration zu verwenden, wird ein Kompilierungsfehler angezeigt: 

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

Fazit

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

Wir wünschen Ihnen zum Beispiel viel Erfolg bei bevorstehenden Interviews.

Related