Vragen tijdens sollicitatiegesprek met Java-annotaties (+ antwoorden)

Dit artikel maakt deel uit van een reeks: • Interviewvragen over Java Collections

• Vragen over het Java Type System-interview

• Vragen over Java Concurrency-sollicitatiegesprekken (+ antwoorden)

• Vragen over Java-klassenstructuur en initialisatie

• Java 8 sollicitatievragen (+ antwoorden)

• Geheugenbeheer in Java-interviewvragen (+ antwoorden)

• Java Generics sollicitatievragen (+ antwoorden)

• Vragen over Java Flow Control-interview (+ antwoorden)

• Interviewvragen over Java-uitzonderingen (+ antwoorden)

• Java-annotaties interviewvragen (+ antwoorden) (huidig ​​artikel) • Top Spring Framework interviewvragen

1. Inleiding

Annotaties bestaan ​​al sinds Java 5 en tegenwoordig zijn het alomtegenwoordige programmeerconstructies waarmee de code kan worden verrijkt.

In dit artikel bespreken we enkele vragen met betrekking tot annotaties; die vaak worden gevraagd tijdens technische interviews en, waar van toepassing; we zullen voorbeelden implementeren om hun antwoorden beter te begrijpen.

2. Vragen

V1. Wat zijn annotaties? Wat zijn hun typische gebruikssituaties?

Annotaties zijn metagegevens die zijn gebonden aan elementen van de broncode van een programma en hebben geen effect op de werking van de code die ze gebruiken.

Hun typische gebruikssituaties zijn:

  • Informatie voor de compiler - met annotaties kan de compiler fouten detecteren of waarschuwingen onderdrukken
  • Verwerking in compilatietijd en implementatietijd - softwaretools kunnen annotaties verwerken en code, configuratiebestanden enz. Genereren.
  • Runtime-verwerking - annotaties kunnen tijdens runtime worden onderzocht om het gedrag van een programma aan te passen

Q2. Beschrijf enkele nuttige aantekeningen uit de standaardbibliotheek.

Er zijn verschillende annotaties in het java.lang en java.lang.annotation pakketten, de meest voorkomende omvatten, maar zijn niet beperkt tot:

  • @Override - geeft aan dat een methode bedoeld is om een ​​element dat in een superklasse is gedeclareerd, te overschrijven. Als het de methode niet correct overschrijft, zal de compiler een foutmelding geven
  • @Verouderd - geeft aan dat het element verouderd is en niet gebruikt mag worden. De compiler geeft een waarschuwing als het programma een methode, klasse of veld gebruikt die met deze annotatie is gemarkeerd
  • @SuppressWarnings - vertelt de compiler om specifieke waarschuwingen te onderdrukken. Meestal gebruikt bij het communiceren met oude code die is geschreven voordat generieke codes verschenen
  • @FunctioneleInterface - geïntroduceerd in Java 8, geeft aan dat de typeaangifte een functionele interface is en waarvan de implementatie kan worden geleverd met behulp van een Lambda-expressie

Q3. Hoe kunt u een aantekening maken?

Annotaties zijn een vorm van een interface waarin het trefwoord koppel wordt voorafgegaan door @, en wiens lichaam bevat annotatietype-element declaraties die erg lijken op methoden:

openbare @interface SimpleAnnotation {String-waarde (); int [] types (); }

Nadat de annotatie is gedefinieerd, kunt u deze gaan gebruiken via uw code:

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

Houd er rekening mee dat wanneer u meerdere waarden opgeeft voor array-elementen, u deze tussen haakjes moet plaatsen.

Optioneel kunnen standaardwaarden worden opgegeven zolang het constante uitdrukkingen zijn voor de compiler:

public @interface SimpleAnnotation {String waarde () standaard "Dit is een element"; int [] types () standaard {1, 2, 3}; }

Nu kunt u de annotatie gebruiken zonder deze elementen:

