Soalan Temuduga Anotasi Java (+ Jawapan)

Artikel ini adalah sebahagian daripada siri: • Pertanyaan Temuduga Koleksi Java

• Soalan Temuduga Sistem Jenis Java

• Pertanyaan Temuduga Bersama Java (+ Jawapan)

• Soalan Temuduga Struktur dan Permulaan Kelas Java

• Soalan Temuduga Java 8 (+ Jawapan)

• Pengurusan Memori dalam Soalan Temuduga Java (+ Jawapan)

• Soalan Temuduga Generik Java (+ Jawapan)

• Soalan Temuduga Kawalan Aliran Java (+ Jawapan)

• Soalan Temuduga Pengecualian Java (+ Jawapan)

• Soalan Temuduga Anotasi Java (+ Jawapan) (artikel semasa) • Soalan Temuduga Rangka Musim Semi Teratas

1. Pengenalan

Anotasi telah wujud sejak Java 5, dan saat ini, mereka adalah konstruksi pengaturcaraan di mana-mana yang membolehkan memperkaya kod.

Dalam artikel ini, kami akan mengkaji beberapa soalan, mengenai anotasi; yang sering ditanya pada temu ramah teknikal dan, jika sesuai; kami akan melaksanakan contoh untuk memahami jawapan mereka dengan lebih baik.

2. Soalan

S1. Apa itu Anotasi? Apakah Kes Penggunaan Khasnya?

Anotasi adalah metadata yang terikat pada elemen kod sumber program dan tidak mempengaruhi operasi kod yang dikendalikannya.

Kes penggunaan biasa mereka adalah:

  • Maklumat untuk penyusun - dengan penjelasan, penyusun dapat mengesan ralat atau menekan peringatan
  • Pemprosesan waktu kompilasi dan penggunaan - alat perisian dapat memproses anotasi dan menghasilkan kod, fail konfigurasi, dll.
  • Pemprosesan jangka masa - anotasi dapat diperiksa pada waktu berjalan untuk menyesuaikan tingkah laku program

S2. Huraikan Beberapa Anotasi Berguna dari Pustaka Standard.

Terdapat beberapa anotasi dalam pakej anotasi java.lang dan java.lang . yang lebih biasa termasuk tetapi tidak terhad kepada:

  • @Override - menandakan bahawa kaedah dimaksudkan untuk mengatasi elemen yang dinyatakan dalam superclass. Sekiranya gagal mengganti kaedah dengan betul, penyusun akan mengeluarkan ralat
  • @Deprecated - menunjukkan bahawa elemen sudah tidak digunakan lagi dan tidak boleh digunakan. Penyusun akan mengeluarkan amaran jika program menggunakan kaedah, kelas, atau bidang yang ditandai dengan anotasi ini
  • @SuppressWarnings - memberitahu penyusun untuk menekan amaran tertentu. Paling sering digunakan ketika berinteraksi dengan kod warisan yang ditulis sebelum generik muncul
  • @FunctionalInterface - diperkenalkan di Java 8, menunjukkan bahawa deklarasi jenis adalah antara muka fungsional dan pelaksanaannya dapat disediakan menggunakan Lambda Expression

S3. Bagaimana Anda Boleh Membuat Anotasi?

Anotasi adalah satu bentuk antara muka yang mana kata kunci muka didahului dengan @, dan yang badan mengandungi jenis anotasi elemen pengisytiharan yang kelihatan hampir sama dengan kaedah:

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

Setelah penjelasan ditentukan, yon boleh mula menggunakannya melalui kod anda:

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

Perhatikan bahawa, apabila memberikan beberapa nilai untuk elemen array, anda mesti memasukkannya dalam kurungan.

Secara pilihan, nilai lalai dapat diberikan asalkan merupakan ungkapan tetap kepada penyusun:

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

Sekarang, anda boleh menggunakan anotasi tanpa elemen tersebut:

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

Atau hanya sebahagian dari mereka:

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

S4. Jenis Objek Apa yang Dapat Dikembalikan dari Deklarasi Kaedah Anotasi?

Jenis pengembalian mestilah primitif, String , Class , Enum , atau susunan salah satu daripada jenis sebelumnya. Jika tidak, penyusun akan membuang ralat.

Berikut adalah kod contoh yang berjaya mengikuti prinsip ini:

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

Contoh seterusnya akan gagal disusun kerana Objek bukan jenis pengembalian yang sah:

public @interface FailingAnnotation { Object complexity(); }

S5. Elemen Program mana yang Boleh Dianotasi?

Anotasi boleh digunakan di beberapa tempat di seluruh kod sumber. Mereka dapat diterapkan pada deklarasi kelas, konstruktor, dan bidang:

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

Kaedah dan parameternya:

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

Pemboleh ubah tempatan, termasuk pemboleh ubah gelung dan sumber:

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

Jenis anotasi lain:

@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

Dalam artikel ini, kami membahas beberapa pertanyaan yang sering diajukan dalam wawancara teknikal untuk pembangun Java, mengenai anotasi. Ini tidak semestinya daftar lengkap, dan hanya harus dianggap sebagai permulaan penyelidikan lebih lanjut.

Kami, di Baeldung, mengucapkan kejayaan dalam temu ramah yang akan datang.

Seterusnya » Soalan Temuduga Rangka Kerja Musim Semi Teratas « Soalan Temuduga Pengecualian Java Sebelumnya (+ Jawapan)