Pertanyaan Wawancara Anotasi Java (+ Jawaban)

Artikel ini adalah bagian dari serial: • Pertanyaan Wawancara Koleksi Java

• Pertanyaan Wawancara Sistem Jenis Java

• Pertanyaan Wawancara Konkurensi Java (+ Jawaban)

• Struktur Kelas Java dan Pertanyaan Wawancara Inisialisasi

• Java 8 Pertanyaan Wawancara (+ Jawaban)

• Manajemen Memori dalam Pertanyaan Wawancara Java (+ Jawaban)

• Pertanyaan Wawancara Umum Java (+ Jawaban)

• Pertanyaan Wawancara Kontrol Aliran Java (+ Jawaban)

• Pertanyaan Wawancara Pengecualian Jawa (+ Jawaban)

• Pertanyaan Wawancara Anotasi Jawa (+ Jawaban) (artikel saat ini) • Pertanyaan Wawancara Top Spring Framework

1. Perkenalan

Anotasi telah ada sejak Java 5, dan saat ini, mereka adalah konstruksi pemrograman di mana-mana yang memungkinkan pengayaan kode.

Dalam artikel ini, kami akan mengulas beberapa pertanyaan, tentang anotasi; yang sering ditanyakan pada wawancara teknis dan, jika sesuai; kami akan menerapkan contoh untuk memahami jawaban mereka dengan lebih baik.

2. Pertanyaan

P1. Apakah Anotasi Itu? Apa Kasus Penggunaan Khasnya?

Anotasi adalah metadata yang terikat pada elemen kode sumber program dan tidak berpengaruh pada operasi kode yang dioperasikannya.

Kasus penggunaan khas mereka adalah:

  • Informasi untuk kompilator - dengan anotasi, kompilator dapat mendeteksi kesalahan atau menyembunyikan peringatan
  • Waktu kompilasi dan pemrosesan waktu penerapan - alat perangkat lunak dapat memproses penjelasan dan menghasilkan kode, file konfigurasi, dll.
  • Pemrosesan runtime - penjelasan dapat diperiksa pada waktu proses untuk menyesuaikan perilaku program

P2. Jelaskan Beberapa Anotasi Berguna dari Perpustakaan Standar.

Ada beberapa penjelasan dalam paket java.lang dan java.lang.annotation , yang lebih umum termasuk tetapi tidak terbatas pada:

  • @Override - menandai bahwa metode dimaksudkan untuk mengganti elemen yang dideklarasikan dalam superclass. Jika gagal untuk mengganti metode dengan benar, kompilator akan mengeluarkan kesalahan
  • @Deprecated - menunjukkan bahwa elemen tidak digunakan lagi dan tidak boleh digunakan. Kompilator akan mengeluarkan peringatan jika program menggunakan metode, kelas, atau bidang yang ditandai dengan anotasi ini
  • @SuppressWarnings - memberi tahu kompilator untuk menyembunyikan peringatan tertentu. Paling umum digunakan saat berinteraksi dengan kode warisan yang ditulis sebelum obat generik muncul
  • @FunctionalInterface - diperkenalkan di Java 8, menunjukkan bahwa deklarasi type adalah antarmuka fungsional dan implementasinya dapat disediakan menggunakan Lambda Expression

P3. Bagaimana Cara Membuat Anotasi?

Anotasi adalah bentuk antarmuka yang antarmuka kata kuncinya diawali dengan @, dan yang isinya berisi deklarasi elemen jenis anotasi yang terlihat sangat mirip dengan metode:

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

Setelah anotasi ditentukan, Anda dapat mulai menggunakannya melalui kode Anda:

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

Perhatikan bahwa, saat memberikan beberapa nilai untuk elemen array, Anda harus mengapitnya dalam tanda kurung.

Secara opsional, nilai default dapat diberikan selama itu adalah ekspresi konstan untuk compiler:

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

Sekarang, Anda dapat menggunakan anotasi tanpa elemen tersebut:

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

Atau hanya beberapa di antaranya:

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

P4. Jenis Objek Apa yang Dapat Dikembalikan dari Deklarasi Metode Anotasi?

Tipe yang dikembalikan harus primitif, String , Class , Enum , atau array dari salah satu tipe sebelumnya. Jika tidak, kompilator akan menampilkan kesalahan.

Berikut contoh kode yang berhasil mengikuti prinsip ini:

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

Contoh berikutnya akan gagal untuk dikompilasi karena Object bukan tipe kembalian yang valid:

public @interface FailingAnnotation { Object complexity(); }

P5. Elemen Program Mana yang Dapat Dianotasi?

Anotasi dapat diterapkan di beberapa tempat di seluruh kode sumber. Mereka dapat diterapkan ke deklarasi kelas, konstruktor, dan bidang:

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

Metode dan parameternya:

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

Variabel lokal, termasuk loop dan variabel sumber:

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

Jenis anotasi lainnya:

@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

Pada artikel ini, kami membahas beberapa pertanyaan umum yang muncul dalam wawancara teknis untuk pengembang Java, mengenai anotasi. Ini sama sekali bukan daftar yang lengkap, dan seharusnya hanya dianggap sebagai awal dari penelitian lebih lanjut.

Kami, di Baeldung, berharap Anda sukses dalam wawancara yang akan datang.

Berikutnya » Pertanyaan Wawancara Top Spring Framework « Sebelumnya Pertanyaan Wawancara Pengecualian Java (+ Jawaban)