@SimpleAnnotation openbaar klasse-element {// ...}

Of slechts enkele:

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

V4. Welke objecttypen kunnen worden geretourneerd uit een annotatiemethode-declaratie?

Het retourtype moet een primitief zijn, Draad, Klasse, Enum, of een array van een van de voorgaande typen. Anders genereert de compiler een fout.

Hier is een voorbeeldcode die dit principe met succes volgt:

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

Het volgende voorbeeld kan sindsdien niet worden gecompileerd Voorwerp is geen geldig retourtype:

public @interface FailingAnnotation {Object complexity (); }

V5. Welke programma-elementen kunnen worden geannoteerd?

Annotaties kunnen op verschillende plaatsen in de broncode worden toegepast. Ze kunnen worden toegepast op declaraties van klassen, constructors en velden:

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

Methoden en hun parameters:

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

Lokale variabelen, waaronder een lus en bronvariabelen:

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

Andere typen annotaties:

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

En zelfs pakketten, via de package-info.java het dossier:

@PackageAnnotation pakket com.baeldung.interview.annotations;

Vanaf Java 8 kunnen ze ook worden toegepast op het gebruik soorten. Om dit te laten werken, moet de annotatie een @Doelwit annotatie met een waarde van ElementType.USE:

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

Nu kan de annotatie worden toegepast op het maken van een klasse-instantie:

nieuwe @SimpleAnnotation Apply ();

Type afgietsels:

aString = (@SimpleAnnotation String) iets;

Implementeert clausule:

openbare klasse SimpleList implementeert @SimpleAnnotation List {// ...}

En gooit clausule:

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

V6. Is er een manier om de elementen waarin een annotatie kan worden toegepast, te beperken?

Ja de @Doelwit annotatie kan hiervoor worden gebruikt. Als we een annotatie proberen te gebruiken in een context waarin deze niet van toepassing is, geeft de compiler een foutmelding.

Hier is een voorbeeld om het gebruik van de @SimpleAnnotation annotatie alleen voor veldaangiften:

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

We kunnen meerdere constanten doorgeven als we deze toepasbaar willen maken in meer contexten:

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

We kunnen zelfs een annotatie maken, zodat deze niet kan worden gebruikt om iets te annoteren. Dit kan handig zijn als de gedeclareerde typen uitsluitend bedoeld zijn voor gebruik als ledentype in complexe annotaties:

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

V7. Wat zijn meta-annotaties?

Zijn annotaties die van toepassing zijn op andere annotaties.

Alle annotaties die niet zijn gemarkeerd met @Doelwit, of zijn ermee gemarkeerd, maar bevatten ANNOTATION_TYPE constant zijn ook meta-annotaties:

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

V8. Wat zijn herhalende annotaties?

Dit zijn annotaties die meerdere keren op dezelfde elementdeclaratie kunnen worden toegepast.

Om compatibiliteitsredenen worden herhalende annotaties opgeslagen in een container annotatie dat automatisch wordt gegenereerd door de Java-compiler. Om de compiler dit te laten doen, zijn er twee stappen om ze te declareren.

Eerst moeten we een herhaalbare annotatie declareren:

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

Vervolgens definiëren we de bevattende annotatie met een verplichte waarde element, en waarvan het type een array van het herhaalbare annotatietype moet zijn:

openbare @interface Schedules {Schedule [] waarde (); }

Nu kunnen we @Schedule meerdere keren gebruiken:

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

V9. Hoe kunt u annotaties ophalen? Hoe verhoudt dit zich tot het bewaarbeleid?

U kunt de Reflection API of een annotatieprocessor gebruiken om annotaties op te halen.

De @Retentie annotatie en zijn Retentiebeleid parameter bepalen hoe u ze kunt ophalen. Er zijn drie constanten in Retentiebeleid opsomming:

  • Retentiebeleid BRON - zorgt ervoor dat de annotatie wordt weggegooid door de compiler, maar annotatieprocessors kunnen ze lezen
  • RetentionPolicy.CLASS - geeft aan dat de annotatie is toegevoegd aan het klassenbestand maar niet toegankelijk is via reflectie
  • RetentionPolicy.RUNTIME –Annotaties worden door de compiler in het klassenbestand opgenomen en tijdens runtime door de JVM bewaard, zodat ze reflectief kunnen worden gelezen

Hier is een voorbeeldcode om een ​​annotatie te maken die tijdens runtime kan worden gelezen:

@Retention (RetentionPolicy.RUNTIME) public @interface Beschrijving {Stringwaarde (); }

Nu kunnen annotaties worden opgehaald door middel van reflectie:

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

Een annotatieprocessor kan werken met Retentiebeleid BRON, wordt dit beschreven in het artikel Java-annotatieverwerking en het maken van een builder.

RetentionPolicy.CLASS is bruikbaar wanneer u een Java-bytecode-parser schrijft.

V10. Zal de volgende code worden gecompileerd?

@Target ({ElementType.FIELD, ElementType.TYPE, ElementType.FIELD}) openbaar @interface TestAnnotation {int [] waarde () standaard {}; }

Nee. Het is een compilatietijdfout als dezelfde enumconstante meer dan eens voorkomt in een @Doelwit annotatie.

Als u de dubbele constante verwijdert, wordt de code succesvol gecompileerd:

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

V11. Is het mogelijk om annotaties uit te breiden?

Nee. Annotaties worden altijd verlengd java.lang.annotation.Annotation, zoals vermeld in de Java-taalspecificatie.

Als we proberen de strekt zich uit clausule in een annotatieverklaring, krijgen we een compilatiefout:

public @interface AnAnnotation breidt OtherAnnotation {// Compilatiefout} uit

Conclusie

In dit artikel hebben we enkele van de veelgestelde vragen behandeld die in technische interviews voor Java-ontwikkelaars verschijnen, met betrekking tot annotaties. Dit is geenszins een uitputtende lijst en mag alleen worden beschouwd als het begin van verder onderzoek.

Wij, bij Baeldung, wensen u veel succes bij de komende interviews.

De volgende » Top Spring Framework interviewvragen « Vorige interviewvragen over Java-uitzonderingen (+ antwoorden)