Domande di intervista sulle annotazioni Java (+ risposte)

Questo articolo fa parte di una serie: • Domande di intervista sulle raccolte Java

• Domande di intervista sul sistema di tipo Java

• Domande di intervista sulla concorrenza Java (+ risposte)

• Struttura delle classi Java e domande di colloquio sull'inizializzazione

• Domande di intervista Java 8 (+ risposte)

• Gestione della memoria in Java Intervista Domande (+ risposte)

• Domande di intervista su Java Generics (+ risposte)

• Domande di intervista sul controllo del flusso Java (+ risposte)

• Domande di intervista sulle eccezioni Java (+ risposte)

• Java Annotations Interview Questions (+ Answers) (articolo corrente) • Top Spring Framework Interview Questions

1. Introduzione

Le annotazioni esistono da Java 5 e al giorno d'oggi sono costrutti di programmazione onnipresenti che consentono di arricchire il codice.

In questo articolo, esamineremo alcune delle domande relative alle annotazioni; che vengono spesso richiesti durante i colloqui tecnici e, se del caso implementeremo esempi per comprendere meglio le loro risposte.

2. Domande

Q1. Cosa sono le annotazioni? Quali sono i loro casi d'uso tipici?

Le annotazioni sono metadati legati agli elementi del codice sorgente di un programma e non hanno alcun effetto sul funzionamento del codice che operano.

I loro casi d'uso tipici sono:

  • Informazioni per il compilatore : con le annotazioni, il compilatore può rilevare errori o sopprimere gli avvisi
  • Elaborazione in fase di compilazione e in fase di distribuzione : gli strumenti software possono elaborare annotazioni e generare codice, file di configurazione, ecc.
  • Elaborazione in runtime : le annotazioni possono essere esaminate in fase di runtime per personalizzare il comportamento di un programma

Q2. Descrivi alcune utili annotazioni dalla libreria standard.

Ci sono diverse annotazioni nei pacchetti java.lang e java.lang.annotation , le più comuni includono ma non sono limitate a:

  • @Override: indica che un metodo ha lo scopo di sovrascrivere un elemento dichiarato in una superclasse. Se non riesce a sovrascrivere correttamente il metodo, il compilatore emetterà un errore
  • @Deprecated : indica che l'elemento è deprecato e non deve essere utilizzato. Il compilatore emetterà un avviso se il programma utilizza un metodo, una classe o un campo contrassegnato con questa annotazione
  • @SuppressWarnings - dice al compilatore di sopprimere avvisi specifici. Più comunemente usato quando si interfaccia con codice legacy scritto prima della comparsa dei generici
  • @FunctionalInterface - introdotto in Java 8, indica che la dichiarazione del tipo è un'interfaccia funzionale e la cui implementazione può essere fornita utilizzando un'espressione Lambda

Q3. Come puoi creare un'annotazione?

Annotazioni sono una forma di interfaccia in cui la parola interfaccia è preceduto da @, e il cui corpo contiene tipo annotazione elemento dichiarazioni che sembrano molto simile ai metodi:

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

Dopo che l'annotazione è stata definita, puoi iniziare a usarla tramite il tuo codice:

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

Si noti che, quando si forniscono più valori per gli elementi dell'array, è necessario racchiuderli tra parentesi.

Facoltativamente, è possibile fornire valori predefiniti purché siano espressioni costanti per il compilatore:

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

Ora puoi usare l'annotazione senza quegli elementi:

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

O solo alcuni di loro:

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

Q4. Quali tipi di oggetto possono essere restituiti da una dichiarazione del metodo di annotazione?

Il tipo restituito deve essere una primitiva, String , Class , Enum o una matrice di uno dei tipi precedenti. In caso contrario, il compilatore genererà un errore.

Ecco un codice di esempio che segue con successo questo principio:

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

Il prossimo esempio non verrà compilato poiché Object non è un tipo restituito valido:

public @interface FailingAnnotation { Object complexity(); }

Q5. Quali elementi del programma possono essere annotati?

Le annotazioni possono essere applicate in diversi punti del codice sorgente. Possono essere applicati a dichiarazioni di classi, costruttori e campi:

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

Metodi e loro parametri:

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

Variabili locali, inclusi un ciclo e variabili di risorse:

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

Altri tipi di annotazioni:

@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 questo articolo, abbiamo coperto alcune delle domande frequenti che appaiono nelle interviste tecniche per gli sviluppatori Java, riguardanti le annotazioni. Questo non è affatto un elenco esaustivo e dovrebbe essere considerato solo come l'inizio di ulteriori ricerche.

Noi di Baeldung vi auguriamo successo in tutte le prossime interviste.

Successivo » Domande principali per l'intervista su Spring Framework « Domande sull'intervista precedente su Java Exceptions (+ risposte)