streamalism.org

Denne artikel er en del af en serie: • Interviewsspørgsmål om Java Collections

• Spørgsmål om Java Type System Interview

• Java-spørgsmål om samtidige samtaler (+ svar)

• Interviewspørgsmål om Java-klassestruktur og initialisering

• Java 8 interviewspørgsmål (+ svar)

• Hukommelsesstyring i Java Interview-spørgsmål (+ svar)

• Interviews med Java Generics (+ svar)

• Interviewspørgsmål til Java Flow Control (+ svar)

• Spørgsmål om Java-undtagelser (+ svar)

• Spørgsmål om Java-annotationer (+ svar) (nuværende artikel) • Topspørgsmål om forårets rammeinterview

1. Introduktion

Kommentarer har eksisteret siden Java 5, og i dag er de allestedsnærværende programmeringskonstruktioner, der tillader berigelse af koden.

I denne artikel gennemgår vi nogle af spørgsmålene vedrørende annoteringer; der ofte bliver spurgt om tekniske interviews og, hvor det er relevant; Vi implementerer eksempler for bedre at forstå deres svar.

2. Spørgsmål

Q1. Hvad er kommentarer? Hvad er deres typiske brugssager?

Kommentarer er metadata bundet til elementer i kildekoden til et program og har ingen indflydelse på driften af ​​den kode, de bruger.

Deres typiske anvendelsestilfælde er:

• Information til kompilatoren - med annoteringer kan compileren registrere fejl eller undertrykke advarsler
• Compile-time og deployment-time-behandling - softwareværktøjer kan behandle annoteringer og generere kode, konfigurationsfiler osv.
• Runtime-behandling - Kommentarer kan undersøges ved kørsel for at tilpasse et programs opførsel

Q2. Beskriv nogle nyttige kommentarer fra Standardbiblioteket.

Der er flere kommentarer i java.lang og java.lang.annotation pakker, de mere almindelige inkluderer, men ikke begrænset til:

• @Override - markerer, at en metode er beregnet til at tilsidesætte et element, der er erklæret i en superklasse. Hvis den ikke tilsidesætter metoden korrekt, udsteder compileren en fejl
• @Forældet - angiver, at elementet er udfaset og ikke bør bruges. Compileren udsender en advarsel, hvis programmet bruger en metode, klasse eller felt markeret med denne kommentar
• @SuppressWarnings - beder kompilatoren om at undertrykke specifikke advarsler. Mest brugt ved grænseflade med ældre kode skrevet før generiske optrædener
• @FunktionelInterface - introduceret i Java 8, angiver, at typedeklarationen er en funktionel grænseflade, og hvis implementering kan leveres ved hjælp af et Lambda-udtryk

Q3. Hvordan kan du oprette en kommentar?

Kommentarer er en form for en grænseflade, hvor nøgleordet interface forud for @, og hvis krop indeholder annotationstypeelement erklæringer, der ligner meget metoder:

public @interface SimpleAnnotation {Strengværdi (); int [] typer (); }

Når kommentaren er defineret, kan du begynde at bruge den ind gennem din kode:

@SimpleAnnotation (værdi = "et element", types = 1) public class Element {@SimpleAnnotation (value = "en attribut", types = {1, 2}) public Element nextElement; }

Bemærk, at når du angiver flere værdier for matrixelementer, skal du omslutte dem i parentes.

Valgfrit kan standardværdier leveres, så længe de er konstante udtryk for compileren:

public @interface SimpleAnnotation {Strengværdi () standard "Dette er et element"; int [] typer () standard {1, 2, 3}; }

Nu kan du bruge kommentaren uden disse elementer:

@SimpleAnnotation offentlig klasse Element {// ...}

Eller kun nogle af dem:

@SimpleAnnotation (værdi = "en attribut") offentlig Element nextElement;

Q4. Hvilke objekttyper kan returneres fra en erklæring om annoteringsmetoder?

Returtypen skal være primitiv, Snor, Klasse, Enumeller en matrix af en af ​​de foregående typer. Ellers kaster compileren en fejl.

Her er en eksempelkode, der med succes følger dette princip:

enum Complexity {LOW, HIGH} public @interface ComplexAnnotation {Klasseværdi (); int [] typer (); Kompleksitetskompleksitet (); }

Det næste eksempel kan ikke kompileres siden Objekt er ikke en gyldig returtype:

public @interface FailingAnnotation {Objektets kompleksitet (); }

Q5. Hvilke programelementer kan kommenteres?

Kommentarer kan anvendes flere steder i hele kildekoden. De kan anvendes på erklæringer om klasser, konstruktører og felter:

@SimpleAnnotation offentlig klasse Anvend {@SimpleAnnotation private String aField; @SimpleAnnotation offentlig Anvend () {// ...}}

Metoder og deres parametre:

@SimpleAnnotation offentlig ugyldighed aMethod (@SimpleAnnotation String param) {// ...}

Lokale variabler inklusive loop og ressourcevariabler:

@SimpleAnnotation int i = 10; for (@SimpleAnnotation int j = 0; j <i; j ++) {// ...} prøv (@SimpleAnnotation FileWriter forfatter = getWriter ()) {// ...} fangst (Undtagelse ex) {// .. .}

Andre annoteringstyper:

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

Og endda pakker gennem pakke-info.java fil:

@PackageAnnotation-pakke com.baeldung.interview.annotations;

Fra og med Java 8 kan de også anvendes på brug af typer. For at dette kan fungere, skal kommentaren angive et @Mål kommentar med en værdi på ElementType.USE:

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

Nu kan kommentaren anvendes til oprettelse af klasseinstanser:

ny @SimpleAnnotation Anvend ();

Type rollebesætninger:

aString = (@SimpleAnnotation String) noget;

Implementeringsklausul:

offentlig klasse SimpleList implementerer @SimpleAnnotation List {// ...}

Og kaster klausul:

ugyldigt aMethod () kaster @SimpleAnnotation Undtagelse {// ...}

Q6. Er der en måde at begrænse elementerne, hvor en kommentar kan anvendes?

Ja, den @Mål kommentar kan bruges til dette formål. Hvis vi forsøger at bruge en kommentar i en sammenhæng, hvor den ikke er relevant, udsender compileren en fejl.

Her er et eksempel for at begrænse brugen af @SimpleAnnotation kommentar til felterklæringer kun:

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

Vi kan passere flere konstanter, hvis vi vil gøre det anvendeligt i flere sammenhænge:

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

Vi kan endda lave en kommentar, så den ikke kan bruges til at kommentere noget. Dette kan være nyttigt, når de angivne typer udelukkende er beregnet til brug som medlemstype i komplekse kommentarer:

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

Q7. Hvad er metaanmærkninger?

Er annoteringer, der gælder for andre annoteringer.

Alle kommentarer, der ikke er markeret med @Mål, eller er markeret med det, men inkluderer ANNOTATION_TYPE konstant er også meta-annoteringer:

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

Q8. Hvad er gentagne kommentarer?

Dette er kommentarer, der kan anvendes mere end én gang på den samme elementerklæring.

Af kompatibilitetshensyn, da denne funktion blev introduceret i Java 8, gemmes gentagne kommentarer i en container kommentar der genereres automatisk af Java-kompilatoren. For at kompilatoren skal gøre dette, er der to trin til at erklære dem.

Først skal vi erklære en gentagelig kommentar:

@Repeatable (Schedules.class) public @interface Schedule {Strengetid () standard "morgen"; }

Derefter definerer vi den indeholdende kommentar med en obligatorisk værdi element, og hvis type skal være en matrix af den gentagelige annoteringstype:

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

Nu kan vi bruge @Schedule flere gange:

@Schedule @Schedule (time = "eftermiddag") @Schedule (time = "night") ugyldig planningMethod () {// ...}

Q9. Hvordan kan du hente kommentarer? Hvordan har dette at gøre med dets opbevaringspolitik?

Du kan bruge Reflection API eller en kommentarprocessor til at hente annoteringer.

Det @Tilbageholdelse kommentar og dens RetentionPolicy parameter påvirker, hvordan du kan hente dem. Der er tre konstanter i RetentionPolicy enum:

• RetentionPolicy.SOURCE - gør kommentaren til at blive kasseret af compileren, men annoteringsprocessorer kan læse dem
• RetentionPolicy.CLASS - angiver, at kommentaren føjes til klassefilen, men ikke er tilgængelig gennem refleksion
• RetentionPolicy.RUNTIME –Bemærkninger registreres i klassefilen af ​​compileren og opbevares af JVM ved kørsel, så de kan læses reflekterende

Her er et eksempel på en kode til at oprette en kommentar, der kan læses ved kørsel:

@Retention (RetentionPolicy.RUNTIME) offentlig @interface Beskrivelse {Strengværdi (); }

Nu kan annoteringer hentes gennem refleksion:

Beskrivelse beskrivelse = AnnotatedClass.class.getAnnotation (Description.class); System.out.println (beskrivelse.værdi ());

En annoteringsprocessor kan arbejde med RetentionPolicy.SOURCE, dette er beskrevet i artiklen Java Annotation Processing and Creating a Builder.

RetentionPolicy.CLASS kan bruges, når du skriver en Java-bytecode-parser.

Q10. Vil den følgende kode kompilere?

@Target ({ElementType.FIELD, ElementType.TYPE, ElementType.FIELD}) offentlig @interface TestAnnotation {int [] værdi () standard {}; }

Nej. Det er en kompileringstidsfejl, hvis den samme enumkonstant vises mere end en gang i en @Mål kommentar.

Fjernelse af duplikatkonstanten gør koden til at kompilere med succes:

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

Q11. Er det muligt at udvide kommentarerne?

Nej. Kommentarer strækker sig altid java.lang.annotation.Annotation, som angivet i Java Language Specification.

Hvis vi prøver at bruge strækker sig klausul i en annotationserklæring, får vi en kompileringsfejl:

public @interface AnAnnotation udvider OtherAnnotation {// Kompileringsfejl}

Konklusion

I denne artikel dækkede vi nogle af de ofte stillede spørgsmål, der dukkede op i tekniske interviews for Java-udviklere, vedrørende annoteringer. Dette er på ingen måde en udtømmende liste og bør kun betragtes som starten på yderligere forskning.

Vi i Baeldung ønsker dig succes i alle kommende interviews.

Næste » Top forårssamarbejdsspørgsmål « Tidligere Java-undtagelser Interviewspørgsmål (+ svar)